//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2025-2026. 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)
//
// See http://www.boost.org/libs/container for documentation.
//
//////////////////////////////////////////////////////////////////////////////

#include <algorithm>
#include <vector>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <utility>
#include <typeinfo>

#include <boost/container/deque.hpp>
#include <boost/container/experimental/nest.hpp>
#include <boost/move/detail/nsec_clock.hpp>

#include <boost/container/experimental/segmented_all_of.hpp>
#include <boost/container/experimental/segmented_any_of.hpp>
#include <boost/container/experimental/segmented_copy.hpp>
#include <boost/container/experimental/segmented_copy_if.hpp>
#include <boost/container/experimental/segmented_copy_n.hpp>
#include <boost/container/experimental/segmented_count.hpp>
#include <boost/container/experimental/segmented_count_if.hpp>
#include <boost/container/experimental/segmented_equal.hpp>
#include <boost/container/experimental/segmented_fill.hpp>
#include <boost/container/experimental/segmented_fill_n.hpp>
#include <boost/container/experimental/segmented_find.hpp>
#include <boost/container/experimental/segmented_find_if.hpp>
#include <boost/container/experimental/segmented_find_if_not.hpp>
#include <boost/container/experimental/segmented_for_each.hpp>
#include <boost/container/experimental/segmented_generate.hpp>
#include <boost/container/experimental/segmented_generate_n.hpp>
#include <boost/container/experimental/segmented_is_partitioned.hpp>
#include <boost/container/experimental/segmented_is_sorted.hpp>
#include <boost/container/experimental/segmented_merge.hpp>
#include <boost/container/experimental/segmented_mismatch.hpp>
#include <boost/container/experimental/segmented_none_of.hpp>
#include <boost/container/experimental/segmented_is_sorted_until.hpp>
#include <boost/container/experimental/segmented_partition.hpp>
#include <boost/container/experimental/segmented_partition_copy.hpp>
#include <boost/container/experimental/segmented_partition_point.hpp>
#include <boost/container/experimental/segmented_remove.hpp>
#include <boost/container/experimental/segmented_remove_if.hpp>
#include <boost/container/experimental/segmented_remove_copy.hpp>
#include <boost/container/experimental/segmented_remove_copy_if.hpp>
#include <boost/container/experimental/segmented_replace.hpp>
#include <boost/container/experimental/segmented_replace_if.hpp>
#include <boost/container/experimental/segmented_reverse.hpp>
#include <boost/container/experimental/segmented_reverse_copy.hpp>
#include <boost/container/experimental/segmented_search.hpp>
#include <boost/container/experimental/segmented_search_n.hpp>
#include <boost/container/experimental/segmented_set_difference.hpp>
#include <boost/container/experimental/segmented_set_intersection.hpp>
#include <boost/container/experimental/segmented_set_symmetric_difference.hpp>
#include <boost/container/experimental/segmented_set_union.hpp>
#include <boost/container/experimental/segmented_stable_partition.hpp>
#include <boost/container/experimental/segmented_swap_ranges.hpp>
#include <boost/container/experimental/segmented_transform.hpp>


using boost::move_detail::cpu_timer;
using boost::move_detail::cpu_times;
using boost::move_detail::nanosecond_type;

namespace bc = boost::container;

volatile int sink = 0;

void clobber() {
#if defined(_MSC_VER)
   _ReadWriteBarrier();
#else
    asm volatile("" : : : "memory");
#endif
}

inline void escape(void* p)
{
   #if defined(_MSC_VER)
   sink = *static_cast<int*>(p);
   #elif defined(__GNUC__)
   asm volatile("" : : "g"(p) : "memory");
   #endif
}

//////////////////////////////////////////////////////////////////////////////
// Value types
//////////////////////////////////////////////////////////////////////////////

class MyInt
{
   int int_;

   public:
   inline explicit MyInt(int i = 0)
      : int_(i)
   {}

   inline MyInt(const MyInt &other)
      :  int_(other.int_)
   {}

   inline MyInt & operator=(const MyInt &other)
   {
      int_ = other.int_;
      return *this;
   }

   inline ~MyInt()
   {
      int_ = 0;
   }

   inline int int_value() const { return int_; }

   friend inline bool operator==(const MyInt& a, const MyInt& b) { return a.int_ == b.int_; }
   friend inline bool operator!=(const MyInt& a, const MyInt& b) { return a.int_ != b.int_; }
   friend inline bool operator<(const MyInt& a, const MyInt& b) { return a.int_ < b.int_; }
};

class MyFatInt
{
   int int0_;
   int int1_;
   int int2_;
   int int3_;
   int int4_;
   int int5_;
   int int6_;
   int int7_;

   public:
   inline explicit MyFatInt(int i = 0)
      : int0_(i++)
      , int1_(i++)
      , int2_(i++)
      , int3_(i++)
      , int4_(i++)
      , int5_(i++)
      , int6_(i++)
      , int7_(i++)
   {}

   inline MyFatInt(const MyFatInt &other)
      : int0_(other.int0_)
      , int1_(other.int1_)
      , int2_(other.int2_)
      , int3_(other.int3_)
      , int4_(other.int4_)
      , int5_(other.int5_)
      , int6_(other.int6_)
      , int7_(other.int7_)
   {}

   inline MyFatInt & operator=(const MyFatInt &other)
   {
      int0_ = other.int0_;
      int1_ = other.int1_;
      int2_ = other.int2_;
      int3_ = other.int3_;
      int4_ = other.int4_;
      int5_ = other.int5_;
      int6_ = other.int6_;
      int7_ = other.int7_;
      return *this;
   }

   inline ~MyFatInt()
   {
      int0_ = 0;
      int1_ = 0;
      int2_ = 0;
      int3_ = 0;
      int4_ = 0;
      int5_ = 0;
      int6_ = 0;
      int7_ = 0;
   }

   inline int int_value() const { return int0_; }

   friend inline bool operator==(const MyFatInt& a, const MyFatInt& b) { return a.int0_ == b.int0_; }
   friend inline bool operator!=(const MyFatInt& a, const MyFatInt& b) { return a.int0_ != b.int0_; }
   friend inline bool operator<(const MyFatInt& a, const MyFatInt& b) { return a.int0_ < b.int0_; }
};

inline int int_value(int x) { return x; }
inline int int_value(const MyInt& x) { return x.int_value(); }
inline int int_value(const MyFatInt& x) { return x.int_value(); }

//////////////////////////////////////////////////////////////////////////////
// Functors
//////////////////////////////////////////////////////////////////////////////

template<class T>
struct add_one
{
   T operator()(const T& x) const { return T(int_value(x) + 1); }
};

template<class T>
struct is_odd
{
   bool operator()(const T& x) const { return (int_value(x) & 1) != 0; }
};

template<class T>
struct summer
{
   int sum;
   summer() : sum(0) {}
   void operator()(const T& x) { sum = static_cast<int>((static_cast<unsigned>(sum) + static_cast<unsigned>(int_value(x)))); }
};

template<class T>
struct is_negative
{
   bool operator()(const T& x) const { return int_value(x) < 0; }
};

template<class T>
struct is_zero_or_positive
{
   bool operator()(const T& x) const { return int_value(x) >= 0; }
};


template<class T>
struct counter
{
   int n;
   counter() : n(0) {}
   T operator()() { return T(n++); }
};

template<class T>
class equal_to_ref
{
   typedef T value_type;
   const value_type &t_;

   public:
   BOOST_CONTAINER_FORCEINLINE explicit equal_to_ref(const value_type &t)
      :  t_(t)
   {}

   template <class U>
   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &t)const
   {
      return t_ == t;
   }
};

template<class T>
class less_than_ref
{
   typedef T value_type;
   const value_type& t_;
public:
   BOOST_CONTAINER_FORCEINLINE explicit less_than_ref(const value_type& t)
      : t_(t)
   {
   }
   template <class U>
   BOOST_CONTAINER_FORCEINLINE bool operator()(const U& t)const
   {
      return t_ < t;
   }
};

template<class T>
class unequal_to_ref
{
   typedef T value_type;
   const value_type &t_;

   public:
   BOOST_CONTAINER_FORCEINLINE explicit unequal_to_ref(const value_type &t)
      :  t_(t)
   {}

   template <class U>
   BOOST_CONTAINER_FORCEINLINE bool operator()(const U &t)const
   {
      return t_ != t;
   }
};

//////////////////////////////////////////////////////////////////////////////
// C++03 fallbacks for C++11-only <algorithm> functions
//////////////////////////////////////////////////////////////////////////////

