passenger 6.0.4 → 6.0.9

data/src/cxx_supportlib/vendor-modified/boost/memory_order.hpp

@@ -54,18 +54,12 @@ enum class memory_order : unsigned int
     seq_cst = 14 // acq_rel | 8
 };
 
-#if !defined(BOOST_NO_CXX17_INLINE_VARIABLES)
-#define BOOST_MEMORY_ORDER_INLINE_VARIABLE inline
-#else
-#define BOOST_MEMORY_ORDER_INLINE_VARIABLE
-#endif
-
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_relaxed = memory_order::relaxed;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_consume = memory_order::consume;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acquire = memory_order::acquire;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_release = memory_order::release;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acq_rel = memory_order::acq_rel;
-BOOST_MEMORY_ORDER_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_seq_cst = memory_order::seq_cst;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_relaxed = memory_order::relaxed;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_consume = memory_order::consume;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acquire = memory_order::acquire;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_release = memory_order::release;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_acq_rel = memory_order::acq_rel;
+BOOST_INLINE_VARIABLE BOOST_CONSTEXPR_OR_CONST memory_order memory_order_seq_cst = memory_order::seq_cst;
 
 #undef BOOST_MEMORY_ORDER_INLINE_VARIABLE
 

data/src/cxx_supportlib/vendor-modified/boost/move/algo/adaptive_merge.hpp

@@ -98,41 +98,22 @@ inline void adaptive_merge_final_merge( RandIt first
                                       , typename iterator_traits<RandIt>::size_type len2
                                       , typename iterator_traits<RandIt>::size_type collected
                                       , typename iterator_traits<RandIt>::size_type l_intbuf
-                                      , typename iterator_traits<RandIt>::size_type l_block
-                                      , bool use_internal_buf
+                                      , typename iterator_traits<RandIt>::size_type //l_block
+                                      , bool //use_internal_buf
                                       , bool xbuf_used
                                       , Compare comp
                                       , XBuf & xbuf
                                       )
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
-   (void)l_block;
    size_type n_keys = collected-l_intbuf;
    size_type len = len1+len2;
-   if(use_internal_buf){
-      if(xbuf_used){
-         xbuf.clear();
-         //Nothing to do
-         if(n_keys){
-            unstable_sort(first, first+n_keys, comp, xbuf);
-            stable_merge(first, first+n_keys, first+len, comp, xbuf);
-            BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A key mrg: ", len);
-         }
-      }
-      else{
-         xbuf.clear();
-         unstable_sort(first, first+collected, comp, xbuf);
-         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b srt: ", len);
-         stable_merge(first, first+collected, first+len, comp, xbuf);
-         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b mrg: ", len);
-      }
-   }
-   else{
+   if (!xbuf_used || n_keys) {
       xbuf.clear();
-      unstable_sort(first, first+collected, comp, xbuf);
+      const size_type middle = xbuf_used && n_keys ? n_keys: collected;
+      unstable_sort(first, first + middle, comp, xbuf);
       BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b srt: ", len);
-      stable_merge(first, first+collected, first+len1+len2, comp, xbuf);
-      BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A k/b mrg: ", len);
+      stable_merge(first, first + middle, first + len, comp, xbuf);
    }
    BOOST_MOVE_ADAPTIVE_SORT_PRINT_L1("   A fin mrg: ", len);
 }
