1    	// <algorithm> Forward declarations  -*- C++ -*-
2    	
3    	// Copyright (C) 2007-2017 Free Software Foundation, Inc.
4    	//
5    	// This file is part of the GNU ISO C++ Library.  This library is free
6    	// software; you can redistribute it and/or modify it under the
7    	// terms of the GNU General Public License as published by the
8    	// Free Software Foundation; either version 3, or (at your option)
9    	// any later version.
10   	
11   	// This library is distributed in the hope that it will be useful,
12   	// but WITHOUT ANY WARRANTY; without even the implied warranty of
13   	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   	// GNU General Public License for more details.
15   	
16   	// Under Section 7 of GPL version 3, you are granted additional
17   	// permissions described in the GCC Runtime Library Exception, version
18   	// 3.1, as published by the Free Software Foundation.
19   	
20   	// You should have received a copy of the GNU General Public License and
21   	// a copy of the GCC Runtime Library Exception along with this program;
22   	// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23   	// <http://www.gnu.org/licenses/>.
24   	
25   	/** @file bits/algorithmfwd.h
26   	 *  This is an internal header file, included by other library headers.
27   	 *  Do not attempt to use it directly. @headername{algorithm}
28   	 */
29   	
30   	#ifndef _GLIBCXX_ALGORITHMFWD_H
31   	#define _GLIBCXX_ALGORITHMFWD_H 1
32   	
33   	#pragma GCC system_header
34   	
35   	#include <bits/c++config.h>
36   	#include <bits/stl_pair.h>
37   	#include <bits/stl_iterator_base_types.h>
38   	#if __cplusplus >= 201103L
39   	#include <initializer_list>
40   	#endif
41   	
42   	namespace std _GLIBCXX_VISIBILITY(default)
43   	{
44   	_GLIBCXX_BEGIN_NAMESPACE_VERSION
45   	
46   	  /*
47   	    adjacent_find
48   	    all_of (C++11)
49   	    any_of (C++11)
50   	    binary_search
51   	    clamp (C++17)
52   	    copy
53   	    copy_backward
54   	    copy_if (C++11)
55   	    copy_n (C++11)
56   	    count
57   	    count_if
58   	    equal
59   	    equal_range
60   	    fill
61   	    fill_n
62   	    find
63   	    find_end
64   	    find_first_of
65   	    find_if
66   	    find_if_not (C++11)
67   	    for_each
68   	    generate
69   	    generate_n
70   	    includes
71   	    inplace_merge
72   	    is_heap (C++11)
73   	    is_heap_until (C++11)
74   	    is_partitioned (C++11)
75   	    is_sorted (C++11)
76   	    is_sorted_until (C++11)
77   	    iter_swap
78   	    lexicographical_compare
79   	    lower_bound
80   	    make_heap
81   	    max
82   	    max_element
83   	    merge
84   	    min
85   	    min_element
86   	    minmax (C++11)
87   	    minmax_element (C++11)
88   	    mismatch
89   	    next_permutation
90   	    none_of (C++11)
91   	    nth_element
92   	    partial_sort
93   	    partial_sort_copy
94   	    partition
95   	    partition_copy (C++11)
96   	    partition_point (C++11)
97   	    pop_heap
98   	    prev_permutation
99   	    push_heap
100  	    random_shuffle
101  	    remove
102  	    remove_copy
103  	    remove_copy_if
104  	    remove_if
105  	    replace
106  	    replace_copy
107  	    replace_copy_if
108  	    replace_if
109  	    reverse
110  	    reverse_copy
111  	    rotate
112  	    rotate_copy
113  	    search
114  	    search_n
115  	    set_difference
116  	    set_intersection
117  	    set_symmetric_difference
118  	    set_union
119  	    shuffle (C++11)
120  	    sort
121  	    sort_heap
122  	    stable_partition
123  	    stable_sort
124  	    swap
125  	    swap_ranges
126  	    transform
127  	    unique
128  	    unique_copy
129  	    upper_bound
130  	  */
131  	
132  	  /**
133  	   * @defgroup algorithms Algorithms
134  	   *
135  	   * Components for performing algorithmic operations. Includes
136  	   * non-modifying sequence, modifying (mutating) sequence, sorting,
137  	   * searching, merge, partition, heap, set, minima, maxima, and
138  	   * permutation operations.
139  	   */
140  	
141  	  /**
142  	   * @defgroup mutating_algorithms Mutating
143  	   * @ingroup algorithms
144  	   */
145  	
146  	  /**
147  	   * @defgroup non_mutating_algorithms Non-Mutating
148  	   * @ingroup algorithms
149  	   */
150  	
151  	  /**
152  	   * @defgroup sorting_algorithms Sorting
153  	   * @ingroup algorithms
154  	   */
155  	
156  	  /**
157  	   * @defgroup set_algorithms Set Operation
158  	   * @ingroup sorting_algorithms
159  	   *
160  	   * These algorithms are common set operations performed on sequences
161  	   * that are already sorted. The number of comparisons will be
162  	   * linear.
163  	   */
164  	
165  	  /**
166  	   * @defgroup binary_search_algorithms Binary Search
167  	   * @ingroup sorting_algorithms
168  	   *
169  	   * These algorithms are variations of a classic binary search, and
170  	   * all assume that the sequence being searched is already sorted.
171  	   *
172  	   * The number of comparisons will be logarithmic (and as few as
173  	   * possible).  The number of steps through the sequence will be
174  	   * logarithmic for random-access iterators (e.g., pointers), and
175  	   * linear otherwise.
176  	   *
177  	   * The LWG has passed Defect Report 270, which notes: <em>The
178  	   * proposed resolution reinterprets binary search. Instead of
179  	   * thinking about searching for a value in a sorted range, we view
180  	   * that as an important special case of a more general algorithm:
181  	   * searching for the partition point in a partitioned range.  We
182  	   * also add a guarantee that the old wording did not: we ensure that
183  	   * the upper bound is no earlier than the lower bound, that the pair
184  	   * returned by equal_range is a valid range, and that the first part
185  	   * of that pair is the lower bound.</em>
186  	   *
187  	   * The actual effect of the first sentence is that a comparison
188  	   * functor passed by the user doesn't necessarily need to induce a
189  	   * strict weak ordering relation.  Rather, it partitions the range.
190  	   */
191  	
192  	  // adjacent_find
193  	
194  	#if __cplusplus >= 201103L
195  	  template<typename _IIter, typename _Predicate>
196  	    bool
197  	    all_of(_IIter, _IIter, _Predicate);
198  	
199  	  template<typename _IIter, typename _Predicate>
200  	    bool
201  	    any_of(_IIter, _IIter, _Predicate);
202  	#endif
203  	
204  	  template<typename _FIter, typename _Tp>
205  	    bool
206  	    binary_search(_FIter, _FIter, const _Tp&);
207  	
208  	  template<typename _FIter, typename _Tp, typename _Compare>
209  	    bool
210  	    binary_search(_FIter, _FIter, const _Tp&, _Compare);
211  	
212  	#if __cplusplus > 201402L
213  	  template<typename _Tp>
214  	    _GLIBCXX14_CONSTEXPR
215  	    const _Tp&
216  	    clamp(const _Tp&, const _Tp&, const _Tp&);
217  	
218  	  template<typename _Tp, typename _Compare>
219  	    _GLIBCXX14_CONSTEXPR
220  	    const _Tp&
221  	    clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);
222  	#endif
223  	
224  	  template<typename _IIter, typename _OIter>
225  	    _OIter
226  	    copy(_IIter, _IIter, _OIter);
227  	
228  	  template<typename _BIter1, typename _BIter2>
229  	    _BIter2
230  	    copy_backward(_BIter1, _BIter1, _BIter2);
231  	
232  	#if __cplusplus >= 201103L
233  	  template<typename _IIter, typename _OIter, typename _Predicate>
234  	    _OIter
235  	    copy_if(_IIter, _IIter, _OIter, _Predicate);
236  	
237  	  template<typename _IIter, typename _Size, typename _OIter>
238  	    _OIter
239  	    copy_n(_IIter, _Size, _OIter);
240  	#endif
241  	
242  	  // count
243  	  // count_if
244  	
245  	  template<typename _FIter, typename _Tp>
246  	    pair<_FIter, _FIter>
247  	    equal_range(_FIter, _FIter, const _Tp&);
248  	
249  	  template<typename _FIter, typename _Tp, typename _Compare>
250  	    pair<_FIter, _FIter>
251  	    equal_range(_FIter, _FIter, const _Tp&, _Compare);
252  	
253  	  template<typename _FIter, typename _Tp>
254  	    void
255  	    fill(_FIter, _FIter, const _Tp&);
256  	
257  	  template<typename _OIter, typename _Size, typename _Tp>
258  	    _OIter
259  	    fill_n(_OIter, _Size, const _Tp&);
260  	
261  	  // find
262  	
263  	  template<typename _FIter1, typename _FIter2>
264  	    _FIter1
265  	    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
266  	
267  	  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
268  	    _FIter1
269  	    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
270  	
271  	  // find_first_of
272  	  // find_if
273  	
274  	#if __cplusplus >= 201103L
275  	  template<typename _IIter, typename _Predicate>
276  	    _IIter
277  	    find_if_not(_IIter, _IIter, _Predicate);
278  	#endif
279  	
280  	  // for_each
281  	  // generate
282  	  // generate_n
283  	
284  	  template<typename _IIter1, typename _IIter2>
285  	    bool
286  	    includes(_IIter1, _IIter1, _IIter2, _IIter2);
287  	
288  	  template<typename _IIter1, typename _IIter2, typename _Compare>
289  	    bool
290  	    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
291  	
292  	  template<typename _BIter>
293  	    void
294  	    inplace_merge(_BIter, _BIter, _BIter);
295  	
296  	  template<typename _BIter, typename _Compare>
297  	    void
298  	    inplace_merge(_BIter, _BIter, _BIter, _Compare);
299  	
300  	#if __cplusplus >= 201103L
301  	  template<typename _RAIter>
302  	    bool
303  	    is_heap(_RAIter, _RAIter);
304  	
305  	  template<typename _RAIter, typename _Compare>
306  	    bool
307  	    is_heap(_RAIter, _RAIter, _Compare);
308  	
309  	  template<typename _RAIter>
310  	    _RAIter
311  	    is_heap_until(_RAIter, _RAIter);
312  	
313  	  template<typename _RAIter, typename _Compare>
314  	    _RAIter
315  	    is_heap_until(_RAIter, _RAIter, _Compare);
316  	
317  	  template<typename _IIter, typename _Predicate>
318  	    bool
319  	    is_partitioned(_IIter, _IIter, _Predicate);
320  	
321  	  template<typename _FIter1, typename _FIter2>
322  	    bool
323  	    is_permutation(_FIter1, _FIter1, _FIter2);
324  	
325  	  template<typename _FIter1, typename _FIter2,
326  		   typename _BinaryPredicate>
327  	    bool
328  	    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
329  	
330  	  template<typename _FIter>
331  	    bool
332  	    is_sorted(_FIter, _FIter);
333  	
334  	  template<typename _FIter, typename _Compare>
335  	    bool
336  	    is_sorted(_FIter, _FIter, _Compare);
337  	
338  	  template<typename _FIter>
339  	    _FIter
340  	    is_sorted_until(_FIter, _FIter);
341  	
342  	  template<typename _FIter, typename _Compare>
343  	    _FIter
344  	    is_sorted_until(_FIter, _FIter, _Compare);
345  	#endif
346  	
347  	  template<typename _FIter1, typename _FIter2>
348  	    void
349  	    iter_swap(_FIter1, _FIter2);
350  	
351  	  template<typename _FIter, typename _Tp>
352  	    _FIter
353  	    lower_bound(_FIter, _FIter, const _Tp&);
354  	
355  	  template<typename _FIter, typename _Tp, typename _Compare>
356  	    _FIter
357  	    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
358  	
359  	  template<typename _RAIter>
360  	    void
361  	    make_heap(_RAIter, _RAIter);
362  	
363  	  template<typename _RAIter, typename _Compare>
364  	    void
365  	    make_heap(_RAIter, _RAIter, _Compare);
366  	
367  	  template<typename _Tp>
368  	    _GLIBCXX14_CONSTEXPR
369  	    const _Tp&
370  	    max(const _Tp&, const _Tp&);
371  	
372  	  template<typename _Tp, typename _Compare>
373  	    _GLIBCXX14_CONSTEXPR
374  	    const _Tp&
375  	    max(const _Tp&, const _Tp&, _Compare);
376  	
377  	  // max_element
378  	  // merge
379  	
380  	  template<typename _Tp>
381  	    _GLIBCXX14_CONSTEXPR
382  	    const _Tp&
383  	    min(const _Tp&, const _Tp&);
384  	
385  	  template<typename _Tp, typename _Compare>
386  	    _GLIBCXX14_CONSTEXPR
387  	    const _Tp&
388  	    min(const _Tp&, const _Tp&, _Compare);
389  	
390  	  // min_element
391  	
392  	#if __cplusplus >= 201103L
393  	  template<typename _Tp>
394  	    _GLIBCXX14_CONSTEXPR
395  	    pair<const _Tp&, const _Tp&>
396  	    minmax(const _Tp&, const _Tp&);
397  	
398  	  template<typename _Tp, typename _Compare>
399  	    _GLIBCXX14_CONSTEXPR
400  	    pair<const _Tp&, const _Tp&>
401  	    minmax(const _Tp&, const _Tp&, _Compare);
402  	
403  	  template<typename _FIter>
404  	    _GLIBCXX14_CONSTEXPR
405  	    pair<_FIter, _FIter>
406  	    minmax_element(_FIter, _FIter);
407  	
408  	  template<typename _FIter, typename _Compare>
409  	    _GLIBCXX14_CONSTEXPR
410  	    pair<_FIter, _FIter>
411  	    minmax_element(_FIter, _FIter, _Compare);
412  	
413  	  template<typename _Tp>
414  	    _GLIBCXX14_CONSTEXPR
415  	    _Tp
416  	    min(initializer_list<_Tp>);
417  	
418  	  template<typename _Tp, typename _Compare>
419  	    _GLIBCXX14_CONSTEXPR
420  	    _Tp
421  	    min(initializer_list<_Tp>, _Compare);
422  	
423  	  template<typename _Tp>
424  	    _GLIBCXX14_CONSTEXPR
425  	    _Tp
426  	    max(initializer_list<_Tp>);
427  	
428  	  template<typename _Tp, typename _Compare>
429  	    _GLIBCXX14_CONSTEXPR
430  	    _Tp
431  	    max(initializer_list<_Tp>, _Compare);
432  	
433  	  template<typename _Tp>
434  	    _GLIBCXX14_CONSTEXPR
435  	    pair<_Tp, _Tp>
436  	    minmax(initializer_list<_Tp>);
437  	
438  	  template<typename _Tp, typename _Compare>
439  	    _GLIBCXX14_CONSTEXPR
440  	    pair<_Tp, _Tp>
441  	    minmax(initializer_list<_Tp>, _Compare);
442  	#endif
443  	
444  	  // mismatch
445  	
446  	  template<typename _BIter>
447  	    bool
448  	    next_permutation(_BIter, _BIter);
449  	
450  	  template<typename _BIter, typename _Compare>
451  	    bool
452  	    next_permutation(_BIter, _BIter, _Compare);
453  	
454  	#if __cplusplus >= 201103L
455  	  template<typename _IIter, typename _Predicate>
456  	    bool
457  	    none_of(_IIter, _IIter, _Predicate);
458  	#endif
459  	
460  	  // nth_element
461  	  // partial_sort
462  	
463  	  template<typename _IIter, typename _RAIter>
464  	    _RAIter
465  	    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
466  	
467  	  template<typename _IIter, typename _RAIter, typename _Compare>
468  	    _RAIter
469  	    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
470  	
471  	  // partition
472  	
473  	#if __cplusplus >= 201103L
474  	  template<typename _IIter, typename _OIter1,
475  		   typename _OIter2, typename _Predicate>
476  	    pair<_OIter1, _OIter2>
477  	    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
478  	
479  	  template<typename _FIter, typename _Predicate>
480  	    _FIter
481  	    partition_point(_FIter, _FIter, _Predicate);
482  	#endif
483  	
484  	  template<typename _RAIter>
485  	    void
486  	    pop_heap(_RAIter, _RAIter);
487  	
488  	  template<typename _RAIter, typename _Compare>
489  	    void
490  	    pop_heap(_RAIter, _RAIter, _Compare);
491  	
492  	  template<typename _BIter>
493  	    bool
494  	    prev_permutation(_BIter, _BIter);
495  	
496  	  template<typename _BIter, typename _Compare>
497  	    bool
498  	    prev_permutation(_BIter, _BIter, _Compare);
499  	
500  	  template<typename _RAIter>
501  	    void
502  	    push_heap(_RAIter, _RAIter);
503  	
504  	  template<typename _RAIter, typename _Compare>
505  	    void
506  	    push_heap(_RAIter, _RAIter, _Compare);
507  	
508  	  // random_shuffle
509  	
510  	  template<typename _FIter, typename _Tp>
511  	    _FIter
512  	    remove(_FIter, _FIter, const _Tp&);
513  	
514  	  template<typename _FIter, typename _Predicate>
515  	    _FIter
516  	    remove_if(_FIter, _FIter, _Predicate);
517  	
518  	  template<typename _IIter, typename _OIter, typename _Tp>
519  	    _OIter
520  	    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
521  	
522  	  template<typename _IIter, typename _OIter, typename _Predicate>
523  	    _OIter
524  	    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
525  	
526  	  // replace
527  	
528  	  template<typename _IIter, typename _OIter, typename _Tp>
529  	    _OIter
530  	    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
531  	
532  	  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
533  	    _OIter
534  	    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
535  	
536  	  // replace_if
537  	
538  	  template<typename _BIter>
539  	    void
540  	    reverse(_BIter, _BIter);
541  	
542  	  template<typename _BIter, typename _OIter>
543  	    _OIter
544  	    reverse_copy(_BIter, _BIter, _OIter);
545  	
546  	  inline namespace _V2
547  	  {
548  	    template<typename _FIter>
549  	      _FIter
550  	      rotate(_FIter, _FIter, _FIter);
551  	  }
552  	
553  	  template<typename _FIter, typename _OIter>
554  	    _OIter
555  	    rotate_copy(_FIter, _FIter, _FIter, _OIter);
556  	
557  	  // search
558  	  // search_n
559  	  // set_difference
560  	  // set_intersection
561  	  // set_symmetric_difference
562  	  // set_union
563  	
564  	#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
565  	  template<typename _RAIter, typename _UGenerator>
566  	    void
567  	    shuffle(_RAIter, _RAIter, _UGenerator&&);
568  	#endif
569  	
570  	  template<typename _RAIter>
571  	    void
572  	    sort_heap(_RAIter, _RAIter);
573  	
574  	  template<typename _RAIter, typename _Compare>
575  	    void
576  	    sort_heap(_RAIter, _RAIter, _Compare);
577  	
578  	  template<typename _BIter, typename _Predicate>
579  	    _BIter
580  	    stable_partition(_BIter, _BIter, _Predicate);
581  	
582  	#if __cplusplus < 201103L
583  	  // For C++11 swap() is declared in <type_traits>.
584  	
585  	  template<typename _Tp, size_t _Nm>
586  	    inline void
587  	    swap(_Tp& __a, _Tp& __b);
588  	
589  	  template<typename _Tp, size_t _Nm>
590  	    inline void
591  	    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]);
592  	#endif
593  	
594  	  template<typename _FIter1, typename _FIter2>
595  	    _FIter2
596  	    swap_ranges(_FIter1, _FIter1, _FIter2);
597  	
598  	  // transform
599  	
600  	  template<typename _FIter>
601  	    _FIter
602  	    unique(_FIter, _FIter);
603  	
604  	  template<typename _FIter, typename _BinaryPredicate>
605  	    _FIter
606  	    unique(_FIter, _FIter, _BinaryPredicate);
607  	
608  	  // unique_copy
609  	
610  	  template<typename _FIter, typename _Tp>
611  	    _FIter
612  	    upper_bound(_FIter, _FIter, const _Tp&);
613  	
614  	  template<typename _FIter, typename _Tp, typename _Compare>
615  	    _FIter
616  	    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
617  	
618  	_GLIBCXX_END_NAMESPACE_VERSION
619  	
620  	_GLIBCXX_BEGIN_NAMESPACE_ALGO
621  	
622  	  template<typename _FIter>
623  	    _FIter
624  	    adjacent_find(_FIter, _FIter);
625  	
626  	  template<typename _FIter, typename _BinaryPredicate>
627  	    _FIter
628  	    adjacent_find(_FIter, _FIter, _BinaryPredicate);
629  	
630  	  template<typename _IIter, typename _Tp>
631  	    typename iterator_traits<_IIter>::difference_type
632  	    count(_IIter, _IIter, const _Tp&);
633  	
634  	  template<typename _IIter, typename _Predicate>
635  	    typename iterator_traits<_IIter>::difference_type
636  	    count_if(_IIter, _IIter, _Predicate);
637  	
638  	  template<typename _IIter1, typename _IIter2>
639  	    bool
640  	    equal(_IIter1, _IIter1, _IIter2);
641  	
642  	  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
643  	    bool
644  	    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
645  	
646  	  template<typename _IIter, typename _Tp>
647  	    _IIter
648  	    find(_IIter, _IIter, const _Tp&);
649  	
650  	  template<typename _FIter1, typename _FIter2>
651  	    _FIter1
652  	    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
653  	
654  	  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
655  	    _FIter1
656  	    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
657  	
658  	  template<typename _IIter, typename _Predicate>
659  	    _IIter
660  	    find_if(_IIter, _IIter, _Predicate);
661  	
662  	  template<typename _IIter, typename _Funct>
663  	    _Funct
664  	    for_each(_IIter, _IIter, _Funct);
665  	
666  	  template<typename _FIter, typename _Generator>
667  	    void
668  	    generate(_FIter, _FIter, _Generator);
669  	
670  	  template<typename _OIter, typename _Size, typename _Generator>
671  	    _OIter
672  	    generate_n(_OIter, _Size, _Generator);
673  	
674  	  template<typename _IIter1, typename _IIter2>
675  	    bool
676  	    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
677  	
678  	  template<typename _IIter1, typename _IIter2, typename _Compare>
679  	    bool
680  	    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
681  	
682  	  template<typename _FIter>
683  	    _GLIBCXX14_CONSTEXPR
684  	    _FIter
685  	    max_element(_FIter, _FIter);
686  	
687  	  template<typename _FIter, typename _Compare>
688  	    _GLIBCXX14_CONSTEXPR
689  	    _FIter
690  	    max_element(_FIter, _FIter, _Compare);
691  	
692  	  template<typename _IIter1, typename _IIter2, typename _OIter>
693  	    _OIter
694  	    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
695  	
696  	  template<typename _IIter1, typename _IIter2, typename _OIter,
697  		   typename _Compare>
698  	    _OIter
699  	    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
700  	
701  	  template<typename _FIter>
702  	    _GLIBCXX14_CONSTEXPR
703  	    _FIter
704  	    min_element(_FIter, _FIter);
705  	
706  	  template<typename _FIter, typename _Compare>
707  	    _GLIBCXX14_CONSTEXPR
708  	    _FIter
709  	    min_element(_FIter, _FIter, _Compare);
710  	
711  	  template<typename _IIter1, typename _IIter2>
712  	    pair<_IIter1, _IIter2>
713  	    mismatch(_IIter1, _IIter1, _IIter2);
714  	
715  	  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
716  	    pair<_IIter1, _IIter2>
717  	    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
718  	
719  	  template<typename _RAIter>
720  	    void
721  	    nth_element(_RAIter, _RAIter, _RAIter);
722  	
723  	  template<typename _RAIter, typename _Compare>
724  	    void
725  	    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
726  	
727  	  template<typename _RAIter>
728  	    void
729  	    partial_sort(_RAIter, _RAIter, _RAIter);
730  	
731  	  template<typename _RAIter, typename _Compare>
732  	    void
733  	    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
734  	
735  	  template<typename _BIter, typename _Predicate>
736  	    _BIter
737  	    partition(_BIter, _BIter, _Predicate);
738  	
739  	  template<typename _RAIter>
740  	    void
741  	    random_shuffle(_RAIter, _RAIter);
742  	
743  	  template<typename _RAIter, typename _Generator>
744  	    void
745  	    random_shuffle(_RAIter, _RAIter,
746  	#if __cplusplus >= 201103L
747  			   _Generator&&);
748  	#else
749  			   _Generator&);
750  	#endif
751  	
752  	  template<typename _FIter, typename _Tp>
753  	    void
754  	    replace(_FIter, _FIter, const _Tp&, const _Tp&);
755  	
756  	  template<typename _FIter, typename _Predicate, typename _Tp>
757  	    void
758  	    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
759  	
760  	  template<typename _FIter1, typename _FIter2>
761  	    _FIter1
762  	    search(_FIter1, _FIter1, _FIter2, _FIter2);
763  	
764  	  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
765  	    _FIter1
766  	    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
767  	
768  	  template<typename _FIter, typename _Size, typename _Tp>
769  	    _FIter
770  	    search_n(_FIter, _FIter, _Size, const _Tp&);
771  	
772  	  template<typename _FIter, typename _Size, typename _Tp,
773  		   typename _BinaryPredicate>
774  	    _FIter
775  	    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
776  	
777  	  template<typename _IIter1, typename _IIter2, typename _OIter>
778  	    _OIter
779  	    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
780  	
781  	  template<typename _IIter1, typename _IIter2, typename _OIter,
782  		   typename _Compare>
783  	    _OIter
784  	    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
785  	
786  	  template<typename _IIter1, typename _IIter2, typename _OIter>
787  	    _OIter
788  	    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
789  	
790  	  template<typename _IIter1, typename _IIter2, typename _OIter,
791  		   typename _Compare>
792  	    _OIter
793  	    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
794  	
795  	  template<typename _IIter1, typename _IIter2, typename _OIter>
796  	    _OIter
797  	    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
798  	
799  	  template<typename _IIter1, typename _IIter2, typename _OIter,
800  		   typename _Compare>
801  	    _OIter
802  	    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
803  				     _OIter, _Compare);
804  	
805  	  template<typename _IIter1, typename _IIter2, typename _OIter>
806  	    _OIter
807  	    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
808  	
809  	  template<typename _IIter1, typename _IIter2, typename _OIter,
810  		   typename _Compare>
811  	    _OIter
812  	    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
813  	
814  	  template<typename _RAIter>
815  	    void
816  	    sort(_RAIter, _RAIter);
817  	
818  	  template<typename _RAIter, typename _Compare>
819  	    void
820  	    sort(_RAIter, _RAIter, _Compare);
821  	
822  	  template<typename _RAIter>
823  	    void
824  	    stable_sort(_RAIter, _RAIter);
825  	
826  	  template<typename _RAIter, typename _Compare>
827  	    void
828  	    stable_sort(_RAIter, _RAIter, _Compare);
829  	
830  	  template<typename _IIter, typename _OIter, typename _UnaryOperation>
831  	    _OIter
832  	    transform(_IIter, _IIter, _OIter, _UnaryOperation);
833  	
834  	  template<typename _IIter1, typename _IIter2, typename _OIter,
835  		   typename _BinaryOperation>
836  	    _OIter
837  	    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
838  	
839  	  template<typename _IIter, typename _OIter>
840  	    _OIter
841  	    unique_copy(_IIter, _IIter, _OIter);
842  	
843  	  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
844  	    _OIter
845  	    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
846  	
847  	_GLIBCXX_END_NAMESPACE_ALGO
848  	} // namespace std
849  	
850  	#ifdef _GLIBCXX_PARALLEL
851  	# include <parallel/algorithmfwd.h>
852  	#endif
853  	
854  	#endif
855  	
856