namespace bench_detail {

#if BOOST_CXX_VERSION < 201103L

template<class InIt, class Pred>
bool all_of(InIt first, InIt last, Pred pred)
{
   for (; first != last; ++first)
      if (!pred(*first)) return false;
   return true;
}

template<class InIt, class Pred>
bool any_of(InIt first, InIt last, Pred pred)
{
   for (; first != last; ++first)
      if (pred(*first)) return true;
   return false;
}

template<class InIt, class Pred>
bool none_of(InIt first, InIt last, Pred pred)
{
   for (; first != last; ++first)
      if (pred(*first)) return false;
   return true;
}

template <class InpIter, class Sent, class Pred>
inline InpIter find_if_not(InpIter first, Sent last, Pred pred)
{
   return std::find_if(first, last, boost::container::not_pred<Pred>(pred));
}

template<class InIt, class OutIt, class Pred>
OutIt copy_if(InIt first, InIt last, OutIt d_first, Pred pred)
{
   for (; first != last; ++first)
      if (pred(*first))
         *d_first++ = *first;
   return d_first;
}

template<class InIt, class Size, class OutIt>
OutIt copy_n(InIt first, Size count, OutIt result)
{
   for (Size i = 0; i < count; ++i, ++first, ++result)
      *result = *first;
   return result;
}

template<class FwdIt>
bool is_sorted(FwdIt first, FwdIt last)
{
   if (first == last) return true;
   FwdIt next = first;
   for (++next; next != last; first = next, ++next)
      if (*next < *first) return false;
   return true;
}

template<class FwdIt>
FwdIt is_sorted_until(FwdIt first, FwdIt last)
{
   if (first == last) return last;
   FwdIt next = first;
   for (++next; next != last; first = next, ++next)
      if (*next < *first) return next;
   return last;
}

template<class InIt, class Pred>
bool is_partitioned(InIt first, InIt last, Pred pred)
{
   for (; first != last; ++first)
      if (!pred(*first)) break;
   for (; first != last; ++first)
      if (pred(*first)) return false;
   return true;
}

template<class InIt, class OutIt1, class OutIt2, class Pred>
std::pair<OutIt1, OutIt2>
partition_copy(InIt first, InIt last,
               OutIt1 out_true, OutIt2 out_false, Pred pred)
{
   for (; first != last; ++first) {
      if (pred(*first))
         *out_true++ = *first;
      else
         *out_false++ = *first;
   }
   return std::pair<OutIt1, OutIt2>(out_true, out_false);
}

template<class FwdIt, class Pred>
FwdIt partition_point(FwdIt first, FwdIt last, Pred pred)
{
   for (; first != last; ++first)
      if (!pred(*first)) return first;
   return last;
}

#else

   using std::all_of;
   using std::any_of;
   using std::none_of;
   using std::find_if_not;
   using std::copy_if;
   using std::copy_n;
   using std::is_sorted;
   using std::is_sorted_until;
   using std::is_partitioned;
   using std::partition_copy;
   using std::partition_point;

#endif



//Not benchmarked:
//inplace_merge


//not implemented (c++03)
//find_end
//find_first_of
//adjacent_find
//mismatch
//copy_backward
//move
//move_backward
//transform
//replace_copy
//replace_copy_if
//unique
//unique_copy
//rotate
//rotate_copy
//max_element
//min_element
//minmax_element
//nth_element
//includes
//set_union
//lexicographical_compare
//   -- sorting --
//sort (random-access non-implementable?)
//stable_sort (random-access non-implementable?)
//partial_sort (random-access non-implementable?)
//partial_sort_copy(random-access non-implementable?)
//   -- binary search --
//lower_bound (binary/random-access non-implementable?)
//upper_bound (binary/random-access non-implementable?)
//equal_range (binary/random-access non-implementable?)
//binary_search (binary/random-access non-implementable?)
//   -- heap --
//push_heap (binary/random-access non-implementable?)
//pop_heap (binary/random-access non-implementable?)
//make_heap (binary/random-access non-implementable?)
//sort_heap (binary/random-access non-implementable?)
//   -- permutation --
//next_permutation
//prev_permutation
//is_permutation
//   -- numeric --
//iota
//accumulate
//inner_product
//adjacent_difference
//partial_sum

//not implemented (c++11):
//move
//move_backward
//shuffle (random-access non-implementable?)
//is_heap (random-access non-implementable?)
//is_heap_until (random-access non-implementable?)


//not implemented (c++17)
//for_each_n
//random_shuffle (random-access non-implementable?)
//sample (random-access non-implementable?)
//reduce
//exclusive_scan
//inclusive_scan
//transform_reduce
//transform_exclusive_scan
//transform_inclusive_scan





//not implemented (c++20)
//shift_left
//shift_right
//lexicographical_compare_three_way

//range-based?
//find_last
//find_last_if
//find_last_if_not
//
//contains
//contains_subrange
//starts_with
//ends_with
//fold_left
//fold_left_first
//fold_right
//fold_right_last
//fold_left_with_iter
//fold_left_first_with_iter
//generate_random


} // namespace bench_detail

//////////////////////////////////////////////////////////////////////////////
// Fill helpers
//////////////////////////////////////////////////////////////////////////////