@@ -168,8 +149,8 @@ inline SizeType adaptive_merge_n_keys_intbuf(SizeType &rl_block, SizeType len1,
    size_type l_block = rl_block;
    size_type l_intbuf = xbuf.capacity() >= l_block ? 0u : l_block;
 
-   while(xbuf.capacity() >= l_block*2){
-      l_block *= 2;
+   if (xbuf.capacity() > l_block){
+      l_block = xbuf.capacity();
    }
 
    //This is the minimum number of keys to implement the ideal algorithm
@@ -326,12 +307,38 @@ void adaptive_merge_impl
 template<class RandIt, class Compare>
 void adaptive_merge( RandIt first, RandIt middle, RandIt last, Compare comp
                 , typename iterator_traits<RandIt>::value_type* uninitialized = 0
-                , std::size_t uninitialized_len = 0)
+                , typename iterator_traits<RandIt>::size_type uninitialized_len = 0)
 {
    typedef typename iterator_traits<RandIt>::size_type  size_type;
    typedef typename iterator_traits<RandIt>::value_type value_type;
 
-   ::boost::movelib::detail_adaptive::adaptive_xbuf<value_type> xbuf(uninitialized, uninitialized_len);
+   if (first == middle || middle == last){
+      return;
+   }
+
+   //Reduce ranges to merge if possible
+   do {
+      if (comp(*middle, *first)){
+         break;
+      }
+      ++first;
+      if (first == middle)
+         return;
+   } while(1);
+
+   RandIt first_high(middle);
+   --first_high;
+   do {
+      --last;
+      if (comp(*last, *first_high)){
+         ++last;
+         break;
+      }
+      if (last == middle)
+         return;
+   } while(1);
+
+   ::boost::movelib::adaptive_xbuf<value_type, value_type*, size_type> xbuf(uninitialized, size_type(uninitialized_len));
    ::boost::movelib::detail_adaptive::adaptive_merge_impl(first, size_type(middle - first), size_type(last - middle), comp, xbuf);
 }
 

data/src/cxx_supportlib/vendor-modified/boost/move/algo/adaptive_sort.hpp

@@ -14,6 +14,7 @@
 
 #include <boost/move/detail/config_begin.hpp>
 #include <boost/move/algo/detail/adaptive_sort_merge.hpp>
+#include <boost/core/ignore_unused.hpp>
 
 namespace boost {
 namespace movelib {
@@ -148,7 +149,7 @@ typename iterator_traits<RandIt>::size_type
    }
    xbuf.clear();
    //2*l_build_buf or total already merged
-   return min_value(elements_in_blocks, 2*l_build_buf);
+   return min_value<size_type>(elements_in_blocks, 2*l_build_buf);
 }
 
 template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class XBuf>
@@ -165,7 +166,7 @@ void adaptive_sort_combine_blocks
    , Compare comp
    , bool merge_left)
 {
-   (void)xbuf;
+   boost::ignore_unused(xbuf);
    typedef typename iterator_traits<RandIt>::size_type   size_type;
 
    size_type const l_reg_combined   = 2*l_prev_merged;
@@ -174,25 +175,25 @@ void adaptive_sort_combine_blocks
    size_type const n_reg_combined = len/l_reg_combined;
    RandIt combined_first = first;
 
-   (void)l_total_combined;
+   boost::ignore_unused(l_total_combined);
    BOOST_ASSERT(l_total_combined <= len);
 
    size_type const max_i = n_reg_combined + (l_irreg_combined != 0);
 
    if(merge_left || !use_buf) {
-      for( size_type combined_i = 0; combined_i != max_i; ++combined_i, combined_first += l_reg_combined) {
+      for( size_type combined_i = 0; combined_i != max_i; ) {
          //Now merge blocks
          bool const is_last = combined_i==n_reg_combined;
          size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;
 
-         range_xbuf<RandIt, move_op> rbuf( (use_buf && xbuf_used) ? (combined_first-l_block) : combined_first, combined_first);
+         range_xbuf<RandIt, size_type, move_op> rbuf( (use_buf && xbuf_used) ? (combined_first-l_block) : combined_first, combined_first);
          size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
          combine_params( keys, key_comp, l_cur_combined
                         , l_prev_merged, l_block, rbuf
                         , n_block_a, n_block_b, l_irreg1, l_irreg2);   //Outputs
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A combpar:            ", len + l_block);
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first, combined_first + n_block_a*l_block+l_irreg1, comp));
-            BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first + n_block_a*l_block+l_irreg1, combined_first + n_block_a*l_block+l_irreg1+n_block_b*l_block+l_irreg2, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(combined_first, combined_first + n_block_a*l_block+l_irreg1, comp));
+            BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(combined_first + n_block_a*l_block+l_irreg1, combined_first + n_block_a*l_block+l_irreg1+n_block_b*l_block+l_irreg2, comp));
          if(!use_buf){
             merge_blocks_bufferless
                (keys, key_comp, combined_first, l_block, 0u, n_block_a, n_block_b, l_irreg2, comp);
@@ -202,26 +203,32 @@ void adaptive_sort_combine_blocks
                (keys, key_comp, combined_first, l_block, 0u, n_block_a, n_block_b, l_irreg2, comp, xbuf_used);
          }
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   After merge_blocks_L: ", len + l_block);
+         ++combined_i;
+         if(combined_i != max_i)
+            combined_first += l_reg_combined;
       }
    }
    else{
       combined_first += l_reg_combined*(max_i-1);
-      for( size_type combined_i = max_i; combined_i--; combined_first -= l_reg_combined) {
+      for( size_type combined_i = max_i; combined_i; ) {
+         --combined_i;
          bool const is_last = combined_i==n_reg_combined;
          size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;
 
          RandIt const combined_last(combined_first+l_cur_combined);
-         range_xbuf<RandIt, move_op> rbuf(combined_last, xbuf_used ? (combined_last+l_block) : combined_last);
+         range_xbuf<RandIt, size_type, move_op> rbuf(combined_last, xbuf_used ? (combined_last+l_block) : combined_last);
          size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
          combine_params( keys, key_comp, l_cur_combined
                         , l_prev_merged, l_block, rbuf
                         , n_block_a, n_block_b, l_irreg1, l_irreg2);  //Outputs
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   A combpar:            ", len + l_block);
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first, combined_first + n_block_a*l_block+l_irreg1, comp));
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first + n_block_a*l_block+l_irreg1, combined_first + n_block_a*l_block+l_irreg1+n_block_b*l_block+l_irreg2, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(combined_first, combined_first + n_block_a*l_block+l_irreg1, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(combined_first + n_block_a*l_block+l_irreg1, combined_first + n_block_a*l_block+l_irreg1+n_block_b*l_block+l_irreg2, comp));
          merge_blocks_right
             (keys, key_comp, combined_first, l_block, n_block_a, n_block_b, l_irreg2, comp, xbuf_used);
          BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   After merge_blocks_R: ", len + l_block);
+         if(combined_i)
+            combined_first -= l_reg_combined;
       }
    }
 }
