/*

 *

 * Copyright (c) 1994

 * Hewlett-Packard Company

 *

 * Copyright (c) 1996,1997

 * Silicon Graphics Computer Systems, Inc.

 *

 * Copyright (c) 1997

 * Moscow Center for SPARC Technology

 *

 * Copyright (c) 1999

 * Boris Fomitchev

 *

 * This material is provided "as is", with absolutely no warranty expressed

 * or implied. Any use is at your own risk.

 *

 * Permission to use or copy this software for any purpose is hereby granted

 * without fee, provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 */

/* NOTE: This is an internal header file, included by other STL headers.

 *   You should not attempt to use it directly.

 */

#ifndef _STLP_INTERNAL_ALGO_H

#define _STLP_INTERNAL_ALGO_H

#ifndef _STLP_INTERNAL_ALGOBASE_H

#  include <stl/_algobase.h>

#endif

#ifndef _STLP_INTERNAL_HEAP_H

#  include <stl/_heap.h>

#endif

#ifndef _STLP_INTERNAL_ITERATOR_H

#  include <stl/_iterator.h>

#endif

#ifndef _STLP_INTERNAL_FUNCTION_BASE_H

#  include <stl/_function_base.h>

#endif

#if defined (__SUNPRO_CC) && !defined (_STLP_INTERNAL_CSTDIO)

// remove() conflict

#  include <stl/_cstdio.h>

#endif

_STLP_BEGIN_NAMESPACE

// for_each.  Apply a function to every element of a range.

template <class _InputIter, class _Function>

_STLP_INLINE_LOOP _Function

for_each(_InputIter __first, _InputIter __last, _Function __f) {

  for ( ; __first != __last; ++__first)

    __f(*__first);

  return __f;

}

// count_if

template <class _InputIter, class _Predicate>

_STLP_INLINE_LOOP _STLP_DIFFERENCE_TYPE(_InputIter)

count_if(_InputIter __first, _InputIter __last, _Predicate __pred) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  _STLP_DIFFERENCE_TYPE(_InputIter) __n = 0;

  for ( ; __first != __last; ++__first) {

    if (__pred(*__first))

      ++__n;

  }

  return __n;

}

// adjacent_find.

template <class _ForwardIter, class _BinaryPredicate>

_STLP_INLINE_LOOP _ForwardIter

adjacent_find(_ForwardIter __first, _ForwardIter __last,

              _BinaryPredicate __binary_pred) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  if (__first == __last)

    return __last;

  _ForwardIter __next = __first;

  while(++__next != __last) {

    if (__binary_pred(*__first, *__next))

      return __first;

    __first = __next;

  }

  return __last;

}

template <class _ForwardIter>

_STLP_INLINE_LOOP _ForwardIter

adjacent_find(_ForwardIter __first, _ForwardIter __last) {

  return adjacent_find(__first, __last,

                       _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first, _ForwardIter)));

}

#if !defined (_STLP_NO_ANACHRONISMS)

template <class _InputIter, class _Tp, class _Size>

_STLP_INLINE_LOOP void

count(_InputIter __first, _InputIter __last, const _Tp& __val, _Size& __n) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

    for ( ; __first != __last; ++__first)

      if (*__first == __val)

        ++__n;

}

template <class _InputIter, class _Predicate, class _Size>

_STLP_INLINE_LOOP void

count_if(_InputIter __first, _InputIter __last, _Predicate __pred, _Size& __n) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  for ( ; __first != __last; ++__first)

    if (__pred(*__first))

      ++__n;

}

#endif

template <class _ForwardIter1, class _ForwardIter2>

_ForwardIter1 search(_ForwardIter1 __first1, _ForwardIter1 __last1,

                     _ForwardIter2 __first2, _ForwardIter2 __last2);

// search_n.  Search for __count consecutive copies of __val.

template <class _ForwardIter, class _Integer, class _Tp>

_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,

                      _Integer __count, const _Tp& __val);

template <class _ForwardIter, class _Integer, class _Tp, class _BinaryPred>

_ForwardIter search_n(_ForwardIter __first, _ForwardIter __last,

                      _Integer __count, const _Tp& __val, _BinaryPred __binary_pred);

template <class _InputIter, class _ForwardIter>