template<class C>
void fill_test_data(C& c, std::size_t n)
{
   typedef typename C::value_type VT;
   for (std::size_t i = 0; i < n; ++i)
      c.push_back(VT(static_cast<int>(i)));
}

template<class T, class A, class O>
void fill_test_data(bc::nest<T,A,O>& c, std::size_t n)
{
   for (std::size_t i = 0; i < n; ++i)
      c.insert(T(static_cast<int>(i)));
}

//////////////////////////////////////////////////////////////////////////////
// Benchmark helpers
//////////////////////////////////////////////////////////////////////////////

inline double calc_ns_per_elem(nanosecond_type ns,
                               std::size_t iters, std::size_t elems)
{
   return double(ns) / double(iters * elems);
}

inline void print_subheader()
{
   std::cout << std::left  << std::setw(24) << "< algo >"
             << std::right << std::setw(20) << "< speedup >"
             << std::right << std::setw(20) << "< std ns/item >"
             << std::right << std::setw(20) << "< seg ns/item >"
             << '\n';
}

inline void print_ratio(const char* algo, const char*,
                        double std_ns, double seg_ns)
{
   double ratio = (seg_ns > 0.0) ? std_ns / seg_ns : 0.0;
   std::cout << std::left  << std::setw(24) << algo
             << std::right << std::setw(20) << std::fixed << std::setprecision(2) << ratio << 'x'
             << std::right << std::setw(20) << std::fixed << std::setprecision(3) << std_ns
             << std::right << std::setw(20) << std::fixed << std::setprecision(3) << seg_ns
             << '\n';
}

//////////////////////////////////////////////////////////////////////////////
// Individual benchmarks
//////////////////////////////////////////////////////////////////////////////

template<class C, class Pred>
void bench_all_of(C c, std::size_t iters, const char* cname,
                  Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      result = bench_detail::all_of(c.begin(), c.end(), pred) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      result = bc::segmented_all_of(c.begin(), c.end(), pred) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_any_of(C c, std::size_t iters, const char* cname,
                  Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      result = bench_detail::any_of(c.begin(), c.end(), pred) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      result = bc::segmented_any_of(c.begin(), c.end(), pred) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_none_of(C c, std::size_t iters, const char* cname,
                   Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      result = bench_detail::none_of(c.begin(), c.end(), pred) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      result = bc::segmented_none_of(c.begin(), c.end(), pred) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_for_each(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      summer<VT> s;
      s = std::for_each(c.begin(), c.end(), s);
      result = s.sum;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      summer<VT> s;
      s = bc::segmented_for_each(c.begin(), c.end(), s);
      result = s.sum;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("for_each", cname, r1, r2);
}

template<class C>
void bench_copy(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::copy(c.begin(), c.end(), out.begin());
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_copy(c.begin(), c.end(), out.begin());
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("copy", cname, r1, r2);
}

template<class C, class Pred>
void bench_copy_if(C c, std::size_t iters, const char* cname,
                   Pred pred, const char* label)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      bench_detail::copy_if(c.begin(), c.end(), out.begin(), pred);
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_copy_if(c.begin(), c.end(), out.begin(), pred);
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_fill(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   VT val(42);

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::fill(c.begin(), c.end(), val);
      t1.stop();
      escape(&val);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_fill(c.begin(), c.end(), val);
      t2.stop();
      escape(&val);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("fill", cname, r1, r2);
}

template<class C>
void bench_count(C c, std::size_t iters, const char* cname,
                 const typename C::value_type& val, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      result = static_cast<int>(std::count(c.begin(), c.end(), val));
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      result = static_cast<int>(bc::segmented_count(c.begin(), c.end(), val));
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_count_if(C c, std::size_t iters, const char* cname,
                    Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      result = static_cast<int>(std::count_if(c.begin(), c.end(), pred));
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      result = static_cast<int>(bc::segmented_count_if(c.begin(), c.end(), pred));
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_find(C c, std::size_t iters, const char* cname,
                const typename C::value_type& val, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = std::find(c.begin(), c.end(), val);
      result = (it == c.end()) ? 0 : 1;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_find(c.begin(), c.end(), val);
      result = (it == c.end()) ? 0 : 1;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_find_if(C c, std::size_t iters, const char* cname,
                   Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = std::find_if(c.begin(), c.end(), pred);
      result = (it != c.end()) ? int_value(*it) : -1;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_find_if(c.begin(), c.end(), pred);
      result = (it != c.end()) ? int_value(*it) : -1;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_find_if_not(C c, std::size_t iters, const char* cname,
                       Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = bench_detail::find_if_not(c.begin(), c.end(), pred);
      result = (it != c.end()) ? int_value(*it) : -1;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_find_if_not(c.begin(), c.end(), pred);
      result = (it != c.end()) ? int_value(*it) : -1;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_equal(C c, C& c2, std::size_t iters, const char* cname,
                 const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      result = std::equal(c.begin(), c.end(), c2.begin()) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      result = bc::segmented_equal(c.begin(), c.end(), c2.begin()) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_replace(C c, std::size_t iters, const char* cname,
                   const typename C::value_type& old_val,
                   const typename C::value_type& new_val, const char* label)
{
   typedef typename C::value_type VT;
   VT v = *c.begin();

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::replace(c.begin(), c.end(), old_val, new_val);
      t1.stop();
      escape(&v);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_replace(c.begin(), c.end(), old_val, new_val);
      t2.stop();
      escape(&v);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_replace_if(C c, std::size_t iters, const char* cname,
                      Pred pred, const typename C::value_type& new_val,
                      const char* label)
{
   typedef typename C::value_type VT;
   VT v = *c.begin();

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::replace_if(c.begin(), c.end(), pred, new_val);
      t1.stop();
      escape(&v);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_replace_if(c.begin(), c.end(), pred, new_val);
      t2.stop();
      escape(&v);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_transform(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::transform(c.begin(), c.end(), out.begin(), add_one<VT>());
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_transform(c.begin(), c.end(), out.begin(), add_one<VT>());
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("transform", cname, r1, r2);
}

template<class C>
void bench_fill_n(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   VT val(42);
   typename C::difference_type n =
      static_cast<typename C::difference_type>(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::fill_n(c.begin(), n, val);
      t1.stop();
      escape(&val);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_fill_n(c.begin(), n, val);
      t2.stop();
      escape(&val);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("fill_n", cname, r1, r2);
}

template<class C>
void bench_copy_n(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size());
   typename C::difference_type n =
      static_cast<typename C::difference_type>(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      bench_detail::copy_n(c.begin(), n, out.begin());
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_copy_n(c.begin(), n, out.begin());
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("copy_n", cname, r1, r2);
}

template<class C>
void bench_generate(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::generate(c.begin(), c.end(), counter<VT>());
      result = int_value(*c.begin());
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_generate(c.begin(), c.end(), counter<VT>());
      result = int_value(*c.begin());
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("generate", cname, r1, r2);
}

template<class C>
void bench_generate_n(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   int result = 0;
   typename C::difference_type n =
      static_cast<typename C::difference_type>(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::generate_n(c.begin(), n, counter<VT>());
      result = int_value(*c.begin());
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_generate_n(c.begin(), n, counter<VT>());
      result = int_value(*c.begin());
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("generate_n", cname, r1, r2);
}

template<class C>
void bench_remove(C c, std::size_t iters, const char* cname,
                  const typename C::value_type& val, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = std::remove(c.begin(), c.end(), val);
      result = (it == c.end()) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_remove(c.begin(), c.end(), val);
      result = (it == c.end()) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_remove_if(C c, std::size_t iters, const char* cname,
                     Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = std::remove_if(c.begin(), c.end(), pred);
      result = (it == c.end()) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_remove_if(c.begin(), c.end(), pred);
      result = (it == c.end()) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_remove_copy(C c, std::size_t iters, const char* cname,
                       const typename C::value_type& val, const char* label)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::remove_copy(c.begin(), c.end(), out.begin(), val);
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_remove_copy(c.begin(), c.end(), out.begin(), val);
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_remove_copy_if(C c, std::size_t iters, const char* cname,
                          Pred pred, const char* label)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::remove_copy_if(c.begin(), c.end(), out.begin(), pred);
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_remove_copy_if(c.begin(), c.end(), out.begin(), pred);
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_reverse(C c, std::size_t iters, const char* cname)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::reverse(c.begin(), c.end());
      result = int_value(*c.begin());
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_reverse(c.begin(), c.end());
      result = int_value(*c.begin());
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("reverse", cname, r1, r2);
}

template<class C>
void bench_reverse_copy(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::reverse_copy(c.begin(), c.end(), out.begin());
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_reverse_copy(c.begin(), c.end(), out.begin());
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("reverse_copy", cname, r1, r2);
}

template<class C>
void bench_is_sorted(C c, std::size_t iters, const char* cname,
                     const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      result = bench_detail::is_sorted(c.begin(), c.end()) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      result = bc::segmented_is_sorted(c.begin(), c.end()) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_is_sorted_until(C c, std::size_t iters, const char* cname,
                           const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = bench_detail::is_sorted_until(c.begin(), c.end());
      result = (it == c.end()) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_is_sorted_until(c.begin(), c.end());
      result = (it == c.end()) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_is_partitioned(C c, std::size_t iters, const char* cname,
                          Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      result = bench_detail::is_partitioned(c.begin(), c.end(), pred) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      result = bc::segmented_is_partitioned(c.begin(), c.end(), pred) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_merge(C c, C& c2, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size() + c2.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::merge(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_merge(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("merge", cname, r1, r2);
}

template<class C>
void bench_mismatch(C c, C& c2, std::size_t iters, const char* cname,
                    const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      result = (std::mismatch(c.begin(), c.end(), c2.begin()).first == c.end()) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      result = (bc::segmented_mismatch(c.begin(), c.end(), c2.begin()).first == c.end()) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_swap_ranges(C c, std::size_t iters, const char* cname)
{
   C c2(c);
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::swap_ranges(c.begin(), c.end(), c2.begin());
      result = int_value(*c.begin());
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_swap_ranges(c.begin(), c.end(), c2.begin());
      result = int_value(*c.begin());
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("swap_ranges", cname, r1, r2);
}

template<class C>
void bench_search(C c, std::size_t iters, const char* cname,
                  const typename C::value_type* pattern, std::size_t pat_size,
                  const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = std::search(c.begin(), c.end(), pattern, pattern + pat_size);
      result = (it == c.end()) ? 0 : 1;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_search(c.begin(), c.end(), pattern, pattern + pat_size);
      result = (it == c.end()) ? 0 : 1;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_search_n(C c, std::size_t iters, const char* cname,
                    typename C::difference_type count,
                    const typename C::value_type& val, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = std::search_n(c.begin(), c.end(), count, val);
      result = (it == c.end()) ? 0 : 1;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_search_n(c.begin(), c.end(), count, val);
      result = (it == c.end()) ? 0 : 1;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_set_union(C c, C& c2, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size() + c2.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::set_union(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_set_union(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("set_union", cname, r1, r2);
}

template<class C>
void bench_set_difference(C c, C& c2, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::set_difference(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_set_difference(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("set_difference", cname, r1, r2);
}

template<class C>
void bench_set_intersection(C c, C& c2, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::set_intersection(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_set_intersection(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("set_intersection", cname, r1, r2);
}

template<class C>
void bench_set_symmetric_difference(C c, C& c2, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> out(c.size() + c2.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      std::set_symmetric_difference(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t1.stop();
      escape(&out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_set_symmetric_difference(c.begin(), c.end(), c2.begin(), c2.end(), out.begin());
      t2.stop();
      escape(&out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("set_symmetric_difference", cname, r1, r2);
}

template<class C, class Pred>
void bench_partition(C c, std::size_t iters, const char* cname,
                     Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = std::partition(c.begin(), c.end(), pred);
      result = (it == c.end()) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_partition(c.begin(), c.end(), pred);
      result = (it == c.end()) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C, class Pred>
void bench_stable_partition(C c, std::size_t iters, const char* cname,
                            Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = std::stable_partition(c.begin(), c.end(), pred);
      result = (it == c.end()) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_stable_partition(c.begin(), c.end(), pred);
      result = (it == c.end()) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

template<class C>
void bench_partition_copy(C c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;
   std::vector<VT> t_out(c.size());
   std::vector<VT> f_out(c.size());

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      bench_detail::partition_copy(c.begin(), c.end(),
         t_out.begin(), f_out.begin(), is_odd<VT>());
      t1.stop();
      escape(&t_out[0]);
      escape(&f_out[0]);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      bc::segmented_partition_copy(c.begin(), c.end(),
         t_out.begin(), f_out.begin(), is_odd<VT>());
      t2.stop();
      escape(&t_out[0]);
      escape(&f_out[0]);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio("partition_copy", cname, r1, r2);
}

template<class C, class Pred>
void bench_partition_point(C c, std::size_t iters, const char* cname,
                           Pred pred, const char* label)
{
   int result = 0;

   cpu_timer t1;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t1.resume();
      typename C::iterator it = bench_detail::partition_point(c.begin(), c.end(), pred);
      result = (it == c.end()) ? 1 : 0;
      t1.stop();
      escape(&result);
   }
   double r1 = calc_ns_per_elem(t1.elapsed().wall, iters, c.size());

   cpu_timer t2;
   for (std::size_t i = 0; i < iters; ++i) {
      clobber();
      t2.resume();
      typename C::iterator it = bc::segmented_partition_point(c.begin(), c.end(), pred);
      result = (it == c.end()) ? 1 : 0;
      t2.stop();
      escape(&result);
   }
   double r2 = calc_ns_per_elem(t2.elapsed().wall, iters, c.size());
   print_ratio(label, cname, r1, r2);
}

//////////////////////////////////////////////////////////////////////////////
// Run all benchmarks for a container type
//////////////////////////////////////////////////////////////////////////////

template<class C>
void run_all(const C& c, std::size_t iters, const char* cname)
{
   typedef typename C::value_type VT;

   print_subheader();

   //all_of
   bench_all_of(c, iters, cname, is_zero_or_positive<VT>(), "all_of(hit)");
   bench_all_of(c, iters, cname, unequal_to_ref<VT>(VT(static_cast<int>(c.size() / 2))), "all_of(miss)");

   //any_of
   bench_any_of(c, iters, cname, equal_to_ref<VT>(VT(static_cast<int>(c.size() / 2))),   "any_of(hit)");
   bench_any_of(c, iters, cname, is_negative<VT>(), "any_of(miss)");

   //copy
   bench_copy(c, iters, cname);

   //copy_if
   bench_copy_if(c, iters, cname, is_odd<VT>(),      "copy_if(hit)");
   bench_copy_if(c, iters, cname, is_negative<VT>(), "copy_if(miss)");

   //copy_n
   bench_copy_n(c, iters, cname);

   //count
   bench_count(c, iters, cname, VT(0),  "count(hit)");
   bench_count(c, iters, cname, VT(-1), "count(miss)");

   //count_if
   bench_count_if(c, iters, cname, is_odd<VT>(),      "count_if(hit)");
   bench_count_if(c, iters, cname, is_negative<VT>(), "count_if(miss)");

   //equal
   {
      C c2(c);
      bench_equal(c, c2, iters, cname, "equal(hit)");
      typename C::iterator last = c2.end();
      --last;
      *last = VT(-1);
      bench_equal(c, c2, iters, cname, "equal(miss)");
   }

   //fill
   bench_fill(c, iters, cname);

   //fill_n
   bench_fill_n(c, iters, cname);

   //find
   bench_find(c, iters, cname, VT(static_cast<int>(c.size() / 2)), "find(hit)");
   bench_find(c, iters, cname, VT(-1), "find(miss)");

   //find_if
   bench_find_if(c, iters, cname, equal_to_ref<VT>(VT(static_cast<int>(c.size() / 2))), "find_if(hit)");
   bench_find_if(c, iters, cname, is_negative<VT>(), "find_if(miss)");

   //find_if_not
   bench_find_if_not(c, iters, cname, unequal_to_ref<VT>(VT(static_cast<int>(c.size() / 2))), "find_if_not(hit)");
   bench_find_if_not(c, iters, cname, is_zero_or_positive<VT>(), "find_if_not(miss)");

   //for_each
   bench_for_each(c, iters, cname);

   //generate
   bench_generate(c, iters, cname);

   //generate_n
   bench_generate_n(c, iters, cname);

   //is_partitioned
   {
      bench_is_partitioned(c, iters, cname, is_negative<VT>(), "is_partitioned(hit)");
      C c2(c);
      typename C::iterator last = c2.end();
      --last;
      *last = VT(-1);
      bench_is_partitioned(c2, iters, cname, is_negative<VT>(), "is_partitioned(miss)");
   }

   //is_sorted
   {
      bench_is_sorted(c, iters, cname, "is_sorted(hit)");
      C c2(c);
      typename C::iterator last = c2.end();
      --last;
      *last = VT(0);
      bench_is_sorted(c2, iters, cname, "is_sorted(miss)");
   }

   //is_sorted_until
   {
      bench_is_sorted_until(c, iters, cname, "is_sorted_until(hit)");
      C c2(c);
      typename C::iterator last = c2.end();
      --last;
      *last = VT(0);
      bench_is_sorted_until(c2, iters, cname, "is_sorted_until(miss)");
   }

   //merge
   {
      C c2(c);
      for (typename C::iterator it = c2.begin(); it != c2.end(); ++it)
         *it = VT(int_value(*it) * 2);
      bench_merge(c, c2, iters, cname);
   }

   //mismatch
   {
      C c2(c);
      bench_mismatch(c, c2, iters, cname, "mismatch(hit)");
      typename C::iterator last = c2.end();
      --last;
      *last = VT(-1);
      bench_mismatch(c, c2, iters, cname, "mismatch(miss)");
   }

   //none_of
   bench_none_of(c, iters, cname, is_negative<VT>(), "none_of(hit)");
   bench_none_of(c, iters, cname, equal_to_ref<VT>(VT(static_cast<int>(c.size()/2))),      "none_of(miss)");

   //partition
   bench_partition(c, iters, cname, is_odd<VT>(),      "partition(hit)");
   bench_partition(c, iters, cname, is_negative<VT>(), "partition(miss)");

   //partition_copy
   bench_partition_copy(c, iters, cname);

   //partition_point
   bench_partition_point(c, iters, cname, less_than_ref<VT>(static_cast<VT>((int)c.size()/2)), "partition_point(hit)");
   bench_partition_point(c, iters, cname, is_negative<VT>(),                                   "partition_point(miss)");
   ;
   //remove
   bench_remove(c, iters, cname, VT(0),  "remove(hit)");
   bench_remove(c, iters, cname, VT(-1), "remove(miss)");

   //remove_copy
   bench_remove_copy(c, iters, cname, VT(0),  "remove_copy(hit)");
   bench_remove_copy(c, iters, cname, VT(-1), "remove_copy(miss)");

   //remove_copy_if
   bench_remove_copy_if(c, iters, cname, is_odd<VT>(),      "remove_copy_if(hit)");
   bench_remove_copy_if(c, iters, cname, is_negative<VT>(), "remove_copy_if(miss)");

   //remove_if
   bench_remove_if(c, iters, cname, is_odd<VT>(),      "remove_if(hit)");
   bench_remove_if(c, iters, cname, is_negative<VT>(), "remove_if(miss)");

   //replace
   bench_replace(c, iters, cname, VT(0),  VT(0),  "replace(hit)");
   bench_replace(c, iters, cname, VT(-1), VT(-2), "replace(miss)");

   //replace_if
   bench_replace_if(c, iters, cname, is_odd<VT>(),      VT(-2), "replace_if(hit)");
   bench_replace_if(c, iters, cname, is_negative<VT>(), VT(-2), "replace_if(miss)");

   //reverse
   bench_reverse(c, iters, cname);

   //reverse_copy
   bench_reverse_copy(c, iters, cname);

   //search
   {
      int half = static_cast<int>(c.size() / 2);
      VT hit_pat[] = {VT(half), VT(half + 1), VT(half + 2)};
      bench_search(c, iters, cname, hit_pat, 3, "search(hit)");
      VT miss_pat[] = {VT(-1), VT(-2), VT(-3)};
      bench_search(c, iters, cname, miss_pat, 3, "search(miss)");
   }

   //search_n
   bench_search_n(c, iters, cname, 1, VT(static_cast<int>(c.size() / 2)), "search_n(hit)");
   bench_search_n(c, iters, cname, 3, VT(-1), "search_n(miss)");

   //set_difference, set_symmetric_difference, set_union
   {
      C c2(c);
      for (typename C::iterator it = c2.begin(); it != c2.end(); ++it)
         *it = VT(int_value(*it) * 2);
      bench_set_difference(c, c2, iters, cname);
      bench_set_intersection(c, c2, iters, cname);
      bench_set_symmetric_difference(c, c2, iters, cname);
      bench_set_union(c, c2, iters, cname);
   }

   //stable_partition
   bench_stable_partition(c, iters, cname, is_odd<VT>(),      "stable_partition(hit)");
   bench_stable_partition(c, iters, cname, is_negative<VT>(), "stable_partition(miss)");

   //swap_ranges
   bench_swap_ranges(c, iters, cname);

   //transform
   bench_transform(c, iters, cname);
}

//////////////////////////////////////////////////////////////////////////////
// Run all benchmarks for a given value type
//////////////////////////////////////////////////////////////////////////////

template<class T>
void run_benchmarks()
{
   #ifdef NDEBUG
   const std::size_t N    = 100000;
   const std::size_t iter = 500;
   #else
   const std::size_t N    = 10000;
   const std::size_t iter = 10;
   #endif

   std::cout << "\n=== Segmented algorithm benchmark [" << typeid(T).name() << "] ===\n"
             << "Elements: " << N << "   Iterations: " << iter << "\n\n";

   {
      std::cout << "--- bc::deque<" << typeid(T).name() << "> ---\n";
      bc::deque<T> dq;
      fill_test_data(dq, N);
      run_all(dq, iter, "deque");
      std::cout << "\n";
   }/*
   {
      std::cout << "--- bc::nest<" << typeid(T).name() << "> ---\n";
      bc::nest<T> nt;
      fill_test_data(nt, N);
      run_all(nt, iter, "nest");
      std::cout << "\n";
   }*/
}

//////////////////////////////////////////////////////////////////////////////
// Main
//////////////////////////////////////////////////////////////////////////////

int main()
{
   //run_benchmarks<int>();
   run_benchmarks<MyInt>();
   //run_benchmarks<MyFatInt>();
   return 0;
}