FM / bits

/usr/include/c++/9/bits

Name	Size	Mode	Actions
algorithmfwd.h	21737	0644	edit dl rm
allocated_ptr.h	3293	0644	edit dl rm
allocator.h	7942	0644	edit dl rm
alloc_traits.h	21481	0644	edit dl rm
atomic_base.h	24993	0644	edit dl rm
atomic_futex.h	9499	0644	edit dl rm
atomic_lockfree_defines.h	2353	0644	edit dl rm
basic_ios.h	16080	0644	edit dl rm
basic_ios.tcc	6083	0644	edit dl rm
basic_string.h	247075	0644	edit dl rm
basic_string.tcc	53891	0644	edit dl rm
boost_concept_check.h	27161	0644	edit dl rm
c++0x_warning.h	1474	0644	edit dl rm
char_traits.h	24828	0644	edit dl rm
codecvt.h	25429	0644	edit dl rm
concept_check.h	3423	0644	edit dl rm
cpp_type_traits.h	9947	0644	edit dl rm
cxxabi_forced.h	1811	0644	edit dl rm
cxxabi_init_exception.h	2220	0644	edit dl rm
deque.tcc	34404	0644	edit dl rm
enable_special_members.h	12387	0644	edit dl rm
erase_if.h	2037	0644	edit dl rm
exception.h	2486	0644	edit dl rm
exception_defines.h	1645	0644	edit dl rm
exception_ptr.h	5982	0644	edit dl rm
forward_list.h	49405	0644	edit dl rm
forward_list.tcc	13871	0644	edit dl rm
fstream.tcc	33663	0644	edit dl rm
fs_dir.h	15168	0644	edit dl rm
fs_fwd.h	11687	0644	edit dl rm
fs_ops.h	9731	0644	edit dl rm
fs_path.h	36954	0644	edit dl rm
functexcept.h	3433	0644	edit dl rm
functional_hash.h	8568	0644	edit dl rm
gslice.h	5519	0644	edit dl rm
gslice_array.h	7852	0644	edit dl rm
hashtable.h	74814	0644	edit dl rm
hashtable_policy.h	68109	0644	edit dl rm
hash_bytes.h	2146	0644	edit dl rm
indirect_array.h	7862	0644	edit dl rm
invoke.h	3657	0644	edit dl rm
ios_base.h	31434	0644	edit dl rm
istream.tcc	31093	0644	edit dl rm
list.tcc	16968	0644	edit dl rm
localefwd.h	5941	0644	edit dl rm
locale_classes.h	24903	0644	edit dl rm
locale_classes.tcc	8375	0644	edit dl rm
locale_conv.h	18801	0644	edit dl rm
locale_facets.h	92339	0644	edit dl rm
locale_facets.tcc	39548	0644	edit dl rm
locale_facets_nonio.h	68994	0644	edit dl rm
locale_facets_nonio.tcc	45280	0644	edit dl rm
mask_array.h	7676	0644	edit dl rm
memoryfwd.h	2453	0644	edit dl rm
move.h	6529	0644	edit dl rm
nested_exception.h	4803	0644	edit dl rm
node_handle.h	8216	0644	edit dl rm
ostream.tcc	12315	0644	edit dl rm
ostream_insert.h	4002	0644	edit dl rm
parse_numbers.h	7944	0644	edit dl rm
postypes.h	8465	0644	edit dl rm
predefined_ops.h	9083	0644	edit dl rm
ptr_traits.h	6728	0644	edit dl rm
quoted_string.h	5053	0644	edit dl rm
random.h	178041	0644	edit dl rm
random.tcc	105619	0644	edit dl rm
range_access.h	10084	0644	edit dl rm
refwrap.h	12927	0644	edit dl rm
regex.h	98707	0644	edit dl rm
regex.tcc	16574	0644	edit dl rm
regex_automaton.h	10739	0644	edit dl rm
regex_automaton.tcc	7722	0644	edit dl rm
regex_compiler.h	16482	0644	edit dl rm
regex_compiler.tcc	18929	0644	edit dl rm
regex_constants.h	14707	0644	edit dl rm
regex_error.h	4907	0644	edit dl rm
regex_executor.h	7489	0644	edit dl rm
regex_executor.tcc	18841	0644	edit dl rm
regex_scanner.h	7089	0644	edit dl rm
regex_scanner.tcc	15009	0644	edit dl rm
shared_ptr.h	24221	0644	edit dl rm
shared_ptr_atomic.h	9775	0644	edit dl rm
shared_ptr_base.h	53771	0644	edit dl rm
slice_array.h	9430	0644	edit dl rm
specfun.h	47052	0644	edit dl rm
sstream.tcc	10142	0644	edit dl rm
std_abs.h	3384	0644	edit dl rm
std_function.h	23566	0644	edit dl rm
std_mutex.h	4768	0644	edit dl rm
stl_algo.h	215416	0644	edit dl rm
stl_algobase.h	51417	0644	edit dl rm
stl_bvector.h	33888	0644	edit dl rm
stl_construct.h	7397	0644	edit dl rm
stl_deque.h	80116	0644	edit dl rm
stl_function.h	42293	0644	edit dl rm
stl_heap.h	20206	0644	edit dl rm
stl_iterator.h	42755	0644	edit dl rm
stl_iterator_base_funcs.h	8178	0644	edit dl rm
stl_iterator_base_types.h	8682	0644	edit dl rm
stl_list.h	67809	0644	edit dl rm
stl_map.h	53495	0644	edit dl rm
stl_multimap.h	42240	0644	edit dl rm
stl_multiset.h	36486	0644	edit dl rm
stl_numeric.h	14376	0644	edit dl rm
stl_pair.h	18642	0644	edit dl rm
stl_queue.h	24580	0644	edit dl rm
stl_raw_storage_iter.h	3830	0644	edit dl rm
stl_relops.h	4594	0644	edit dl rm
stl_set.h	36790	0644	edit dl rm
stl_stack.h	12228	0644	edit dl rm
stl_tempbuf.h	8287	0644	edit dl rm
stl_tree.h	75018	0644	edit dl rm
stl_uninitialized.h	31455	0644	edit dl rm
stl_vector.h	64968	0644	edit dl rm
streambuf.tcc	4929	0644	edit dl rm
streambuf_iterator.h	13889	0644	edit dl rm
stream_iterator.h	6867	0644	edit dl rm
stringfwd.h	2690	0644	edit dl rm
string_view.tcc	6698	0644	edit dl rm
uniform_int_dist.h	10248	0644	edit dl rm
unique_lock.h	6102	0644	edit dl rm
unique_ptr.h	27564	0644	edit dl rm
unordered_map.h	76884	0644	edit dl rm
unordered_set.h	60677	0644	edit dl rm
uses_allocator.h	6824	0644	edit dl rm
valarray_after.h	22839	0644	edit dl rm
valarray_array.h	21295	0644	edit dl rm
valarray_array.tcc	7254	0644	edit dl rm
valarray_before.h	19142	0644	edit dl rm
vector.tcc	30870	0644	edit dl rm