@@ -263,7 +270,7 @@ bool adaptive_sort_combine_all_blocks
       //    Implies l_block == n_keys/2 && use_internal_buf == true
       //Otherwise, just give up and and use all keys to merge using rotations (use_internal_buf = false)
       bool use_internal_buf = false;
-      size_type const l_block = lblock_for_combine(l_intbuf, n_keys, 2*l_merged, use_internal_buf);
+      size_type const l_block = lblock_for_combine(l_intbuf, n_keys, size_type(2*l_merged), use_internal_buf);
       BOOST_ASSERT(!l_intbuf || (l_block == l_intbuf));
       BOOST_ASSERT(n == 0 || (!use_internal_buf || prev_use_internal_buf) );
       BOOST_ASSERT(n == 0 || (!use_internal_buf || l_prev_block == l_block) );
@@ -607,12 +614,12 @@ void adaptive_sort_impl
 template<class RandIt, class RandRawIt, class Compare>
 void adaptive_sort( RandIt first, RandIt last, Compare comp
                , RandRawIt uninitialized
-               , std::size_t uninitialized_len)
+               , typename iterator_traits<RandIt>::size_type uninitialized_len)
 {
    typedef typename iterator_traits<RandIt>::size_type  size_type;
    typedef typename iterator_traits<RandIt>::value_type value_type;
 
-   ::boost::movelib::detail_adaptive::adaptive_xbuf<value_type, RandRawIt> xbuf(uninitialized, uninitialized_len);
+   ::boost::movelib::adaptive_xbuf<value_type, RandRawIt, size_type> xbuf(uninitialized, uninitialized_len);
    ::boost::movelib::detail_adaptive::adaptive_sort_impl(first, size_type(last - first), comp, xbuf);
 }
 

data/src/cxx_supportlib/vendor-modified/boost/move/algo/detail/adaptive_sort_merge.hpp

@@ -52,6 +52,7 @@
 #include <boost/move/algo/detail/heap_sort.hpp>
 #include <boost/move/algo/detail/merge.hpp>
 #include <boost/move/algo/detail/is_sorted.hpp>
+#include <boost/core/ignore_unused.hpp>
 #include <boost/assert.hpp>
 #include <boost/cstdint.hpp>
 
@@ -143,236 +144,6 @@ typename iterator_traits<ForwardIt>::size_type
    return count;
 }
 
-template<class T, class RandRawIt = T*>
-class adaptive_xbuf
-{
-   adaptive_xbuf(const adaptive_xbuf &);
-   adaptive_xbuf & operator=(const adaptive_xbuf &);
-
-   public:
-   typedef RandRawIt iterator;
-
-   adaptive_xbuf()
-      : m_ptr(), m_size(0), m_capacity(0)
-   {}
-
-   adaptive_xbuf(RandRawIt raw_memory, std::size_t capacity)
-      : m_ptr(raw_memory), m_size(0), m_capacity(capacity)
-   {}
-
-   template<class RandIt>
-   void move_assign(RandIt first, std::size_t n)
-   {
-      if(n <= m_size){
-         boost::move(first, first+n, m_ptr);
-         std::size_t size = m_size;
-         while(size-- != n){
-            m_ptr[size].~T();
-         }
-         m_size = n;
-      }
-      else{
-         RandRawIt result = boost::move(first, first+m_size, m_ptr);
-         boost::uninitialized_move(first+m_size, first+n, result);
-         m_size = n;
-      }
-   }
-
-   template<class RandIt>
-   void push_back(RandIt first, std::size_t n)
-   {
-      BOOST_ASSERT(m_capacity - m_size >= n);
-      boost::uninitialized_move(first, first+n, m_ptr+m_size);
-      m_size += n;
-   }
-
-   template<class RandIt>
-   iterator add(RandIt it)
-   {
-      BOOST_ASSERT(m_size < m_capacity);
-      RandRawIt p_ret = m_ptr + m_size;
-      ::new(&*p_ret) T(::boost::move(*it));
-      ++m_size;
-      return p_ret;
-   }
-
-   template<class RandIt>
-   void insert(iterator pos, RandIt it)
-   {
-      if(pos == (m_ptr + m_size)){
-         this->add(it);
-      }
-      else{
-         this->add(m_ptr+m_size-1);
-         //m_size updated
-         boost::move_backward(pos, m_ptr+m_size-2, m_ptr+m_size-1);
-         *pos = boost::move(*it);
-      }
-   }
-
-   void set_size(std::size_t size)
-   {
-      m_size = size;
-   }
-
-   void shrink_to_fit(std::size_t const size)
-   {
-      if(m_size > size){
-         for(std::size_t szt_i = size; szt_i != m_size; ++szt_i){
-            m_ptr[szt_i].~T();
-         }
-         m_size = size;
-      }
-   }
-
-   void initialize_until(std::size_t const size, T &t)
-   {
-      BOOST_ASSERT(m_size < m_capacity);
-      if(m_size < size){
-         ::new((void*)&m_ptr[m_size]) T(::boost::move(t));
-         ++m_size;
-         for(; m_size != size; ++m_size){
-            ::new((void*)&m_ptr[m_size]) T(::boost::move(m_ptr[m_size-1]));
-         }
-         t = ::boost::move(m_ptr[m_size-1]);
-      }
-   }
-
-   private:
-   template<class RIt>
-   static bool is_raw_ptr(RIt)
-   {
-      return false;
-   }
-
-   static bool is_raw_ptr(T*)
-   {
-      return true;
-   }
-
-   public:
-   template<class U>
-   bool supports_aligned_trailing(std::size_t size, std::size_t trail_count) const
-   {
-      if(this->is_raw_ptr(this->data()) && m_capacity){
-         uintptr_t u_addr_sz = uintptr_t(&*(this->data()+size));
-         uintptr_t u_addr_cp = uintptr_t(&*(this->data()+this->capacity()));
-         u_addr_sz = ((u_addr_sz + sizeof(U)-1)/sizeof(U))*sizeof(U);
-         return (u_addr_cp >= u_addr_sz) && ((u_addr_cp - u_addr_sz)/sizeof(U) >= trail_count);
-      }
-      return false;
-   }
-
-   template<class U>
-   U *aligned_trailing() const
-   {
-      return this->aligned_trailing<U>(this->size());
-   }
-
-   template<class U>
-   U *aligned_trailing(std::size_t pos) const
-   {
-      uintptr_t u_addr = uintptr_t(&*(this->data()+pos));
-      u_addr = ((u_addr + sizeof(U)-1)/sizeof(U))*sizeof(U);
-      return (U*)u_addr;
-   }
-
-   ~adaptive_xbuf()
-   {
-      this->clear();
-   }
-
-   std::size_t capacity() const
-   {  return m_capacity;   }
-
-   iterator data() const
-   {  return m_ptr;   }
-
-   iterator end() const
-   {  return m_ptr+m_size;   }
-
-   std::size_t size() const
-   {  return m_size;   }
-
-   bool empty() const
-   {  return !m_size;   }
-
-   void clear()
-   {
-      this->shrink_to_fit(0u);
-   }
-
-   private:
-   RandRawIt m_ptr;
-   std::size_t m_size;
-   std::size_t m_capacity;
-};
-
-template<class Iterator, class Op>
-class range_xbuf
-{
-   range_xbuf(const range_xbuf &);
-   range_xbuf & operator=(const range_xbuf &);
-
-   public:
-   typedef typename iterator_traits<Iterator>::size_type size_type;
-   typedef Iterator iterator;
-
-   range_xbuf(Iterator first, Iterator last)
-      : m_first(first), m_last(first), m_cap(last)
-   {}
-
-   template<class RandIt>
-   void move_assign(RandIt first, std::size_t n)
-   {
-      BOOST_ASSERT(size_type(n) <= size_type(m_cap-m_first));
-      m_last = Op()(forward_t(), first, first+n, m_first);
-   }
-
-   ~range_xbuf()
-   {}
-
-   std::size_t capacity() const
-   {  return m_cap-m_first;   }
-
-   Iterator data() const
-   {  return m_first;   }
-
-   Iterator end() const
-   {  return m_last;   }
-
-   std::size_t size() const
-   {  return m_last-m_first;   }
-
-   bool empty() const
-   {  return m_first == m_last;   }
-
-   void clear()
-   {
-      m_last = m_first;
-   }
-
-   template<class RandIt>
-   iterator add(RandIt it)
-   {
-      Iterator pos(m_last);
-      *pos = boost::move(*it);
-      ++m_last;
-      return pos;
-   }
-
-   void set_size(std::size_t size)
-   {
-      m_last  = m_first;
-      m_last += size;
-   }
-
-   private:
-   Iterator const m_first;
-   Iterator m_last;
-   Iterator const m_cap;
-};
-
 
 template<class RandIt, class Compare>
 RandIt skip_until_merge
@@ -407,6 +178,49 @@ void swap_and_update_key
    }
 }
 
+template<class RandItKeys>
+void update_key
+(RandItKeys const key_next
+   , RandItKeys const key_range2
+   , RandItKeys &key_mid)
+{
+   if (key_next != key_range2) {
+      ::boost::adl_move_swap(*key_next, *key_range2);
+      if (key_next == key_mid) {
+         key_mid = key_range2;
+      }
+      else if (key_mid == key_range2) {
+         key_mid = key_next;
+      }
+   }
+}
+
+template<class RandItKeys, class RandIt, class RandIt2, class Op>
+RandIt2 buffer_and_update_key
+(RandItKeys const key_next
+   , RandItKeys const key_range2
+   , RandItKeys &key_mid
+   , RandIt begin
+   , RandIt end
+   , RandIt with
+   , RandIt2 buffer
+   , Op op)
+{
+   if (begin != with) {
+      while(begin != end) {
+         op(three_way_t(), begin++, with++, buffer++);
+      }
+      ::boost::adl_move_swap(*key_next, *key_range2);
+      if (key_next == key_mid) {
+         key_mid = key_range2;
+      }
+      else if (key_mid == key_range2) {
+         key_mid = key_next;
+      }
+   }
+   return buffer;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 //
 //                         MERGE BUFFERLESS
@@ -457,7 +271,7 @@ static SizeType needed_keys_count(SizeType n_block_a, SizeType n_block_b)
 template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
 typename iterator_traits<RandIt>::size_type
    find_next_block
-      ( RandItKeys key_first
+      ( RandItKeys const key_first
       , KeyCompare key_comp
       , RandIt const first
       , typename iterator_traits<RandIt>::size_type const l_block
@@ -488,7 +302,7 @@ typename iterator_traits<RandIt>::size_type
 
 template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
 void merge_blocks_bufferless
-   ( RandItKeys key_first
+   ( RandItKeys const key_first
    , KeyCompare key_comp
    , RandIt const first
    , typename iterator_traits<RandIt>::size_type const l_block
@@ -499,7 +313,8 @@ void merge_blocks_bufferless
    , Compare comp)
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
-   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b);
+   ::boost::ignore_unused(key_count);
    //BOOST_ASSERT(n_block_a || n_block_b);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted_and_unique(key_first, key_first + key_count, key_comp));
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
@@ -515,11 +330,11 @@ void merge_blocks_bufferless
       RandItKeys key_range2(key_first);
 
       size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
-      size_type max_check = min_value(min_check+1, n_block_left);
+      size_type max_check = min_value<size_type>(min_check+1, n_block_left);
       for (RandIt f = first+l_irreg1; n_block_left; --n_block_left, ++key_range2, f += l_block, min_check -= min_check != 0, max_check -= max_check != 0) {
          size_type const next_key_idx = find_next_block(key_range2, key_comp, f, l_block, min_check, max_check, comp);
          RandItKeys const key_next(key_range2 + next_key_idx);
-         max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+         max_check = min_value<size_type>(max_value<size_type>(max_check, next_key_idx+size_type(2)), n_block_left);
 
          RandIt const first_min = f + next_key_idx*l_block;
 
@@ -531,67 +346,28 @@ void merge_blocks_bufferless
          n_bef_irreg2 += l_irreg_pos_count;
 
          swap_and_update_key(key_next, key_range2, key_mid, f, f + l_block, first_min);
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(f, f+l_block, comp));
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_min, first_min + l_block, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(f, f+l_block, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first_min, first_min + l_block, comp));
          BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((f == (first+l_irreg1)) || !comp(*f, *(f-l_block)));
       }
    }
-   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first+l_irreg1+n_bef_irreg2*l_block, first_irr2, comp));
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first+l_irreg1+n_bef_irreg2*l_block, first_irr2, comp));
 
    RandIt first1 = first;
    RandIt last1  = first+l_irreg1;
    RandItKeys const key_end (key_first+n_bef_irreg2);
    bool is_range1_A = true;
 
-   for( ; key_first != key_end; ++key_first){
-      bool is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_first, *key_mid);
+   for(RandItKeys key_next = key_first; key_next != key_end; ++key_next){
+      bool is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_next, *key_mid);
       first1 = is_range1_A == is_range2_A
          ? last1 : partial_merge_bufferless(first1, last1, last1 + l_block, &is_range1_A, comp);
       last1 += l_block;
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, first1, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, first1, comp));
    }
 
    merge_bufferless(is_range1_A ? first1 : last1, first_irr2, last_irr2, comp);
-   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, last_irr2, comp));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//                            BUFFERED MERGE
-//
-///////////////////////////////////////////////////////////////////////////////
-template<class RandIt, class Compare, class Op, class Buf>
-void op_buffered_merge
-      ( RandIt first, RandIt const middle, RandIt last
-      , Compare comp, Op op
-      , Buf &xbuf)
-{
-   if(first != middle && middle != last && comp(*middle, middle[-1])){
-      typedef typename iterator_traits<RandIt>::size_type   size_type;
-      size_type const len1 = size_type(middle-first);
-      size_type const len2 = size_type(last-middle);
-      if(len1 <= len2){
-         first = boost::movelib::upper_bound(first, middle, *middle, comp);
-         xbuf.move_assign(first, size_type(middle-first));
-         op_merge_with_right_placed
-            (xbuf.data(), xbuf.end(), first, middle, last, comp, op);
-      }
-      else{
-         last = boost::movelib::lower_bound(middle, last, middle[-1], comp);
-         xbuf.move_assign(middle, size_type(last-middle));
-         op_merge_with_left_placed
-            (first, middle, last, xbuf.data(), xbuf.end(), comp, op);
-      }
-   }
-}
-
-template<class RandIt, class Compare, class XBuf>
-void buffered_merge
-      ( RandIt first, RandIt const middle, RandIt last
-      , Compare comp
-      , XBuf &xbuf)
-{
-   op_buffered_merge(first, middle, last, comp, move_op(), xbuf);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, last_irr2, comp));
 }
 
 // Complexity: 2*distance(first, last)+max_collected^2/2
@@ -828,7 +604,8 @@ void unstable_sort( RandIt first, RandIt last
                     , Comp comp
                     , XBuf & xbuf)
 {
-   heap_sort(first, last, comp);(void)xbuf;
+   heap_sort(first, last, comp);
+   ::boost::ignore_unused(xbuf);
 }
 
 template<class RandIt, class Compare, class XBuf>
@@ -841,14 +618,16 @@ void stable_merge
    typedef typename iterator_traits<RandIt>::size_type   size_type;
    size_type const len1  = size_type(middle-first);
    size_type const len2  = size_type(last-middle);
-   size_type const l_min = min_value(len1, len2);
+   size_type const l_min = min_value<size_type>(len1, len2);
    if(xbuf.capacity() >= l_min){
       buffered_merge(first, middle, last, comp, xbuf);
       xbuf.clear();
    }
    else{
-      merge_bufferless(first, middle, last, comp);
+      //merge_bufferless(first, middle, last, comp);
+      merge_adaptive_ONlogN(first, middle, last, comp, xbuf.begin(), xbuf.capacity());
    }
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, last, boost::movelib::unantistable(comp)));
 }
 
 template<class RandIt, class Comp, class XBuf>
@@ -1164,19 +943,21 @@ OutputIt op_merge_blocks_with_irreg
 
    for(; n_block_left; --n_block_left, ++key_first, min_check -= min_check != 0, max_check -= max_check != 0){
       size_type next_key_idx = find_next_block(key_first, key_comp, first_reg, l_block, min_check, max_check, comp);  
-      max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+      max_check = min_value<size_type>(max_value<size_type>(max_check, next_key_idx+size_type(2)), n_block_left);
       RandIt const last_reg  = first_reg + l_block;
       RandIt first_min = first_reg + next_key_idx*l_block;
-      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last_min  = first_min + l_block;
+      boost::ignore_unused(last_min);
 
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_reg, last_reg, comp));
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!next_key_idx || is_sorted(first_min, last_min, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first_reg, last_reg, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!next_key_idx || boost::movelib::is_sorted(first_min, last_min, comp));
       BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((!next_key_idx || !comp(*first_reg, *first_min )));
 
-      OutputIt orig_dest = dest; (void)orig_dest;
+      OutputIt orig_dest = dest;
+      boost::ignore_unused(orig_dest);
       dest = next_key_idx ? op_partial_merge_and_swap(first_irr, last_irr, first_reg, last_reg, first_min, dest, comp, op, is_stable)
                           : op_partial_merge         (first_irr, last_irr, first_reg, last_reg, dest, comp, op, is_stable);
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(orig_dest, dest, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(orig_dest, dest, comp));
 
       if(first_reg == dest){
          dest = next_key_idx ? ::boost::adl_move_swap_ranges(first_min, last_min, first_reg)
@@ -1190,7 +971,7 @@ OutputIt op_merge_blocks_with_irreg
       RandItKeys const key_next(key_first + next_key_idx);
       swap_and_update_key(key_next, key_first, key_mid, last_reg, last_reg, first_min);
 
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(orig_dest, dest, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(orig_dest, dest, comp));
       first_reg = last_reg;
    }
    return dest;
@@ -1219,7 +1000,9 @@ void op_merge_blocks_left
    , Compare comp, Op op)
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
-   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b);
+   boost::ignore_unused(key_count);
+
 //   BOOST_ASSERT(n_block_a || n_block_b);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted_and_unique(key_first, key_first + key_count, key_comp));
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
@@ -1242,17 +1025,19 @@ void op_merge_blocks_left
    //Process all regular blocks before the irregular B block
    ////////////////////////////////////////////////////////////////////////////
    size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
-   size_type max_check = min_value(min_check+1, n_block_left);
+   size_type max_check = min_value<size_type>(min_check+size_type(1), n_block_left);
    for (; n_block_left; --n_block_left, ++key_range2, min_check -= min_check != 0, max_check -= max_check != 0) {
       size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
-      max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+      max_check = min_value<size_type>(max_value<size_type>(max_check, next_key_idx+size_type(2)), n_block_left);
       RandIt const first_min = first2 + next_key_idx*l_block;
-      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last_min  = first_min + l_block;
+
+      boost::ignore_unused(last_min);
       RandIt const last2  = first2 + l_block;
 
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first1, last1, comp));
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first2, last2, comp));
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_left || is_sorted(first_min, last_min, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first1, last1, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first2, last2, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_left || boost::movelib::is_sorted(first_min, last_min, comp));
 
       //Check if irregular b block should go here.
       //If so, break to the special code handling the irregular block
@@ -1292,8 +1077,9 @@ void op_merge_blocks_left
             unmerged = op_partial_merge_and_save
                (buffer, buffer+(last1-first1), first2, last2, first_min, buf_beg, buf_end, comp, op, is_range1_A);
          }
-         (void)unmerged;
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first-l_block, unmerged, comp));
+
+         boost::ignore_unused(unmerged);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first-l_block, unmerged, comp));
 
          swap_and_update_key( key_next, key_range2, key_mid, first2, last2
                             , last_min - size_type(last2 - first2));
@@ -1342,7 +1128,7 @@ void op_merge_blocks_left
    else if(!is_buffer_middle){
       buffer = op(forward_t(), first1, last1, buffer);
    }
-   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first-l_block, buffer, comp));
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first-l_block, buffer, comp));
 
    ////////////////////////////////////////////////////////////////////////////
    //Process irregular B block and remaining A blocks
@@ -1350,8 +1136,9 @@ void op_merge_blocks_left
    buffer = op_merge_blocks_with_irreg
       ( key_range2, key_mid, key_comp, first2, first_irr2, last_irr2
       , buffer, l_block, n_block_left, min_check, max_check, comp, false, op);
-   buffer = op(forward_t(), first_irr2, last_irr2, buffer);(void)buffer;
-   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first-l_block, buffer, comp));
+   buffer = op(forward_t(), first_irr2, last_irr2, buffer);
+   boost::ignore_unused(buffer);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first-l_block, buffer, comp));
 }
 
 // first - first element to merge.
@@ -1440,7 +1227,8 @@ void op_merge_blocks_with_buf
    , RandItBuf const buf_first)
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
-   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b);
+   boost::ignore_unused(key_count);
    //BOOST_ASSERT(n_block_a || n_block_b);
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted_and_unique(key_first, key_first + key_count, key_comp));
    BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
@@ -1457,6 +1245,8 @@ void op_merge_blocks_with_buf
    RandIt first2 = last1;
    RandIt const first_irr2 = first2 + n_block_left*l_block;
    bool is_range1_A = true;
+   const size_type len = l_block * n_block_a + l_block * n_block_b + l_irreg1 + l_irreg2;
+   boost::ignore_unused(len);
 
    RandItKeys key_range2(key_first);
 
@@ -1464,18 +1254,20 @@ void op_merge_blocks_with_buf
    //Process all regular blocks before the irregular B block
    ////////////////////////////////////////////////////////////////////////////
    size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
-   size_type max_check = min_value(min_check+1, n_block_left);
+   size_type max_check = min_value<size_type>(min_check+size_type(1), n_block_left);
    for (; n_block_left; --n_block_left, ++key_range2, min_check -= min_check != 0, max_check -= max_check != 0) {
       size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
-      max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+      max_check = min_value<size_type>(max_value<size_type>(max_check, next_key_idx+size_type(2)), n_block_left);
       RandIt       first_min = first2 + next_key_idx*l_block;
-      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last_min  = first_min + l_block;
+      boost::ignore_unused(last_min);
       RandIt const last2  = first2 + l_block;
 
-      bool const buffer_empty = buffer == buffer_end; (void)buffer_empty;
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(buffer_empty ? is_sorted(first1, last1, comp) : is_sorted(buffer, buffer_end, comp));
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first2, last2, comp));
-      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_left || is_sorted(first_min, last_min, comp));
+      bool const buffer_empty = buffer == buffer_end;
+      boost::ignore_unused(buffer_empty);
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(buffer_empty ? boost::movelib::is_sorted(first1, last1, comp) : boost::movelib::is_sorted(buffer, buffer_end, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first2, last2, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_left || boost::movelib::is_sorted(first_min, last_min, comp));
 
       //Check if irregular b block should go here.
       //If so, break to the special code handling the irregular block
@@ -1491,64 +1283,74 @@ void op_merge_blocks_with_buf
          BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((first1 == last1) || (buffer_empty ? !comp(*first_min, last1[-1]) : !comp(*first_min, buffer_end[-1])));
          //If buffered, put those elements in place
          RandIt res = op(forward_t(), buffer, buffer_end, first1);
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_fwd: ", len);
          buffer    = buffer_end = buf_first;
-         BOOST_ASSERT(buffer_empty || res == last1); (void)res;
-         swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first2, last2, comp));
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_min, last_min, comp));
+         BOOST_ASSERT(buffer_empty || res == last1);
+         boost::ignore_unused(res);
+         //swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
+         buffer_end = buffer_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min, buffer = buf_first, op);
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_swp: ", len);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first2, last2, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first_min, last_min, comp));
          first1 = first2;
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, first1, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, first1, comp));
       }
       else {
          RandIt const unmerged = op_partial_merge_and_save(first1, last1, first2, last2, first_min, buffer, buffer_end, comp, op, is_range1_A);
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_mrs: ", len);
          bool const is_range_1_empty = buffer == buffer_end;
          BOOST_ASSERT(is_range_1_empty || (buffer_end-buffer) == (last1+l_block-unmerged));
          if(is_range_1_empty){
             buffer    = buffer_end = buf_first;
             first_min = last_min - (last2 - first2);
+            //swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
+            buffer_end = buffer_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min, buf_first, op);
          }
          else{
             first_min = last_min;
+            //swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
+            update_key(key_next, key_range2, key_mid);
          }
          BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!is_range_1_empty || (last_min-first_min) == (last2-unmerged));
-         swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
-
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_min, last_min, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_swp: ", len);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first_min, last_min, comp));
          is_range1_A ^= is_range_1_empty;
          first1 = unmerged;
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, unmerged, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, unmerged, comp));
       }
       BOOST_ASSERT( (is_range2_A && n_block_a_left) || (!is_range2_A && n_block_b_left));
       is_range2_A ? --n_block_a_left : --n_block_b_left;
       last1 += l_block;
       first2 = last2;
    }
-
-   RandIt res = op(forward_t(), buffer, buffer_end, first1); (void)res;
-   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, res, comp));
+   RandIt res = op(forward_t(), buffer, buffer_end, first1);
+   boost::ignore_unused(res);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, res, comp));
+   BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_fwd: ", len);
 
    ////////////////////////////////////////////////////////////////////////////
    //Process irregular B block and remaining A blocks
    ////////////////////////////////////////////////////////////////////////////
    RandIt const last_irr2 = first_irr2 + l_irreg2;
    op(forward_t(), first_irr2, first_irr2+l_irreg2, buf_first);
+   BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_fwir:", len);
    buffer = buf_first;
    buffer_end = buffer+l_irreg2;
 
    reverse_iterator<RandItBuf> rbuf_beg(buffer_end);
    RandIt dest = op_merge_blocks_with_irreg
       ((make_reverse_iterator)(key_first + n_block_b + n_block_a), (make_reverse_iterator)(key_mid), inverse<KeyCompare>(key_comp)
-      , (make_reverse_iterator)(first_irr2), rbuf_beg
-      , (make_reverse_iterator)(buffer), (make_reverse_iterator)(last_irr2)
+      , (make_reverse_iterator)(first_irr2), rbuf_beg, (make_reverse_iterator)(buffer), (make_reverse_iterator)(last_irr2)
       , l_block, n_block_left, 0, n_block_left
       , inverse<Compare>(comp), true, op).base();
-   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(dest, last_irr2, comp));
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(dest, last_irr2, comp));
+   BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_blocks_w_irg: ", len);
 
    buffer_end = rbuf_beg.base();
    BOOST_ASSERT((dest-last1) == (buffer_end-buffer));
    op_merge_with_left_placed(is_range1_A ? first1 : last1, last1, dest, buffer, buffer_end, comp, op);
-
-   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, last_irr2, comp));
+   BOOST_MOVE_ADAPTIVE_SORT_PRINT_L2("   merge_with_left_plc:", len);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(first, last_irr2, comp));
 }
 
 //////////////////////////////////
@@ -1662,17 +1464,17 @@ typename iterator_traits<RandIt>::size_type
       RandIt pos = first_block;
       while((elements_in_blocks - p0) > 2*l_merged) {
          op_merge_left(pos-l_merged, pos, pos+l_merged, pos+2*l_merged, comp, op);
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(pos-l_merged, pos+l_merged, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(pos-l_merged, pos+l_merged, comp));
          p0 += 2*l_merged;
          pos = first_block+p0;
       }
       if((elements_in_blocks-p0) > l_merged) {
          op_merge_left(pos-l_merged, pos, pos+l_merged, first_block+elements_in_blocks, comp, op);
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(pos-l_merged, pos-l_merged+(first_block+elements_in_blocks-pos), comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(pos-l_merged, pos-l_merged+(first_block+elements_in_blocks-pos), comp));
       }
       else {
          op(forward_t(), pos, first_block+elements_in_blocks, pos-l_merged);
-         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(pos-l_merged, first_block+elements_in_blocks-l_merged, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(boost::movelib::is_sorted(pos-l_merged, first_block+elements_in_blocks-l_merged, comp));
       }
       first_block -= l_merged;
       l_left_space -= l_merged;