inline _InputIter find_first_of(_InputIter __first1, _InputIter __last1,

                                _ForwardIter __first2, _ForwardIter __last2) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))

  return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2,

                                    _STLP_PRIV __equal_to(_STLP_VALUE_TYPE(__first1, _InputIter)));

}

template <class _InputIter, class _ForwardIter, class _BinaryPredicate>

inline _InputIter

find_first_of(_InputIter __first1, _InputIter __last1,

              _ForwardIter __first2, _ForwardIter __last2, _BinaryPredicate __comp) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first2, __last2))

  return _STLP_PRIV __find_first_of(__first1, __last1, __first2, __last2, __comp);

}

template <class _ForwardIter1, class _ForwardIter2>

_ForwardIter1

find_end(_ForwardIter1 __first1, _ForwardIter1 __last1,

         _ForwardIter2 __first2, _ForwardIter2 __last2);

// swap_ranges

template <class _ForwardIter1, class _ForwardIter2>

_STLP_INLINE_LOOP _ForwardIter2

swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1, _ForwardIter2 __first2) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))

  for ( ; __first1 != __last1; ++__first1, ++__first2)

    iter_swap(__first1, __first2);

  return __first2;

}

// transform

template <class _InputIter, class _OutputIter, class _UnaryOperation>

_STLP_INLINE_LOOP _OutputIter

transform(_InputIter __first, _InputIter __last, _OutputIter __result, _UnaryOperation __opr) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  for ( ; __first != __last; ++__first, ++__result)

    *__result = __opr(*__first);

  return __result;

}

template <class _InputIter1, class _InputIter2, class _OutputIter, class _BinaryOperation>

_STLP_INLINE_LOOP _OutputIter

transform(_InputIter1 __first1, _InputIter1 __last1,

          _InputIter2 __first2, _OutputIter __result,_BinaryOperation __binary_op) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first1, __last1))

  for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)

    *__result = __binary_op(*__first1, *__first2);

  return __result;

}

// replace_if, replace_copy, replace_copy_if

template <class _ForwardIter, class _Predicate, class _Tp>

_STLP_INLINE_LOOP void

replace_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred, const _Tp& __new_value) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  for ( ; __first != __last; ++__first)

    if (__pred(*__first))

      *__first = __new_value;

}

template <class _InputIter, class _OutputIter, class _Tp>

_STLP_INLINE_LOOP  _OutputIter

replace_copy(_InputIter __first, _InputIter __last,_OutputIter __result,

             const _Tp& __old_value, const _Tp& __new_value) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  for ( ; __first != __last; ++__first, ++__result)

    *__result = *__first == __old_value ? __new_value : *__first;

  return __result;

}

template <class _Iterator, class _OutputIter, class _Predicate, class _Tp>

_STLP_INLINE_LOOP _OutputIter

replace_copy_if(_Iterator __first, _Iterator __last,

                _OutputIter __result,

                _Predicate __pred, const _Tp& __new_value) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  for ( ; __first != __last; ++__first, ++__result)

    *__result = __pred(*__first) ? __new_value : *__first;

  return __result;

}

// generate and generate_n

template <class _ForwardIter, class _Generator>

_STLP_INLINE_LOOP void

generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  for ( ; __first != __last; ++__first)

    *__first = __gen();

}

template <class _OutputIter, class _Size, class _Generator>

_STLP_INLINE_LOOP void

generate_n(_OutputIter __first, _Size __n, _Generator __gen) {

  for ( ; __n > 0; --__n, ++__first)

    *__first = __gen();

}

// remove, remove_if, remove_copy, remove_copy_if

template <class _InputIter, class _OutputIter, class _Tp>

_STLP_INLINE_LOOP _OutputIter

remove_copy(_InputIter __first, _InputIter __last,_OutputIter __result, const _Tp& __val) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  for ( ; __first != __last; ++__first) {

    if (!(*__first == __val)) {

      *__result = *__first;

      ++__result;

    }

  }

  return __result;

}

template <class _InputIter, class _OutputIter, class _Predicate>

_STLP_INLINE_LOOP _OutputIter

remove_copy_if(_InputIter __first, _InputIter __last, _OutputIter __result, _Predicate __pred) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  for ( ; __first != __last; ++__first) {

    if (!__pred(*__first)) {

      *__result = *__first;

      ++__result;

    }

  }

  return __result;

}

template <class _ForwardIter, class _Tp>

_STLP_INLINE_LOOP _ForwardIter

remove(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  __first = find(__first, __last, __val);

  if (__first == __last)

    return __first;

  else {

    _ForwardIter __next = __first;

    return remove_copy(++__next, __last, __first, __val);

  }

}

template <class _ForwardIter, class _Predicate>

_STLP_INLINE_LOOP _ForwardIter

remove_if(_ForwardIter __first, _ForwardIter __last, _Predicate __pred) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  __first = find_if(__first, __last, __pred);

  if ( __first == __last )

    return __first;

  else {

    _ForwardIter __next = __first;

    return remove_copy_if(++__next, __last, __first, __pred);

  }

}

// unique and unique_copy

template <class _InputIter, class _OutputIter>

_OutputIter unique_copy(_InputIter __first, _InputIter __last, _OutputIter __result);

template <class _InputIter, class _OutputIter, class _BinaryPredicate>

_OutputIter unique_copy(_InputIter __first, _InputIter __last,_OutputIter __result,

                        _BinaryPredicate __binary_pred);

template <class _ForwardIter>

inline _ForwardIter unique(_ForwardIter __first, _ForwardIter __last) {

  __first = adjacent_find(__first, __last);

  return unique_copy(__first, __last, __first);

}

template <class _ForwardIter, class _BinaryPredicate>

inline _ForwardIter unique(_ForwardIter __first, _ForwardIter __last,

                           _BinaryPredicate __binary_pred) {

  __first = adjacent_find(__first, __last, __binary_pred);

  return unique_copy(__first, __last, __first, __binary_pred);

}

// reverse and reverse_copy, and their auxiliary functions

template <class _BidirectionalIter>

_STLP_INLINE_LOOP void

__reverse(_BidirectionalIter __first, _BidirectionalIter __last, const bidirectional_iterator_tag &) {

  for (; __first != __last && __first != --__last; ++__first)

    iter_swap(__first,__last);

}

template <class _RandomAccessIter>

_STLP_INLINE_LOOP void

__reverse(_RandomAccessIter __first, _RandomAccessIter __last, const random_access_iterator_tag &) {

  for (; __first < __last; ++__first)

    iter_swap(__first, --__last);

}

template <class _BidirectionalIter>

inline void

reverse(_BidirectionalIter __first, _BidirectionalIter __last) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  __reverse(__first, __last, _STLP_ITERATOR_CATEGORY(__first, _BidirectionalIter));

}

template <class _BidirectionalIter, class _OutputIter>

_STLP_INLINE_LOOP

_OutputIter reverse_copy(_BidirectionalIter __first,

                         _BidirectionalIter __last,

                         _OutputIter __result) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  while (__first != __last) {

    --__last;

    *__result = *__last;

    ++__result;

  }

  return __result;

}

_STLP_MOVE_TO_PRIV_NAMESPACE

// rotate and rotate_copy, and their auxiliary functions

template <class _EuclideanRingElement>

_STLP_INLINE_LOOP

_EuclideanRingElement __gcd(_EuclideanRingElement __m,

                            _EuclideanRingElement __n) {

  while (__n != 0) {

    _EuclideanRingElement __t = __m % __n;

    __m = __n;

    __n = __t;

  }

  return __m;

}

_STLP_MOVE_TO_STD_NAMESPACE

template <class _ForwardIter>

void rotate(_ForwardIter __first, _ForwardIter __middle, _ForwardIter __last);

template <class _ForwardIter, class _OutputIter>

inline _OutputIter rotate_copy(_ForwardIter __first, _ForwardIter __middle,

                               _ForwardIter __last, _OutputIter __result) {

  return copy(__first, __middle, copy(__middle, __last, __result));

}

// random_shuffle

template <class _RandomAccessIter>

void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last);

template <class _RandomAccessIter, class _RandomNumberGenerator>

void random_shuffle(_RandomAccessIter __first, _RandomAccessIter __last,

                    _RandomNumberGenerator& __rand);

#if !defined (_STLP_NO_EXTENSIONS)

// random_sample and random_sample_n (extensions, not part of the standard).

template <class _ForwardIter, class _OutputIter, class _Distance>

_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,

                            _OutputIter __out_ite, const _Distance __n);

template <class _ForwardIter, class _OutputIter, class _Distance,

          class _RandomNumberGenerator>

_OutputIter random_sample_n(_ForwardIter __first, _ForwardIter __last,

                            _OutputIter __out_ite, const _Distance __n,

                            _RandomNumberGenerator& __rand);

template <class _InputIter, class _RandomAccessIter>

_RandomAccessIter

random_sample(_InputIter __first, _InputIter __last,

              _RandomAccessIter __out_first, _RandomAccessIter __out_last);

template <class _InputIter, class _RandomAccessIter,

          class _RandomNumberGenerator>

_RandomAccessIter

random_sample(_InputIter __first, _InputIter __last,

              _RandomAccessIter __out_first, _RandomAccessIter __out_last,

              _RandomNumberGenerator& __rand);

#endif /* _STLP_NO_EXTENSIONS */

// partition, stable_partition, and their auxiliary functions

template <class _ForwardIter, class _Predicate>

_ForwardIter partition(_ForwardIter __first, _ForwardIter __last, _Predicate   __pred);

template <class _ForwardIter, class _Predicate>

_ForwardIter

stable_partition(_ForwardIter __first, _ForwardIter __last, _Predicate __pred);

// sort() and its auxiliary functions.

_STLP_MOVE_TO_PRIV_NAMESPACE

template <class _Size>

inline _Size __lg(_Size __n) {

  _Size __k;

  for (__k = 0; __n != 1; __n >>= 1) ++__k;

  return __k;

}

_STLP_MOVE_TO_STD_NAMESPACE

template <class _RandomAccessIter>

void sort(_RandomAccessIter __first, _RandomAccessIter __last);

template <class _RandomAccessIter, class _Compare>

void sort(_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp);

// stable_sort() and its auxiliary functions.

template <class _RandomAccessIter>

void stable_sort(_RandomAccessIter __first,

                 _RandomAccessIter __last);

template <class _RandomAccessIter, class _Compare>

void stable_sort(_RandomAccessIter __first,

                 _RandomAccessIter __last, _Compare __comp);

// partial_sort, partial_sort_copy, and auxiliary functions.

template <class _RandomAccessIter>

void partial_sort(_RandomAccessIter __first, _RandomAccessIter __middle,

                  _RandomAccessIter __last);

template <class _RandomAccessIter, class _Compare>

void partial_sort(_RandomAccessIter __first,_RandomAccessIter __middle,

                  _RandomAccessIter __last, _Compare __comp);

template <class _InputIter, class _RandomAccessIter>

_RandomAccessIter

partial_sort_copy(_InputIter __first, _InputIter __last,

                  _RandomAccessIter __result_first, _RandomAccessIter __result_last);

template <class _InputIter, class _RandomAccessIter, class _Compare>

_RandomAccessIter

partial_sort_copy(_InputIter __first, _InputIter __last,

                  _RandomAccessIter __result_first,

                  _RandomAccessIter __result_last, _Compare __comp);

// nth_element() and its auxiliary functions.

template <class _RandomAccessIter>

void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,

                 _RandomAccessIter __last);

template <class _RandomAccessIter, class _Compare>

void nth_element(_RandomAccessIter __first, _RandomAccessIter __nth,

                 _RandomAccessIter __last, _Compare __comp);

// auxiliary class for lower_bound, etc.

_STLP_MOVE_TO_PRIV_NAMESPACE

template <class _T1, class _T2>

struct __less_2 {

  bool operator() (const _T1& __x, const _T2& __y) const { return __x < __y ; }

};

template <class _T1, class _T2>

__less_2<_T1,_T2> __less2(_T1*, _T2* ) { return __less_2<_T1, _T2>(); }

#if defined (_STLP_FUNCTION_PARTIAL_ORDER)

template <class _Tp>

less<_Tp> __less2(_Tp*, _Tp* ) { return less<_Tp>(); }

#endif

_STLP_MOVE_TO_STD_NAMESPACE

// Binary search (lower_bound, upper_bound, equal_range, binary_search).

template <class _ForwardIter, class _Tp>

inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,

                                   const _Tp& __val) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  return _STLP_PRIV __lower_bound(__first, __last, __val,

                                  _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),

                                  _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),

                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));

}

template <class _ForwardIter, class _Tp, class _Compare>

inline _ForwardIter lower_bound(_ForwardIter __first, _ForwardIter __last,

                                const _Tp& __val, _Compare __comp) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  return _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,

                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));

}

_STLP_MOVE_TO_PRIV_NAMESPACE

template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>

_ForwardIter __upper_bound(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,

                           _Compare1 __comp1, _Compare2 __comp2, _Distance*);

_STLP_MOVE_TO_STD_NAMESPACE

template <class _ForwardIter, class _Tp>

inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,

                                const _Tp& __val) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  return _STLP_PRIV __upper_bound(__first, __last, __val,

                                  _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),

                                  _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),

                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));

}

template <class _ForwardIter, class _Tp, class _Compare>

inline _ForwardIter upper_bound(_ForwardIter __first, _ForwardIter __last,

                                const _Tp& __val, _Compare __comp) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  return _STLP_PRIV __upper_bound(__first, __last, __val, __comp, __comp,

                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));

}

_STLP_MOVE_TO_PRIV_NAMESPACE

template <class _ForwardIter, class _Tp, class _Compare1, class _Compare2, class _Distance>

pair<_ForwardIter, _ForwardIter>

__equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,

              _Compare1 __comp1, _Compare2 __comp2, _Distance*);

_STLP_MOVE_TO_STD_NAMESPACE

template <class _ForwardIter, class _Tp>

inline pair<_ForwardIter, _ForwardIter>

equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  return _STLP_PRIV __equal_range(__first, __last, __val,

                                  _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),

                                  _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),

                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));

}

template <class _ForwardIter, class _Tp, class _Compare>

inline pair<_ForwardIter, _ForwardIter>

equal_range(_ForwardIter __first, _ForwardIter __last, const _Tp& __val,

            _Compare __comp) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  return _STLP_PRIV __equal_range(__first, __last, __val, __comp, __comp,

                                  _STLP_DISTANCE_TYPE(__first, _ForwardIter));

}

template <class _ForwardIter, class _Tp>

inline bool binary_search(_ForwardIter __first, _ForwardIter __last,

                   const _Tp& __val) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val,

                                              _STLP_PRIV __less2(_STLP_VALUE_TYPE(__first, _ForwardIter), (_Tp*)0),

                                              _STLP_PRIV __less2((_Tp*)0, _STLP_VALUE_TYPE(__first, _ForwardIter)),

                                              _STLP_DISTANCE_TYPE(__first, _ForwardIter));

  return __i != __last && !(__val < *__i);

}

template <class _ForwardIter, class _Tp, class _Compare>

inline bool binary_search(_ForwardIter __first, _ForwardIter __last,

                          const _Tp& __val,

                          _Compare __comp) {

  _STLP_DEBUG_CHECK(_STLP_PRIV __check_range(__first, __last))

  _ForwardIter __i = _STLP_PRIV __lower_bound(__first, __last, __val, __comp, __comp,

                                              _STLP_DISTANCE_TYPE(__first, _ForwardIter));

  return __i != __last && !__comp(__val, *__i);

}

// merge, with and without an explicitly supplied comparison function.

template <class _InputIter1, class _InputIter2, class _OutputIter>

_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,

                  _InputIter2 __first2, _InputIter2 __last2,

                  _OutputIter __result);

template <class _InputIter1, class _InputIter2, class _OutputIter,

          class _Compare>

_OutputIter merge(_InputIter1 __first1, _InputIter1 __last1,

                  _InputIter2 __first2, _InputIter2 __last2,

                  _OutputIter __result, _Compare __comp);

// inplace_merge and its auxiliary functions.

template <class _BidirectionalIter>

void inplace_merge(_BidirectionalIter __first,

                   _BidirectionalIter __middle,

                   _BidirectionalIter __last) ;

template <class _BidirectionalIter, class _Compare>

void inplace_merge(_BidirectionalIter __first,

                   _BidirectionalIter __middle,

                   _BidirectionalIter __last, _Compare __comp);

// Set algorithms: includes, set_union, set_intersection, set_difference,

// set_symmetric_difference.  All of these algorithms have the precondition

// that their input ranges are sorted and the postcondition that their output

// ranges are sorted.

template <class _InputIter1, class _InputIter2>

bool includes(_InputIter1 __first1, _InputIter1 __last1,

              _InputIter2 __first2, _InputIter2 __last2);

template <class _InputIter1, class _InputIter2, class _Compare>

bool includes(_InputIter1 __first1, _InputIter1 __last1,

              _InputIter2 __first2, _InputIter2 __last2, _Compare __comp);

template <class _InputIter1, class _InputIter2, class _OutputIter>

_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,

                      _InputIter2 __first2, _InputIter2 __last2,

                      _OutputIter __result);

template <class _InputIter1, class _InputIter2, class _OutputIter,

          class _Compare>

_OutputIter set_union(_InputIter1 __first1, _InputIter1 __last1,

                      _InputIter2 __first2, _InputIter2 __last2,

                      _OutputIter __result, _Compare __comp);

template <class _InputIter1, class _InputIter2, class _OutputIter>

_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,

                             _InputIter2 __first2, _InputIter2 __last2,

                             _OutputIter __result);

template <class _InputIter1, class _InputIter2, class _OutputIter,

          class _Compare>

_OutputIter set_intersection(_InputIter1 __first1, _InputIter1 __last1,

                             _InputIter2 __first2, _InputIter2 __last2,

                             _OutputIter __result, _Compare __comp);

template <class _InputIter1, class _InputIter2, class _OutputIter>

_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,

                           _InputIter2 __first2, _InputIter2 __last2,

                           _OutputIter __result);

template <class _InputIter1, class _InputIter2, class _OutputIter,

          class _Compare>

_OutputIter set_difference(_InputIter1 __first1, _InputIter1 __last1,

                           _InputIter2 __first2, _InputIter2 __last2,

                           _OutputIter __result, _Compare __comp);

template <class _InputIter1, class _InputIter2, class _OutputIter>

_OutputIter

set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,

                         _InputIter2 __first2, _InputIter2 __last2,

                         _OutputIter __result);

template <class _InputIter1, class _InputIter2, class _OutputIter,

          class _Compare>

_OutputIter

set_symmetric_difference(_InputIter1 __first1, _InputIter1 __last1,

                         _InputIter2 __first2, _InputIter2 __last2,

                         _OutputIter __result,

                         _Compare __comp);

// min_element and max_element, with and without an explicitly supplied

// comparison function.

template <class _ForwardIter>

_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last);

template <class _ForwardIter, class _Compare>

_ForwardIter max_element(_ForwardIter __first, _ForwardIter __last,

                            _Compare __comp);

template <class _ForwardIter>

_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last);

template <class _ForwardIter, class _Compare>

_ForwardIter min_element(_ForwardIter __first, _ForwardIter __last,

                            _Compare __comp);

// next_permutation and prev_permutation, with and without an explicitly

// supplied comparison function.

template <class _BidirectionalIter>

bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last);

template <class _BidirectionalIter, class _Compare>

bool next_permutation(_BidirectionalIter __first, _BidirectionalIter __last,

                      _Compare __comp);

template <class _BidirectionalIter>

bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last);

template <class _BidirectionalIter, class _Compare>

bool prev_permutation(_BidirectionalIter __first, _BidirectionalIter __last,

                      _Compare __comp);

#if !defined (_STLP_NO_EXTENSIONS)

// is_heap, a predicate testing whether or not a range is

// a heap.  This function is an extension, not part of the C++

// standard.

template <class _RandomAccessIter>

bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last);

template <class _RandomAccessIter, class _StrictWeakOrdering>

bool is_heap(_RandomAccessIter __first, _RandomAccessIter __last,

             _StrictWeakOrdering __comp);

// is_sorted, a predicated testing whether a range is sorted in

// nondescending order.  This is an extension, not part of the C++

// standard.

_STLP_MOVE_TO_PRIV_NAMESPACE

template <class _ForwardIter, class _StrictWeakOrdering>

bool __is_sorted(_ForwardIter __first, _ForwardIter __last,

                 _StrictWeakOrdering __comp);

_STLP_MOVE_TO_STD_NAMESPACE

template <class _ForwardIter>

inline bool is_sorted(_ForwardIter __first, _ForwardIter __last) {

  return _STLP_PRIV __is_sorted(__first, __last,

                                _STLP_PRIV __less(_STLP_VALUE_TYPE(__first, _ForwardIter)));

}

template <class _ForwardIter, class _StrictWeakOrdering>

inline bool is_sorted(_ForwardIter __first, _ForwardIter __last,

                      _StrictWeakOrdering __comp) {

  return _STLP_PRIV __is_sorted(__first, __last, __comp);

}

#endif

_STLP_END_NAMESPACE

#if !defined (_STLP_LINK_TIME_INSTANTIATION)

#  include <stl/_algo.c>

#endif

#endif /* _STLP_INTERNAL_ALGO_H */

// Local Variables:

// mode:C++

// End: