diff --git a/examples/cai_1d_heat.cpp b/examples/cai_1d_heat.cpp
index e0913467..d207050d 100644
--- a/examples/cai_1d_heat.cpp
+++ b/examples/cai_1d_heat.cpp
@@ -1,4 +1,4 @@
-///usr/bin/c++ -std=c++23 $0 -I../include && ./a.out | gnuplot -persist; exit
+///usr/bin/clang++ -std=c++23 $0 -I../include && ./a.out | gnuplot -persist; exit
 #include <boost/multi/array.hpp>
 
 #include <cmath>  // for std::exp
@@ -19,6 +19,16 @@ void plot(auto const& x, auto const& f, std::string const& title = "") {
 			  << "pause 0.1\n";
 }
 
+template<class Range, typename T>
+auto append(Range const& range, T const& value) {
+	return stv::iota(typename Range::size_type{}, range.size() + 1) | stv::transform([&](auto i) -> decltype(auto) {return (i<range.size()-1)?range[i]:value;});
+}
+
+template<class Range, typename T>
+auto prepend(Range const& range, T const& value) {
+	return stv::iota(typename Range::size_type{}, range.size() + 1) | stv::transform([&](auto i) -> decltype(auto) {return (i==0)?value:range[i-1];});
+}
+
 auto main() -> int {
 
 	using multi::operator+;
@@ -36,12 +46,10 @@ auto main() -> int {
 	// f_my_left = [NaN, f(1:end-1)];
 	// f_my_right = [f(2:end), NaN];
 	// d2f = (f_my_right - 2*f + f_my_left)/(dx^2);
-	multi::array<double, 1> f_my_left(f.extensions());
-	f_my_left({1, f.size()}) = f.taked(f.size() - 1);
-	multi::array<double, 1> f_my_right(f.extensions());
-	f_my_right({0, f.size() - 1}) = f.dropped(1);
-
+	auto f_my_left = +prepend(f.taked(f.size() - 1), NAN);
+	auto f_my_right = +append(f.dropped(1), NAN);
 	auto d2f = +stv::zip_transform([dx2 = dx * dx](auto r, auto m, auto l) { return (r - 2 * m + l) / dx2; }, f_my_right, f, f_my_left);
+
 	plot(x, d2f);
 
 	// dt = 0.01; D = 1;
diff --git a/include/boost/multi/adaptors/blas/gemm.hpp b/include/boost/multi/adaptors/blas/gemm.hpp
index ebde4372..5dc521e5 100644
--- a/include/boost/multi/adaptors/blas/gemm.hpp
+++ b/include/boost/multi/adaptors/blas/gemm.hpp
@@ -208,7 +208,7 @@ class gemm_iterator {
 	using value_type = typename std::iterator_traits<ItA>::value_type;
 	using pointer = std::nullptr_t;
 	using reference = gemm_reference<decltype((*b_begin_).extensions())>;
-	using iterator_category = typename std::iterator_traits<ItA>::iterator_category;  // std::random_access_iterator_tag;
+	using iterator_category = typename std::iterator_traits<ItB>::iterator_category;  // std::random_access_iterator_tag;
 
 	static_assert( std::is_base_of<std::random_access_iterator_tag, typename std::iterator_traits<gemm_iterator>::iterator_category>{} );
 
diff --git a/include/boost/multi/array.hpp b/include/boost/multi/array.hpp
index ed6089b2..91b62449 100644
--- a/include/boost/multi/array.hpp
+++ b/include/boost/multi/array.hpp
@@ -229,8 +229,8 @@ struct static_array  // NOLINT(fuchsia-multiple-inheritance) : multiple inherita
 	template<class It, class = typename std::iterator_traits<std::decay_t<It>>::difference_type>
 	constexpr explicit static_array(It first, It last, allocator_type const& alloc)
 	: array_alloc{alloc}, ref{
-		                      array_alloc::allocate(static_cast<typename multi::allocator_traits<allocator_type>::size_type>(layout_type{index_extension{adl_distance(first, last)} * multi::extensions(*first)}.num_elements())),
-		                      index_extension{adl_distance(first, last)} * multi::extensions(*first)} {
+		                      array_alloc::allocate(static_cast<typename multi::allocator_traits<allocator_type>::size_type>(layout_type{index_extension(adl_distance(first, last)) * multi::extensions(*first)}.num_elements())),
+		                      index_extension(adl_distance(first, last)) * multi::extensions(*first)} {
 	#if defined(__clang__) && defined(__CUDACC__)
 		// TODO(correaa) add workaround for non-default constructible type and use adl_alloc_uninitialized_default_construct_n
 		if constexpr(! std::is_trivially_default_constructible_v<typename static_array::element_type> && ! multi::force_element_trivial_default_construction<typename static_array::element_type> ) {
@@ -1561,7 +1561,8 @@ template<typename T, dimensionality_type D, typename P> array(subarray<T, D, P>)
 template<
 	class Range, 
 	std::enable_if_t<!has_extensions<Range>::value, int> = 0,
-	typename V = typename std::iterator_traits<decltype(::std::begin(std::declval<Range const&>()))>::value_type
+	typename V = decltype(*::std::begin(std::declval<Range const&>()))
+	// typename V = typename std::iterator_traits<decltype(::std::begin(std::declval<Range const&>()))>::value_type
 >
 array(Range) -> array<V, 1>;
 
diff --git a/include/boost/multi/detail/adl.hpp b/include/boost/multi/detail/adl.hpp
index cc513cca..d220ec18 100644
--- a/include/boost/multi/detail/adl.hpp
+++ b/include/boost/multi/detail/adl.hpp
@@ -459,13 +459,14 @@ auto alloc_uninitialized_fill_n(Alloc& alloc, ForwardIt first, Size n, T const&
 }  // end namespace xtd
 
 class adl_distance_t {
-	template<class... As>          constexpr auto _(priority<1>/**/,        As&&... args) const BOOST_MULTI_DECLRETURN(              std::    distance(std::forward<As>(args)...))
-	template<class... As>          constexpr auto _(priority<2>/**/,        As&&... args) const BOOST_MULTI_DECLRETURN(                       distance(std::forward<As>(args)...))
-	template<class T, class... As> constexpr auto _(priority<3>/**/, T&& arg, As&&... args) const BOOST_MULTI_DECLRETURN(  std::decay_t<T>::  distance(std::forward<T>(arg), std::forward<As>(args)...))
-	template<class T, class... As> constexpr auto _(priority<4>/**/, T&& arg, As&&... args) const BOOST_MULTI_DECLRETURN(std::forward<T>(arg).distance(std::forward<As>(args)...))
+	template<class... As>          constexpr auto _(priority<1>/**/,          As&&... args) const BOOST_MULTI_DECLRETURN(              std::    distance(std::forward<As>(args)...))
+	template<class... As>          constexpr auto _(priority<2>/**/,          As&&... args) const BOOST_MULTI_DECLRETURN(                       distance(std::forward<As>(args)...))
+	template<class It1, class It2> constexpr auto _(priority<3>/**/, It1 it1, It2 it2     ) const BOOST_MULTI_DECLRETURN(it2 - it1)
+	template<class T, class... As> constexpr auto _(priority<4>/**/, T&& arg, As&&... args) const BOOST_MULTI_DECLRETURN(  std::decay_t<T>::  distance(std::forward<T>(arg), std::forward<As>(args)...))
+	template<class T, class... As> constexpr auto _(priority<5>/**/, T&& arg, As&&... args) const BOOST_MULTI_DECLRETURN(std::forward<T>(arg).distance(std::forward<As>(args)...))
 
  public:
-	template<class... As> constexpr auto operator()(As&&... args) const BOOST_MULTI_DECLRETURN(_(priority<4>{}, std::forward<As>(args)...))
+	template<class... As> constexpr auto operator()(As&&... args) const BOOST_MULTI_DECLRETURN(_(priority<5>{}, std::forward<As>(args)...))
 };
 inline constexpr adl_distance_t adl_distance;