Edit: /usr/include/c++/9/bits/algorithmfwd.h (21737B)

// <algorithm> Forward declarations  -*- C++ -*-

// Copyright (C) 2007-2019 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file bits/algorithmfwd.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{algorithm}
 */

#ifndef _GLIBCXX_ALGORITHMFWD_H
#define _GLIBCXX_ALGORITHMFWD_H 1

#pragma GCC system_header

#include <bits/c++config.h>
#include <bits/stl_pair.h>
#include <bits/stl_iterator_base_types.h>
#if __cplusplus >= 201103L
#include <initializer_list>
#endif

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

/*
    adjacent_find
    all_of (C++11)
    any_of (C++11)
    binary_search
    clamp (C++17)
    copy
    copy_backward
    copy_if (C++11)
    copy_n (C++11)
    count
    count_if
    equal
    equal_range
    fill
    fill_n
    find
    find_end
    find_first_of
    find_if
    find_if_not (C++11)
    for_each
    generate
    generate_n
    includes
    inplace_merge
    is_heap (C++11)
    is_heap_until (C++11)
    is_partitioned (C++11)
    is_sorted (C++11)
    is_sorted_until (C++11)
    iter_swap
    lexicographical_compare
    lower_bound
    make_heap
    max
    max_element
    merge
    min
    min_element
    minmax (C++11)
    minmax_element (C++11)
    mismatch
    next_permutation
    none_of (C++11)
    nth_element
    partial_sort
    partial_sort_copy
    partition
    partition_copy (C++11)
    partition_point (C++11)
    pop_heap
    prev_permutation
    push_heap
    random_shuffle
    remove
    remove_copy
    remove_copy_if
    remove_if
    replace
    replace_copy
    replace_copy_if
    replace_if
    reverse
    reverse_copy
    rotate
    rotate_copy
    search
    search_n
    set_difference
    set_intersection
    set_symmetric_difference
    set_union
    shuffle (C++11)
    sort
    sort_heap
    stable_partition
    stable_sort
    swap
    swap_ranges
    transform
    unique
    unique_copy
    upper_bound
  */

/**
   * @defgroup algorithms Algorithms
   *
   * Components for performing algorithmic operations. Includes
   * non-modifying sequence, modifying (mutating) sequence, sorting,
   * searching, merge, partition, heap, set, minima, maxima, and
   * permutation operations.
   */

/**
   * @defgroup mutating_algorithms Mutating
   * @ingroup algorithms
   */

/**
   * @defgroup non_mutating_algorithms Non-Mutating
   * @ingroup algorithms
   */

/**
   * @defgroup sorting_algorithms Sorting
   * @ingroup algorithms
   */

/**
   * @defgroup set_algorithms Set Operations
   * @ingroup sorting_algorithms
   *
   * These algorithms are common set operations performed on sequences
   * that are already sorted. The number of comparisons will be
   * linear.
   */

/**
   * @defgroup binary_search_algorithms Binary Search
   * @ingroup sorting_algorithms
   *
   * These algorithms are variations of a classic binary search, and
   * all assume that the sequence being searched is already sorted.
   *
   * The number of comparisons will be logarithmic (and as few as
   * possible).  The number of steps through the sequence will be
   * logarithmic for random-access iterators (e.g., pointers), and
   * linear otherwise.
   *
   * The LWG has passed Defect Report 270, which notes: <em>The
   * proposed resolution reinterprets binary search. Instead of
   * thinking about searching for a value in a sorted range, we view
   * that as an important special case of a more general algorithm:
   * searching for the partition point in a partitioned range.  We
   * also add a guarantee that the old wording did not: we ensure that
   * the upper bound is no earlier than the lower bound, that the pair
   * returned by equal_range is a valid range, and that the first part
   * of that pair is the lower bound.</em>
   *
   * The actual effect of the first sentence is that a comparison
   * functor passed by the user doesn't necessarily need to induce a
   * strict weak ordering relation.  Rather, it partitions the range.
   */

// adjacent_find

#if __cplusplus >= 201103L
  template<typename _IIter, typename _Predicate>
    bool
    all_of(_IIter, _IIter, _Predicate);

template<typename _IIter, typename _Predicate>
    bool
    any_of(_IIter, _IIter, _Predicate);
#endif

template<typename _FIter, typename _Tp>
    bool
    binary_search(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Tp, typename _Compare>
    bool
    binary_search(_FIter, _FIter, const _Tp&, _Compare);

#if __cplusplus > 201402L
  template<typename _Tp>
    _GLIBCXX14_CONSTEXPR
    const _Tp&
    clamp(const _Tp&, const _Tp&, const _Tp&);

template<typename _Tp, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    const _Tp&
    clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);
#endif

template<typename _IIter, typename _OIter>
    _OIter
    copy(_IIter, _IIter, _OIter);

template<typename _BIter1, typename _BIter2>
    _BIter2
    copy_backward(_BIter1, _BIter1, _BIter2);

#if __cplusplus >= 201103L
  template<typename _IIter, typename _OIter, typename _Predicate>
    _OIter
    copy_if(_IIter, _IIter, _OIter, _Predicate);

template<typename _IIter, typename _Size, typename _OIter>
    _OIter
    copy_n(_IIter, _Size, _OIter);
#endif

// count
  // count_if

template<typename _FIter, typename _Tp>
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Tp, typename _Compare>
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&, _Compare);

template<typename _FIter, typename _Tp>
    void
    fill(_FIter, _FIter, const _Tp&);

template<typename _OIter, typename _Size, typename _Tp>
    _OIter
    fill_n(_OIter, _Size, const _Tp&);

// find

template<typename _FIter1, typename _FIter2>
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2);

template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

// find_first_of
  // find_if

#if __cplusplus >= 201103L
  template<typename _IIter, typename _Predicate>
    _IIter
    find_if_not(_IIter, _IIter, _Predicate);
#endif

// for_each
  // generate
  // generate_n

template<typename _IIter1, typename _IIter2>
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2);

template<typename _IIter1, typename _IIter2, typename _Compare>
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

template<typename _BIter>
    void
    inplace_merge(_BIter, _BIter, _BIter);

template<typename _BIter, typename _Compare>
    void
    inplace_merge(_BIter, _BIter, _BIter, _Compare);

#if __cplusplus >= 201103L
  template<typename _RAIter>
    bool
    is_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    bool
    is_heap(_RAIter, _RAIter, _Compare);

template<typename _RAIter>
    _RAIter
    is_heap_until(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    _RAIter
    is_heap_until(_RAIter, _RAIter, _Compare);

template<typename _IIter, typename _Predicate>
    bool
    is_partitioned(_IIter, _IIter, _Predicate);

template<typename _FIter1, typename _FIter2>
    bool
    is_permutation(_FIter1, _FIter1, _FIter2);

template<typename _FIter1, typename _FIter2,
	   typename _BinaryPredicate>
    bool
    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);

template<typename _FIter>
    bool
    is_sorted(_FIter, _FIter);

template<typename _FIter, typename _Compare>
    bool
    is_sorted(_FIter, _FIter, _Compare);

template<typename _FIter>
    _FIter
    is_sorted_until(_FIter, _FIter);

template<typename _FIter, typename _Compare>
    _FIter
    is_sorted_until(_FIter, _FIter, _Compare);
#endif

template<typename _FIter1, typename _FIter2>
    void
    iter_swap(_FIter1, _FIter2);

template<typename _FIter, typename _Tp>
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Tp, typename _Compare>
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&, _Compare);

template<typename _RAIter>
    void
    make_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    void
    make_heap(_RAIter, _RAIter, _Compare);

template<typename _Tp>
    _GLIBCXX14_CONSTEXPR
    const _Tp&
    max(const _Tp&, const _Tp&);

template<typename _Tp, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    const _Tp&
    max(const _Tp&, const _Tp&, _Compare);

// max_element
  // merge

template<typename _Tp>
    _GLIBCXX14_CONSTEXPR
    const _Tp&
    min(const _Tp&, const _Tp&);

template<typename _Tp, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    const _Tp&
    min(const _Tp&, const _Tp&, _Compare);

// min_element

#if __cplusplus >= 201103L
  template<typename _Tp>
    _GLIBCXX14_CONSTEXPR
    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&);

template<typename _Tp, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&, _Compare);

template<typename _FIter>
    _GLIBCXX14_CONSTEXPR
    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter);

template<typename _FIter, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter, _Compare);

template<typename _Tp>
    _GLIBCXX14_CONSTEXPR
    _Tp
    min(initializer_list<_Tp>);

template<typename _Tp, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    _Tp
    min(initializer_list<_Tp>, _Compare);

template<typename _Tp>
    _GLIBCXX14_CONSTEXPR
    _Tp
    max(initializer_list<_Tp>);

template<typename _Tp, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    _Tp
    max(initializer_list<_Tp>, _Compare);

template<typename _Tp>
    _GLIBCXX14_CONSTEXPR
    pair<_Tp, _Tp>
    minmax(initializer_list<_Tp>);

template<typename _Tp, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    pair<_Tp, _Tp>
    minmax(initializer_list<_Tp>, _Compare);
#endif

// mismatch

template<typename _BIter>
    bool
    next_permutation(_BIter, _BIter);

template<typename _BIter, typename _Compare>
    bool
    next_permutation(_BIter, _BIter, _Compare);

#if __cplusplus >= 201103L
  template<typename _IIter, typename _Predicate>
    bool
    none_of(_IIter, _IIter, _Predicate);
#endif

// nth_element
  // partial_sort

template<typename _IIter, typename _RAIter>
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);

template<typename _IIter, typename _RAIter, typename _Compare>
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);

// partition

#if __cplusplus >= 201103L
  template<typename _IIter, typename _OIter1,
	   typename _OIter2, typename _Predicate>
    pair<_OIter1, _OIter2>
    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);

template<typename _FIter, typename _Predicate>
    _FIter
    partition_point(_FIter, _FIter, _Predicate);
#endif

template<typename _RAIter>
    void
    pop_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    void
    pop_heap(_RAIter, _RAIter, _Compare);

template<typename _BIter>
    bool
    prev_permutation(_BIter, _BIter);

template<typename _BIter, typename _Compare>
    bool
    prev_permutation(_BIter, _BIter, _Compare);

template<typename _RAIter>
    void
    push_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    void
    push_heap(_RAIter, _RAIter, _Compare);

// random_shuffle

template<typename _FIter, typename _Tp>
    _FIter
    remove(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Predicate>
    _FIter
    remove_if(_FIter, _FIter, _Predicate);

template<typename _IIter, typename _OIter, typename _Tp>
    _OIter
    remove_copy(_IIter, _IIter, _OIter, const _Tp&);

template<typename _IIter, typename _OIter, typename _Predicate>
    _OIter
    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);

// replace

template<typename _IIter, typename _OIter, typename _Tp>
    _OIter
    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);

template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
    _OIter
    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);

// replace_if

template<typename _BIter>
    void
    reverse(_BIter, _BIter);

template<typename _BIter, typename _OIter>
    _OIter
    reverse_copy(_BIter, _BIter, _OIter);

inline namespace _V2
  {
    template<typename _FIter>
      _FIter
      rotate(_FIter, _FIter, _FIter);
  }

template<typename _FIter, typename _OIter>
    _OIter
    rotate_copy(_FIter, _FIter, _FIter, _OIter);

// search
  // search_n
  // set_difference
  // set_intersection
  // set_symmetric_difference
  // set_union

#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
  template<typename _RAIter, typename _UGenerator>
    void
    shuffle(_RAIter, _RAIter, _UGenerator&&);
#endif

template<typename _RAIter>
    void
    sort_heap(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    void
    sort_heap(_RAIter, _RAIter, _Compare);

template<typename _BIter, typename _Predicate>
    _BIter
    stable_partition(_BIter, _BIter, _Predicate);

#if __cplusplus < 201103L
  // For C++11 swap() is declared in <type_traits>.

template<typename _Tp, size_t _Nm>
    inline void
    swap(_Tp& __a, _Tp& __b);

template<typename _Tp, size_t _Nm>
    inline void
    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]);
#endif

template<typename _FIter1, typename _FIter2>
    _FIter2
    swap_ranges(_FIter1, _FIter1, _FIter2);

// transform

template<typename _FIter>
    _FIter
    unique(_FIter, _FIter);

template<typename _FIter, typename _BinaryPredicate>
    _FIter
    unique(_FIter, _FIter, _BinaryPredicate);

// unique_copy

template<typename _FIter, typename _Tp>
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&);

template<typename _FIter, typename _Tp, typename _Compare>
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&, _Compare);

_GLIBCXX_BEGIN_NAMESPACE_ALGO

template<typename _FIter>
    _FIter
    adjacent_find(_FIter, _FIter);

template<typename _FIter, typename _BinaryPredicate>
    _FIter
    adjacent_find(_FIter, _FIter, _BinaryPredicate);

template<typename _IIter, typename _Tp>
    typename iterator_traits<_IIter>::difference_type
    count(_IIter, _IIter, const _Tp&);

template<typename _IIter, typename _Predicate>
    typename iterator_traits<_IIter>::difference_type
    count_if(_IIter, _IIter, _Predicate);

template<typename _IIter1, typename _IIter2>
    bool
    equal(_IIter1, _IIter1, _IIter2);

template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    bool
    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

template<typename _IIter, typename _Tp>
    _IIter
    find(_IIter, _IIter, const _Tp&);

template<typename _FIter1, typename _FIter2>
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);

template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

template<typename _IIter, typename _Predicate>
    _IIter
    find_if(_IIter, _IIter, _Predicate);

template<typename _IIter, typename _Funct>
    _Funct
    for_each(_IIter, _IIter, _Funct);

template<typename _FIter, typename _Generator>
    void
    generate(_FIter, _FIter, _Generator);

template<typename _OIter, typename _Size, typename _Generator>
    _OIter
    generate_n(_OIter, _Size, _Generator);

template<typename _IIter1, typename _IIter2>
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);

template<typename _IIter1, typename _IIter2, typename _Compare>
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

template<typename _FIter>
    _GLIBCXX14_CONSTEXPR
    _FIter
    max_element(_FIter, _FIter);

template<typename _FIter, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    _FIter
    max_element(_FIter, _FIter, _Compare);

template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,
	   typename _Compare>
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

template<typename _FIter>
    _GLIBCXX14_CONSTEXPR
    _FIter
    min_element(_FIter, _FIter);

template<typename _FIter, typename _Compare>
    _GLIBCXX14_CONSTEXPR
    _FIter
    min_element(_FIter, _FIter, _Compare);

template<typename _IIter1, typename _IIter2>
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2);

template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

template<typename _RAIter>
    void
    nth_element(_RAIter, _RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    void
    nth_element(_RAIter, _RAIter, _RAIter, _Compare);

template<typename _RAIter>
    void
    partial_sort(_RAIter, _RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    void
    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);

template<typename _BIter, typename _Predicate>
    _BIter
    partition(_BIter, _BIter, _Predicate);

template<typename _RAIter>
    void
    random_shuffle(_RAIter, _RAIter);

template<typename _RAIter, typename _Generator>
    void
    random_shuffle(_RAIter, _RAIter,
#if __cplusplus >= 201103L
		   _Generator&&);
#else
		   _Generator&);
#endif

template<typename _FIter, typename _Tp>
    void
    replace(_FIter, _FIter, const _Tp&, const _Tp&);

template<typename _FIter, typename _Predicate, typename _Tp>
    void
    replace_if(_FIter, _FIter, _Predicate, const _Tp&);

template<typename _FIter1, typename _FIter2>
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2);

template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

template<typename _FIter, typename _Size, typename _Tp>
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&);

template<typename _FIter, typename _Size, typename _Tp,
	   typename _BinaryPredicate>
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);

template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,
	   typename _Compare>
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,
	   typename _Compare>
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,
	   typename _Compare>
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
			     _OIter, _Compare);

template<typename _IIter1, typename _IIter2, typename _OIter>
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

template<typename _IIter1, typename _IIter2, typename _OIter,
	   typename _Compare>
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

template<typename _RAIter>
    void
    sort(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    void
    sort(_RAIter, _RAIter, _Compare);

template<typename _RAIter>
    void
    stable_sort(_RAIter, _RAIter);

template<typename _RAIter, typename _Compare>
    void
    stable_sort(_RAIter, _RAIter, _Compare);

template<typename _IIter, typename _OIter, typename _UnaryOperation>
    _OIter
    transform(_IIter, _IIter, _OIter, _UnaryOperation);

template<typename _IIter1, typename _IIter2, typename _OIter,
	   typename _BinaryOperation>
    _OIter
    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);

template<typename _IIter, typename _OIter>
    _OIter
    unique_copy(_IIter, _IIter, _OIter);

template<typename _IIter, typename _OIter, typename _BinaryPredicate>
    _OIter
    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);

_GLIBCXX_END_NAMESPACE_ALGO
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#ifdef _GLIBCXX_PARALLEL
# include <parallel/algorithmfwd.h>
#endif

#endif

cmd: