<h2>File Contents: //usr/include/c++/8/functional</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//usr/include/c++/8/functional'><textarea name='file_content' rows='10' cols='50'>// &lt;functional&gt; -*- C++ -*-

// Copyright (C) 2001-2018 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
// &lt;http://www.gnu.org/licenses/&gt;.

/*
 * Copyright (c) 1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided &quot;as is&quot; without express or implied warranty.
 *
 */

/** @file include/functional
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_FUNCTIONAL
#define _GLIBCXX_FUNCTIONAL 1

#pragma GCC system_header

#include &lt;bits/c++config.h&gt;
#include &lt;bits/stl_function.h&gt;

#if __cplusplus &gt;= 201103L

#include &lt;new&gt;
#include &lt;tuple&gt;
#include &lt;type_traits&gt;
#include &lt;bits/functional_hash.h&gt;
#include &lt;bits/invoke.h&gt;
#include &lt;bits/refwrap.h&gt;	// std::reference_wrapper and _Mem_fn_traits
#include &lt;bits/std_function.h&gt;	// std::function
#if __cplusplus &gt; 201402L
# include &lt;unordered_map&gt;
# include &lt;vector&gt;
# include &lt;array&gt;
# include &lt;utility&gt;
# include &lt;bits/stl_algo.h&gt;
#endif

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

#if __cplusplus &gt; 201402L
# define __cpp_lib_invoke 201411

  /// Invoke a callable object.
  template&lt;typename _Callable, typename... _Args&gt;
    inline invoke_result_t&lt;_Callable, _Args...&gt;
    invoke(_Callable&amp;&amp; __fn, _Args&amp;&amp;... __args)
    noexcept(is_nothrow_invocable_v&lt;_Callable, _Args...&gt;)
    {
      return std::__invoke(std::forward&lt;_Callable&gt;(__fn),
			   std::forward&lt;_Args&gt;(__args)...);
    }
#endif

  template&lt;typename _MemFunPtr,
	   bool __is_mem_fn = is_member_function_pointer&lt;_MemFunPtr&gt;::value&gt;
    class _Mem_fn_base
    : public _Mem_fn_traits&lt;_MemFunPtr&gt;::__maybe_type
    {
      using _Traits = _Mem_fn_traits&lt;_MemFunPtr&gt;;

      using _Arity = typename _Traits::__arity;
      using _Varargs = typename _Traits::__vararg;

      template&lt;typename _Func, typename... _BoundArgs&gt;
	friend struct _Bind_check_arity;

      _MemFunPtr _M_pmf;

    public:

      using result_type = typename _Traits::__result_type;

      explicit constexpr
      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }

      template&lt;typename... _Args&gt;
	auto
	operator()(_Args&amp;&amp;... __args) const
	noexcept(noexcept(
	      std::__invoke(_M_pmf, std::forward&lt;_Args&gt;(__args)...)))
	-&gt; decltype(std::__invoke(_M_pmf, std::forward&lt;_Args&gt;(__args)...))
	{ return std::__invoke(_M_pmf, std::forward&lt;_Args&gt;(__args)...); }
    };

  // Partial specialization for member object pointers.
  template&lt;typename _MemObjPtr&gt;
    class _Mem_fn_base&lt;_MemObjPtr, false&gt;
    {
      using _Arity = integral_constant&lt;size_t, 0&gt;;
      using _Varargs = false_type;

      template&lt;typename _Func, typename... _BoundArgs&gt;
	friend struct _Bind_check_arity;

      _MemObjPtr _M_pm;

    public:
      explicit constexpr
      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }

      template&lt;typename _Tp&gt;
	auto
	operator()(_Tp&amp;&amp; __obj) const
	noexcept(noexcept(std::__invoke(_M_pm, std::forward&lt;_Tp&gt;(__obj))))
	-&gt; decltype(std::__invoke(_M_pm, std::forward&lt;_Tp&gt;(__obj)))
	{ return std::__invoke(_M_pm, std::forward&lt;_Tp&gt;(__obj)); }
    };

  template&lt;typename _MemberPointer&gt;
    struct _Mem_fn; // undefined

  template&lt;typename _Res, typename _Class&gt;
    struct _Mem_fn&lt;_Res _Class::*&gt;
    : _Mem_fn_base&lt;_Res _Class::*&gt;
    {
      using _Mem_fn_base&lt;_Res _Class::*&gt;::_Mem_fn_base;
    };

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 2048.  Unnecessary mem_fn overloads
  /**
   *  @brief Returns a function object that forwards to the member
   *  pointer @a pm.
   *  @ingroup functors
   */
  template&lt;typename _Tp, typename _Class&gt;
    inline _Mem_fn&lt;_Tp _Class::*&gt;
    mem_fn(_Tp _Class::* __pm) noexcept
    {
      return _Mem_fn&lt;_Tp _Class::*&gt;(__pm);
    }

  /**
   *  @brief Determines if the given type _Tp is a function object that
   *  should be treated as a subexpression when evaluating calls to
   *  function objects returned by bind().
   *
   *  C++11 [func.bind.isbind].
   *  @ingroup binders
   */
  template&lt;typename _Tp&gt;
    struct is_bind_expression
    : public false_type { };

  /**
   *  @brief Determines if the given type _Tp is a placeholder in a
   *  bind() expression and, if so, which placeholder it is.
   *
   *  C++11 [func.bind.isplace].
   *  @ingroup binders
   */
  template&lt;typename _Tp&gt;
    struct is_placeholder
    : public integral_constant&lt;int, 0&gt;
    { };

#if __cplusplus &gt; 201402L
  template &lt;typename _Tp&gt; inline constexpr bool is_bind_expression_v
    = is_bind_expression&lt;_Tp&gt;::value;
  template &lt;typename _Tp&gt; inline constexpr int is_placeholder_v
    = is_placeholder&lt;_Tp&gt;::value;
#endif // C++17

  /** @brief The type of placeholder objects defined by libstdc++.
   *  @ingroup binders
   */
  template&lt;int _Num&gt; struct _Placeholder { };

  /** @namespace std::placeholders
   *  @brief ISO C++11 entities sub-namespace for functional.
   *  @ingroup binders
   */
  namespace placeholders
  {
  /* Define a large number of placeholders. There is no way to
   * simplify this with variadic templates, because we're introducing
   * unique names for each.
   */
    extern const _Placeholder&lt;1&gt; _1;
    extern const _Placeholder&lt;2&gt; _2;
    extern const _Placeholder&lt;3&gt; _3;
    extern const _Placeholder&lt;4&gt; _4;
    extern const _Placeholder&lt;5&gt; _5;
    extern const _Placeholder&lt;6&gt; _6;
    extern const _Placeholder&lt;7&gt; _7;
    extern const _Placeholder&lt;8&gt; _8;
    extern const _Placeholder&lt;9&gt; _9;
    extern const _Placeholder&lt;10&gt; _10;
    extern const _Placeholder&lt;11&gt; _11;
    extern const _Placeholder&lt;12&gt; _12;
    extern const _Placeholder&lt;13&gt; _13;
    extern const _Placeholder&lt;14&gt; _14;
    extern const _Placeholder&lt;15&gt; _15;
    extern const _Placeholder&lt;16&gt; _16;
    extern const _Placeholder&lt;17&gt; _17;
    extern const _Placeholder&lt;18&gt; _18;
    extern const _Placeholder&lt;19&gt; _19;
    extern const _Placeholder&lt;20&gt; _20;
    extern const _Placeholder&lt;21&gt; _21;
    extern const _Placeholder&lt;22&gt; _22;
    extern const _Placeholder&lt;23&gt; _23;
    extern const _Placeholder&lt;24&gt; _24;
    extern const _Placeholder&lt;25&gt; _25;
    extern const _Placeholder&lt;26&gt; _26;
    extern const _Placeholder&lt;27&gt; _27;
    extern const _Placeholder&lt;28&gt; _28;
    extern const _Placeholder&lt;29&gt; _29;
  }

  /**
   *  Partial specialization of is_placeholder that provides the placeholder
   *  number for the placeholder objects defined by libstdc++.
   *  @ingroup binders
   */
  template&lt;int _Num&gt;
    struct is_placeholder&lt;_Placeholder&lt;_Num&gt; &gt;
    : public integral_constant&lt;int, _Num&gt;
    { };

  template&lt;int _Num&gt;
    struct is_placeholder&lt;const _Placeholder&lt;_Num&gt; &gt;
    : public integral_constant&lt;int, _Num&gt;
    { };


  // Like tuple_element_t but SFINAE-friendly.
  template&lt;std::size_t __i, typename _Tuple&gt;
    using _Safe_tuple_element_t
      = typename enable_if&lt;(__i &lt; tuple_size&lt;_Tuple&gt;::value),
			   tuple_element&lt;__i, _Tuple&gt;&gt;::type::type;

  /**
   *  Maps an argument to bind() into an actual argument to the bound
   *  function object [func.bind.bind]/10. Only the first parameter should
   *  be specified: the rest are used to determine among the various
   *  implementations. Note that, although this class is a function
   *  object, it isn't entirely normal because it takes only two
   *  parameters regardless of the number of parameters passed to the
   *  bind expression. The first parameter is the bound argument and
   *  the second parameter is a tuple containing references to the
   *  rest of the arguments.
   */
  template&lt;typename _Arg,
	   bool _IsBindExp = is_bind_expression&lt;_Arg&gt;::value,
	   bool _IsPlaceholder = (is_placeholder&lt;_Arg&gt;::value &gt; 0)&gt;
    class _Mu;

  /**
   *  If the argument is reference_wrapper&lt;_Tp&gt;, returns the
   *  underlying reference.
   *  C++11 [func.bind.bind] p10 bullet 1.
   */
  template&lt;typename _Tp&gt;
    class _Mu&lt;reference_wrapper&lt;_Tp&gt;, false, false&gt;
    {
    public:
      /* Note: This won't actually work for const volatile
       * reference_wrappers, because reference_wrapper::get() is const
       * but not volatile-qualified. This might be a defect in the TR.
       */
      template&lt;typename _CVRef, typename _Tuple&gt;
	_Tp&amp;
	operator()(_CVRef&amp; __arg, _Tuple&amp;) const volatile
	{ return __arg.get(); }
    };

  /**
   *  If the argument is a bind expression, we invoke the underlying
   *  function object with the same cv-qualifiers as we are given and
   *  pass along all of our arguments (unwrapped).
   *  C++11 [func.bind.bind] p10 bullet 2.
   */
  template&lt;typename _Arg&gt;
    class _Mu&lt;_Arg, true, false&gt;
    {
    public:
      template&lt;typename _CVArg, typename... _Args&gt;
	auto
	operator()(_CVArg&amp; __arg,
		   tuple&lt;_Args...&gt;&amp; __tuple) const volatile
	-&gt; decltype(__arg(declval&lt;_Args&gt;()...))
	{
	  // Construct an index tuple and forward to __call
	  typedef typename _Build_index_tuple&lt;sizeof...(_Args)&gt;::__type
	    _Indexes;
	  return this-&gt;__call(__arg, __tuple, _Indexes());
	}

    private:
      // Invokes the underlying function object __arg by unpacking all
      // of the arguments in the tuple.
      template&lt;typename _CVArg, typename... _Args, std::size_t... _Indexes&gt;
	auto
	__call(_CVArg&amp; __arg, tuple&lt;_Args...&gt;&amp; __tuple,
	       const _Index_tuple&lt;_Indexes...&gt;&amp;) const volatile
	-&gt; decltype(__arg(declval&lt;_Args&gt;()...))
	{
	  return __arg(std::get&lt;_Indexes&gt;(std::move(__tuple))...);
	}
    };

  /**
   *  If the argument is a placeholder for the Nth argument, returns
   *  a reference to the Nth argument to the bind function object.
   *  C++11 [func.bind.bind] p10 bullet 3.
   */
  template&lt;typename _Arg&gt;
    class _Mu&lt;_Arg, false, true&gt;
    {
    public:
      template&lt;typename _Tuple&gt;
	_Safe_tuple_element_t&lt;(is_placeholder&lt;_Arg&gt;::value - 1), _Tuple&gt;&amp;&amp;
	operator()(const volatile _Arg&amp;, _Tuple&amp; __tuple) const volatile
	{
	  return
	    ::std::get&lt;(is_placeholder&lt;_Arg&gt;::value - 1)&gt;(std::move(__tuple));
	}
    };

  /**
   *  If the argument is just a value, returns a reference to that
   *  value. The cv-qualifiers on the reference are determined by the caller.
   *  C++11 [func.bind.bind] p10 bullet 4.
   */
  template&lt;typename _Arg&gt;
    class _Mu&lt;_Arg, false, false&gt;
    {
    public:
      template&lt;typename _CVArg, typename _Tuple&gt;
	_CVArg&amp;&amp;
	operator()(_CVArg&amp;&amp; __arg, _Tuple&amp;) const volatile
	{ return std::forward&lt;_CVArg&gt;(__arg); }
    };

  // std::get&lt;I&gt; for volatile-qualified tuples
  template&lt;std::size_t _Ind, typename... _Tp&gt;
    inline auto
    __volget(volatile tuple&lt;_Tp...&gt;&amp; __tuple)
    -&gt; __tuple_element_t&lt;_Ind, tuple&lt;_Tp...&gt;&gt; volatile&amp;
    { return std::get&lt;_Ind&gt;(const_cast&lt;tuple&lt;_Tp...&gt;&amp;&gt;(__tuple)); }

  // std::get&lt;I&gt; for const-volatile-qualified tuples
  template&lt;std::size_t _Ind, typename... _Tp&gt;
    inline auto
    __volget(const volatile tuple&lt;_Tp...&gt;&amp; __tuple)
    -&gt; __tuple_element_t&lt;_Ind, tuple&lt;_Tp...&gt;&gt; const volatile&amp;
    { return std::get&lt;_Ind&gt;(const_cast&lt;const tuple&lt;_Tp...&gt;&amp;&gt;(__tuple)); }

  /// Type of the function object returned from bind().
  template&lt;typename _Signature&gt;
    struct _Bind;

   template&lt;typename _Functor, typename... _Bound_args&gt;
    class _Bind&lt;_Functor(_Bound_args...)&gt;
    : public _Weak_result_type&lt;_Functor&gt;
    {
      typedef typename _Build_index_tuple&lt;sizeof...(_Bound_args)&gt;::__type
	_Bound_indexes;

      _Functor _M_f;
      tuple&lt;_Bound_args...&gt; _M_bound_args;

      // Call unqualified
      template&lt;typename _Result, typename... _Args, std::size_t... _Indexes&gt;
	_Result
	__call(tuple&lt;_Args...&gt;&amp;&amp; __args, _Index_tuple&lt;_Indexes...&gt;)
	{
	  return std::__invoke(_M_f,
	      _Mu&lt;_Bound_args&gt;()(std::get&lt;_Indexes&gt;(_M_bound_args), __args)...
	      );
	}

      // Call as const
      template&lt;typename _Result, typename... _Args, std::size_t... _Indexes&gt;
	_Result
	__call_c(tuple&lt;_Args...&gt;&amp;&amp; __args, _Index_tuple&lt;_Indexes...&gt;) const
	{
	  return std::__invoke(_M_f,
	      _Mu&lt;_Bound_args&gt;()(std::get&lt;_Indexes&gt;(_M_bound_args), __args)...
	      );
	}

      // Call as volatile
      template&lt;typename _Result, typename... _Args, std::size_t... _Indexes&gt;
	_Result
	__call_v(tuple&lt;_Args...&gt;&amp;&amp; __args,
		 _Index_tuple&lt;_Indexes...&gt;) volatile
	{
	  return std::__invoke(_M_f,
	      _Mu&lt;_Bound_args&gt;()(__volget&lt;_Indexes&gt;(_M_bound_args), __args)...
	      );
	}

      // Call as const volatile
      template&lt;typename _Result, typename... _Args, std::size_t... _Indexes&gt;
	_Result
	__call_c_v(tuple&lt;_Args...&gt;&amp;&amp; __args,
		   _Index_tuple&lt;_Indexes...&gt;) const volatile
	{
	  return std::__invoke(_M_f,
	      _Mu&lt;_Bound_args&gt;()(__volget&lt;_Indexes&gt;(_M_bound_args), __args)...
	      );
	}

      template&lt;typename _BoundArg, typename _CallArgs&gt;
	using _Mu_type = decltype(
	    _Mu&lt;typename remove_cv&lt;_BoundArg&gt;::type&gt;()(
	      std::declval&lt;_BoundArg&amp;&gt;(), std::declval&lt;_CallArgs&amp;&gt;()) );

      template&lt;typename _Fn, typename _CallArgs, typename... _BArgs&gt;
	using _Res_type_impl
	  = typename result_of&lt; _Fn&amp;(_Mu_type&lt;_BArgs, _CallArgs&gt;&amp;&amp;...) &gt;::type;

      template&lt;typename _CallArgs&gt;
	using _Res_type = _Res_type_impl&lt;_Functor, _CallArgs, _Bound_args...&gt;;

      template&lt;typename _CallArgs&gt;
	using __dependent = typename
	  enable_if&lt;bool(tuple_size&lt;_CallArgs&gt;::value+1), _Functor&gt;::type;

      template&lt;typename _CallArgs, template&lt;class&gt; class __cv_quals&gt;
	using _Res_type_cv = _Res_type_impl&lt;
	  typename __cv_quals&lt;__dependent&lt;_CallArgs&gt;&gt;::type,
	  _CallArgs,
	  typename __cv_quals&lt;_Bound_args&gt;::type...&gt;;

     public:
      template&lt;typename... _Args&gt;
	explicit _Bind(const _Functor&amp; __f, _Args&amp;&amp;... __args)
	: _M_f(__f), _M_bound_args(std::forward&lt;_Args&gt;(__args)...)
	{ }

      template&lt;typename... _Args&gt;
	explicit _Bind(_Functor&amp;&amp; __f, _Args&amp;&amp;... __args)
	: _M_f(std::move(__f)), _M_bound_args(std::forward&lt;_Args&gt;(__args)...)
	{ }

      _Bind(const _Bind&amp;) = default;

      _Bind(_Bind&amp;&amp; __b)
      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
      { }

      // Call unqualified
      template&lt;typename... _Args,
	       typename _Result = _Res_type&lt;tuple&lt;_Args...&gt;&gt;&gt;
	_Result
	operator()(_Args&amp;&amp;... __args)
	{
	  return this-&gt;__call&lt;_Result&gt;(
	      std::forward_as_tuple(std::forward&lt;_Args&gt;(__args)...),
	      _Bound_indexes());
	}

      // Call as const
      template&lt;typename... _Args,
	       typename _Result = _Res_type_cv&lt;tuple&lt;_Args...&gt;, add_const&gt;&gt;
	_Result
	operator()(_Args&amp;&amp;... __args) const
	{
	  return this-&gt;__call_c&lt;_Result&gt;(
	      std::forward_as_tuple(std::forward&lt;_Args&gt;(__args)...),
	      _Bound_indexes());
	}

#if __cplusplus &gt; 201402L
# define _GLIBCXX_DEPR_BIND \
      [[deprecated(&quot;std::bind does not support volatile in C++17&quot;)]]
#else
# define _GLIBCXX_DEPR_BIND
#endif
      // Call as volatile
      template&lt;typename... _Args,
	       typename _Result = _Res_type_cv&lt;tuple&lt;_Args...&gt;, add_volatile&gt;&gt;
	_GLIBCXX_DEPR_BIND
	_Result
	operator()(_Args&amp;&amp;... __args) volatile
	{
	  return this-&gt;__call_v&lt;_Result&gt;(
	      std::forward_as_tuple(std::forward&lt;_Args&gt;(__args)...),
	      _Bound_indexes());
	}

      // Call as const volatile
      template&lt;typename... _Args,
	       typename _Result = _Res_type_cv&lt;tuple&lt;_Args...&gt;, add_cv&gt;&gt;
	_GLIBCXX_DEPR_BIND
	_Result
	operator()(_Args&amp;&amp;... __args) const volatile
	{
	  return this-&gt;__call_c_v&lt;_Result&gt;(
	      std::forward_as_tuple(std::forward&lt;_Args&gt;(__args)...),
	      _Bound_indexes());
	}
    };

  /// Type of the function object returned from bind&lt;R&gt;().
  template&lt;typename _Result, typename _Signature&gt;
    struct _Bind_result;

  template&lt;typename _Result, typename _Functor, typename... _Bound_args&gt;
    class _Bind_result&lt;_Result, _Functor(_Bound_args...)&gt;
    {
      typedef typename _Build_index_tuple&lt;sizeof...(_Bound_args)&gt;::__type
	_Bound_indexes;

      _Functor _M_f;
      tuple&lt;_Bound_args...&gt; _M_bound_args;

      // sfinae types
      template&lt;typename _Res&gt;
	using __enable_if_void
	  = typename enable_if&lt;is_void&lt;_Res&gt;{}&gt;::type;

      template&lt;typename _Res&gt;
	using __disable_if_void
	  = typename enable_if&lt;!is_void&lt;_Res&gt;{}, _Result&gt;::type;

      // Call unqualified
      template&lt;typename _Res, typename... _Args, std::size_t... _Indexes&gt;
	__disable_if_void&lt;_Res&gt;
	__call(tuple&lt;_Args...&gt;&amp;&amp; __args, _Index_tuple&lt;_Indexes...&gt;)
	{
	  return std::__invoke(_M_f, _Mu&lt;_Bound_args&gt;()
		      (std::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
	}

      // Call unqualified, return void
      template&lt;typename _Res, typename... _Args, std::size_t... _Indexes&gt;
	__enable_if_void&lt;_Res&gt;
	__call(tuple&lt;_Args...&gt;&amp;&amp; __args, _Index_tuple&lt;_Indexes...&gt;)
	{
	  std::__invoke(_M_f, _Mu&lt;_Bound_args&gt;()
	       (std::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
	}

      // Call as const
      template&lt;typename _Res, typename... _Args, std::size_t... _Indexes&gt;
	__disable_if_void&lt;_Res&gt;
	__call(tuple&lt;_Args...&gt;&amp;&amp; __args, _Index_tuple&lt;_Indexes...&gt;) const
	{
	  return std::__invoke(_M_f, _Mu&lt;_Bound_args&gt;()
		      (std::get&lt;_Indexes&gt;(_M_bound_args), __args)...);
	}

      // Call as const, return void
      template&lt;typename _Res, typename... _Args, std::size_t... _Indexes&gt;
	__enable_if_void&lt;_Res&gt;
	__call(tuple&lt;_Args...&gt;&amp;&amp; __args, _Index_tuple&lt;_Indexes...&gt;) const
	{
	  std::__invoke(_M_f, _Mu&lt;_Bound_args&gt;()
	       (std::get&lt;_Indexes&gt;(_M_bound_args),  __args)...);
	}

      // Call as volatile
      template&lt;typename _Res, typename... _Args, std::size_t... _Indexes&gt;
	__disable_if_void&lt;_Res&gt;
	__call(tuple&lt;_Args...&gt;&amp;&amp; __args, _Index_tuple&lt;_Indexes...&gt;) volatile
	{
	  return std::__invoke(_M_f, _Mu&lt;_Bound_args&gt;()
		      (__volget&lt;_Indexes&gt;(_M_bound_args), __args)...);
	}

      // Call as volatile, return void
      template&lt;typename _Res, typename... _Args, std::size_t... _Indexes&gt;
	__enable_if_void&lt;_Res&gt;
	__call(tuple&lt;_Args...&gt;&amp;&amp; __args, _Index_tuple&lt;_Indexes...&gt;) volatile
	{
	  std::__invoke(_M_f, _Mu&lt;_Bound_args&gt;()
	       (__volget&lt;_Indexes&gt;(_M_bound_args), __args)...);
	}

      // Call as const volatile
      template&lt;typename _Res, typename... _Args, std::size_t... _Indexes&gt;
	__disable_if_void&lt;_Res&gt;
	__call(tuple&lt;_Args...&gt;&amp;&amp; __args,
	       _Index_tuple&lt;_Indexes...&gt;) const volatile
	{
	  return std::__invoke(_M_f, _Mu&lt;_Bound_args&gt;()
		      (__volget&lt;_Indexes&gt;(_M_bound_args), __args)...);
	}

      // Call as const volatile, return void
      template&lt;typename _Res, typename... _Args, std::size_t... _Indexes&gt;
	__enable_if_void&lt;_Res&gt;
	__call(tuple&lt;_Args...&gt;&amp;&amp; __args,
	       _Index_tuple&lt;_Indexes...&gt;) const volatile
	{
	  std::__invoke(_M_f, _Mu&lt;_Bound_args&gt;()
	       (__volget&lt;_Indexes&gt;(_M_bound_args), __args)...);
	}

    public:
      typedef _Result result_type;

      template&lt;typename... _Args&gt;
	explicit _Bind_result(const _Functor&amp; __f, _Args&amp;&amp;... __args)
	: _M_f(__f), _M_bound_args(std::forward&lt;_Args&gt;(__args)...)
	{ }

      template&lt;typename... _Args&gt;
	explicit _Bind_result(_Functor&amp;&amp; __f, _Args&amp;&amp;... __args)
	: _M_f(std::move(__f)), _M_bound_args(std::forward&lt;_Args&gt;(__args)...)
	{ }

      _Bind_result(const _Bind_result&amp;) = default;

      _Bind_result(_Bind_result&amp;&amp; __b)
      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
      { }

      // Call unqualified
      template&lt;typename... _Args&gt;
	result_type
	operator()(_Args&amp;&amp;... __args)
	{
	  return this-&gt;__call&lt;_Result&gt;(
	      std::forward_as_tuple(std::forward&lt;_Args&gt;(__args)...),
	      _Bound_indexes());
	}

      // Call as const
      template&lt;typename... _Args&gt;
	result_type
	operator()(_Args&amp;&amp;... __args) const
	{
	  return this-&gt;__call&lt;_Result&gt;(
	      std::forward_as_tuple(std::forward&lt;_Args&gt;(__args)...),
	      _Bound_indexes());
	}

      // Call as volatile
      template&lt;typename... _Args&gt;
	_GLIBCXX_DEPR_BIND
	result_type
	operator()(_Args&amp;&amp;... __args) volatile
	{
	  return this-&gt;__call&lt;_Result&gt;(
	      std::forward_as_tuple(std::forward&lt;_Args&gt;(__args)...),
	      _Bound_indexes());
	}

      // Call as const volatile
      template&lt;typename... _Args&gt;
	_GLIBCXX_DEPR_BIND
	result_type
	operator()(_Args&amp;&amp;... __args) const volatile
	{
	  return this-&gt;__call&lt;_Result&gt;(
	      std::forward_as_tuple(std::forward&lt;_Args&gt;(__args)...),
	      _Bound_indexes());
	}
    };
#undef _GLIBCXX_DEPR_BIND

  /**
   *  @brief Class template _Bind is always a bind expression.
   *  @ingroup binders
   */
  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;_Bind&lt;_Signature&gt; &gt;
    : public true_type { };

  /**
   *  @brief Class template _Bind is always a bind expression.
   *  @ingroup binders
   */
  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;const _Bind&lt;_Signature&gt; &gt;
    : public true_type { };

  /**
   *  @brief Class template _Bind is always a bind expression.
   *  @ingroup binders
   */
  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;volatile _Bind&lt;_Signature&gt; &gt;
    : public true_type { };

  /**
   *  @brief Class template _Bind is always a bind expression.
   *  @ingroup binders
   */
  template&lt;typename _Signature&gt;
    struct is_bind_expression&lt;const volatile _Bind&lt;_Signature&gt;&gt;
    : public true_type { };

  /**
   *  @brief Class template _Bind_result is always a bind expression.
   *  @ingroup binders
   */
  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;_Bind_result&lt;_Result, _Signature&gt;&gt;
    : public true_type { };

  /**
   *  @brief Class template _Bind_result is always a bind expression.
   *  @ingroup binders
   */
  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;const _Bind_result&lt;_Result, _Signature&gt;&gt;
    : public true_type { };

  /**
   *  @brief Class template _Bind_result is always a bind expression.
   *  @ingroup binders
   */
  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;volatile _Bind_result&lt;_Result, _Signature&gt;&gt;
    : public true_type { };

  /**
   *  @brief Class template _Bind_result is always a bind expression.
   *  @ingroup binders
   */
  template&lt;typename _Result, typename _Signature&gt;
    struct is_bind_expression&lt;const volatile _Bind_result&lt;_Result, _Signature&gt;&gt;
    : public true_type { };

  template&lt;typename _Func, typename... _BoundArgs&gt;
    struct _Bind_check_arity { };

  template&lt;typename _Ret, typename... _Args, typename... _BoundArgs&gt;
    struct _Bind_check_arity&lt;_Ret (*)(_Args...), _BoundArgs...&gt;
    {
      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
                   &quot;Wrong number of arguments for function&quot;);
    };

  template&lt;typename _Ret, typename... _Args, typename... _BoundArgs&gt;
    struct _Bind_check_arity&lt;_Ret (*)(_Args......), _BoundArgs...&gt;
    {
      static_assert(sizeof...(_BoundArgs) &gt;= sizeof...(_Args),
                   &quot;Wrong number of arguments for function&quot;);
    };

  template&lt;typename _Tp, typename _Class, typename... _BoundArgs&gt;
    struct _Bind_check_arity&lt;_Tp _Class::*, _BoundArgs...&gt;
    {
      using _Arity = typename _Mem_fn&lt;_Tp _Class::*&gt;::_Arity;
      using _Varargs = typename _Mem_fn&lt;_Tp _Class::*&gt;::_Varargs;
      static_assert(_Varargs::value
		    ? sizeof...(_BoundArgs) &gt;= _Arity::value + 1
		    : sizeof...(_BoundArgs) == _Arity::value + 1,
		    &quot;Wrong number of arguments for pointer-to-member&quot;);
    };

  // Trait type used to remove std::bind() from overload set via SFINAE
  // when first argument has integer type, so that std::bind() will
  // not be a better match than ::bind() from the BSD Sockets API.
  template&lt;typename _Tp, typename _Tp2 = typename decay&lt;_Tp&gt;::type&gt;
    using __is_socketlike = __or_&lt;is_integral&lt;_Tp2&gt;, is_enum&lt;_Tp2&gt;&gt;;

  template&lt;bool _SocketLike, typename _Func, typename... _BoundArgs&gt;
    struct _Bind_helper
    : _Bind_check_arity&lt;typename decay&lt;_Func&gt;::type, _BoundArgs...&gt;
    {
      typedef typename decay&lt;_Func&gt;::type __func_type;
      typedef _Bind&lt;__func_type(typename decay&lt;_BoundArgs&gt;::type...)&gt; type;
    };

  // Partial specialization for is_socketlike == true, does not define
  // nested type so std::bind() will not participate in overload resolution
  // when the first argument might be a socket file descriptor.
  template&lt;typename _Func, typename... _BoundArgs&gt;
    struct _Bind_helper&lt;true, _Func, _BoundArgs...&gt;
    { };

  /**
   *  @brief Function template for std::bind.
   *  @ingroup binders
   */
  template&lt;typename _Func, typename... _BoundArgs&gt;
    inline typename
    _Bind_helper&lt;__is_socketlike&lt;_Func&gt;::value, _Func, _BoundArgs...&gt;::type
    bind(_Func&amp;&amp; __f, _BoundArgs&amp;&amp;... __args)
    {
      typedef _Bind_helper&lt;false, _Func, _BoundArgs...&gt; __helper_type;
      return typename __helper_type::type(std::forward&lt;_Func&gt;(__f),
					  std::forward&lt;_BoundArgs&gt;(__args)...);
    }

  template&lt;typename _Result, typename _Func, typename... _BoundArgs&gt;
    struct _Bindres_helper
    : _Bind_check_arity&lt;typename decay&lt;_Func&gt;::type, _BoundArgs...&gt;
    {
      typedef typename decay&lt;_Func&gt;::type __functor_type;
      typedef _Bind_result&lt;_Result,
			   __functor_type(typename decay&lt;_BoundArgs&gt;::type...)&gt;
	type;
    };

  /**
   *  @brief Function template for std::bind&lt;R&gt;.
   *  @ingroup binders
   */
  template&lt;typename _Result, typename _Func, typename... _BoundArgs&gt;
    inline
    typename _Bindres_helper&lt;_Result, _Func, _BoundArgs...&gt;::type
    bind(_Func&amp;&amp; __f, _BoundArgs&amp;&amp;... __args)
    {
      typedef _Bindres_helper&lt;_Result, _Func, _BoundArgs...&gt; __helper_type;
      return typename __helper_type::type(std::forward&lt;_Func&gt;(__f),
					  std::forward&lt;_BoundArgs&gt;(__args)...);
    }

#if __cplusplus &gt;= 201402L
  /// Generalized negator.
  template&lt;typename _Fn&gt;
    class _Not_fn
    {
      template&lt;typename _Fn2, typename... _Args&gt;
	using __inv_res_t = typename __invoke_result&lt;_Fn2, _Args...&gt;::type;

      template&lt;typename _Tp&gt;
	static decltype(!std::declval&lt;_Tp&gt;())
	_S_not() noexcept(noexcept(!std::declval&lt;_Tp&gt;()));

    public:
      template&lt;typename _Fn2&gt;
	_Not_fn(_Fn2&amp;&amp; __fn, int)
	: _M_fn(std::forward&lt;_Fn2&gt;(__fn)) { }

      _Not_fn(const _Not_fn&amp; __fn) = default;
      _Not_fn(_Not_fn&amp;&amp; __fn) = default;
      ~_Not_fn() = default;

      // Macro to define operator() with given cv-qualifiers ref-qualifiers,
      // forwarding _M_fn and the function arguments with the same qualifiers,
      // and deducing the return type and exception-specification.
#define _GLIBCXX_NOT_FN_CALL_OP( _QUALS )				\
      template&lt;typename... _Args&gt;					\
	decltype(_S_not&lt;__inv_res_t&lt;_Fn _QUALS, _Args...&gt;&gt;())		\
	operator()(_Args&amp;&amp;... __args) _QUALS				\
	noexcept(__is_nothrow_invocable&lt;_Fn _QUALS, _Args...&gt;::value	\
	    &amp;&amp; noexcept(_S_not&lt;__inv_res_t&lt;_Fn _QUALS, _Args...&gt;&gt;()))	\
	{								\
	  return !std::__invoke(std::forward&lt; _Fn _QUALS &gt;(_M_fn),	\
				std::forward&lt;_Args&gt;(__args)...);	\
	}
      _GLIBCXX_NOT_FN_CALL_OP( &amp; )
      _GLIBCXX_NOT_FN_CALL_OP( const &amp; )
      _GLIBCXX_NOT_FN_CALL_OP( &amp;&amp; )
      _GLIBCXX_NOT_FN_CALL_OP( const &amp;&amp; )
#undef _GLIBCXX_NOT_FN_CALL

    private:
      _Fn _M_fn;
    };

  template&lt;typename _Tp, typename _Pred&gt;
    struct __is_byte_like : false_type { };

  template&lt;typename _Tp&gt;
    struct __is_byte_like&lt;_Tp, equal_to&lt;_Tp&gt;&gt;
    : __bool_constant&lt;sizeof(_Tp) == 1 &amp;&amp; is_integral&lt;_Tp&gt;::value&gt; { };

  template&lt;typename _Tp&gt;
    struct __is_byte_like&lt;_Tp, equal_to&lt;void&gt;&gt;
    : __bool_constant&lt;sizeof(_Tp) == 1 &amp;&amp; is_integral&lt;_Tp&gt;::value&gt; { };

#if __cplusplus &gt;= 201703L
  // Declare std::byte (full definition is in &lt;cstddef&gt;).
  enum class byte : unsigned char;

  template&lt;&gt;
    struct __is_byte_like&lt;byte, equal_to&lt;byte&gt;&gt;
    : true_type { };

  template&lt;&gt;
    struct __is_byte_like&lt;byte, equal_to&lt;void&gt;&gt;
    : true_type { };

#define __cpp_lib_not_fn 201603
  /// [func.not_fn] Function template not_fn
  template&lt;typename _Fn&gt;
    inline auto
    not_fn(_Fn&amp;&amp; __fn)
    noexcept(std::is_nothrow_constructible&lt;std::decay_t&lt;_Fn&gt;, _Fn&amp;&amp;&gt;::value)
    {
      return _Not_fn&lt;std::decay_t&lt;_Fn&gt;&gt;{std::forward&lt;_Fn&gt;(__fn), 0};
    }

  // Searchers
#define __cpp_lib_boyer_moore_searcher 201603

  template&lt;typename _ForwardIterator1, typename _BinaryPredicate = equal_to&lt;&gt;&gt;
    class default_searcher
    {
    public:
      default_searcher(_ForwardIterator1 __pat_first,
		       _ForwardIterator1 __pat_last,
		       _BinaryPredicate __pred = _BinaryPredicate())
      : _M_m(__pat_first, __pat_last, std::move(__pred))
      { }

      template&lt;typename _ForwardIterator2&gt;
        pair&lt;_ForwardIterator2, _ForwardIterator2&gt;
	operator()(_ForwardIterator2 __first, _ForwardIterator2 __last) const
	{
	  _ForwardIterator2 __first_ret =
	    std::search(__first, __last, std::get&lt;0&gt;(_M_m), std::get&lt;1&gt;(_M_m),
			std::get&lt;2&gt;(_M_m));
	  auto __ret = std::make_pair(__first_ret, __first_ret);
	  if (__ret.first != __last)
	    std::advance(__ret.second, std::distance(std::get&lt;0&gt;(_M_m),
						     std::get&lt;1&gt;(_M_m)));
	  return __ret;
	}

    private:
      tuple&lt;_ForwardIterator1, _ForwardIterator1, _BinaryPredicate&gt; _M_m;
    };

  template&lt;typename _Key, typename _Tp, typename _Hash, typename _Pred&gt;
    struct __boyer_moore_map_base
    {
      template&lt;typename _RAIter&gt;
	__boyer_moore_map_base(_RAIter __pat, size_t __patlen,
			       _Hash&amp;&amp; __hf, _Pred&amp;&amp; __pred)
	: _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) }
	{
	  if (__patlen &gt; 0)
	    for (__diff_type __i = 0; __i &lt; __patlen - 1; ++__i)
	      _M_bad_char[__pat[__i]] = __patlen - 1 - __i;
	}

      using __diff_type = _Tp;

      __diff_type
      _M_lookup(_Key __key, __diff_type __not_found) const
      {
	auto __iter = _M_bad_char.find(__key);
	if (__iter == _M_bad_char.end())
	  return __not_found;
	return __iter-&gt;second;
      }

      _Pred
      _M_pred() const { return _M_bad_char.key_eq(); }

      _GLIBCXX_STD_C::unordered_map&lt;_Key, _Tp, _Hash, _Pred&gt; _M_bad_char;
    };

  template&lt;typename _Tp, size_t _Len, typename _Pred&gt;
    struct __boyer_moore_array_base
    {
      template&lt;typename _RAIter, typename _Unused&gt;
	__boyer_moore_array_base(_RAIter __pat, size_t __patlen,
				 _Unused&amp;&amp;, _Pred&amp;&amp; __pred)
	: _M_bad_char{ _GLIBCXX_STD_C::array&lt;_Tp, _Len&gt;{}, std::move(__pred) }
	{
	  std::get&lt;0&gt;(_M_bad_char).fill(__patlen);
	  if (__patlen &gt; 0)
	    for (__diff_type __i = 0; __i &lt; __patlen - 1; ++__i)
	      {
		auto __ch = __pat[__i];
		using _UCh = make_unsigned_t&lt;decltype(__ch)&gt;;
		auto __uch = static_cast&lt;_UCh&gt;(__ch);
		std::get&lt;0&gt;(_M_bad_char)[__uch] = __patlen - 1 - __i;
	      }
	}

      using __diff_type = _Tp;

      template&lt;typename _Key&gt;
	__diff_type
	_M_lookup(_Key __key, __diff_type __not_found) const
	{
	  auto __ukey = static_cast&lt;make_unsigned_t&lt;_Key&gt;&gt;(__key);
	  if (__ukey &gt;= _Len)
	    return __not_found;
	  return std::get&lt;0&gt;(_M_bad_char)[__ukey];
	}

      const _Pred&amp;
      _M_pred() const { return std::get&lt;1&gt;(_M_bad_char); }

      tuple&lt;_GLIBCXX_STD_C::array&lt;_Tp, _Len&gt;, _Pred&gt; _M_bad_char;
    };

  // Use __boyer_moore_array_base when pattern consists of narrow characters
  // (or std::byte) and uses std::equal_to as the predicate.
  template&lt;typename _RAIter, typename _Hash, typename _Pred,
           typename _Val = typename iterator_traits&lt;_RAIter&gt;::value_type,
	   typename _Diff = typename iterator_traits&lt;_RAIter&gt;::difference_type&gt;
    using __boyer_moore_base_t
      = conditional_t&lt;__is_byte_like&lt;_Val, _Pred&gt;::value,
		      __boyer_moore_array_base&lt;_Diff, 256, _Pred&gt;,
		      __boyer_moore_map_base&lt;_Val, _Diff, _Hash, _Pred&gt;&gt;;

  template&lt;typename _RAIter, typename _Hash
	     = hash&lt;typename iterator_traits&lt;_RAIter&gt;::value_type&gt;,
	   typename _BinaryPredicate = equal_to&lt;&gt;&gt;
    class boyer_moore_searcher
    : __boyer_moore_base_t&lt;_RAIter, _Hash, _BinaryPredicate&gt;
    {
      using _Base = __boyer_moore_base_t&lt;_RAIter, _Hash, _BinaryPredicate&gt;;
      using typename _Base::__diff_type;

    public:
      boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last,
			   _Hash __hf = _Hash(),
			   _BinaryPredicate __pred = _BinaryPredicate());

      template&lt;typename _RandomAccessIterator2&gt;
        pair&lt;_RandomAccessIterator2, _RandomAccessIterator2&gt;
	operator()(_RandomAccessIterator2 __first,
		   _RandomAccessIterator2 __last) const;

    private:
      bool
      _M_is_prefix(_RAIter __word, __diff_type __len,
		   __diff_type __pos)
      {
	const auto&amp; __pred = this-&gt;_M_pred();
	__diff_type __suffixlen = __len - __pos;
	for (__diff_type __i = 0; __i &lt; __suffixlen; ++__i)
	  if (!__pred(__word[__i], __word[__pos + __i]))
	    return false;
	return true;
      }

      __diff_type
      _M_suffix_length(_RAIter __word, __diff_type __len,
		       __diff_type __pos)
      {
	const auto&amp; __pred = this-&gt;_M_pred();
	__diff_type __i = 0;
	while (__pred(__word[__pos - __i], __word[__len - 1 - __i])
	       &amp;&amp; __i &lt; __pos)
	  {
	    ++__i;
	  }
	return __i;
      }

      template&lt;typename _Tp&gt;
	__diff_type
	_M_bad_char_shift(_Tp __c) const
	{ return this-&gt;_M_lookup(__c, _M_pat_end - _M_pat); }

      _RAIter _M_pat;
      _RAIter _M_pat_end;
      _GLIBCXX_STD_C::vector&lt;__diff_type&gt; _M_good_suffix;
    };

  template&lt;typename _RAIter, typename _Hash
	     = hash&lt;typename iterator_traits&lt;_RAIter&gt;::value_type&gt;,
	   typename _BinaryPredicate = equal_to&lt;&gt;&gt;
    class boyer_moore_horspool_searcher
    : __boyer_moore_base_t&lt;_RAIter, _Hash, _BinaryPredicate&gt;
    {
      using _Base = __boyer_moore_base_t&lt;_RAIter, _Hash, _BinaryPredicate&gt;;
      using typename _Base::__diff_type;

    public:
      boyer_moore_horspool_searcher(_RAIter __pat,
				    _RAIter __pat_end,
				    _Hash __hf = _Hash(),
				    _BinaryPredicate __pred
				    = _BinaryPredicate())
      : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
	_M_pat(__pat), _M_pat_end(__pat_end)
      { }

      template&lt;typename _RandomAccessIterator2&gt;
        pair&lt;_RandomAccessIterator2, _RandomAccessIterator2&gt;
	operator()(_RandomAccessIterator2 __first,
		   _RandomAccessIterator2 __last) const
	{
	  const auto&amp; __pred = this-&gt;_M_pred();
	  auto __patlen = _M_pat_end - _M_pat;
	  if (__patlen == 0)
	    return std::make_pair(__first, __first);
	  auto __len = __last - __first;
	  while (__len &gt;= __patlen)
	    {
	      for (auto __scan = __patlen - 1;
		   __pred(__first[__scan], _M_pat[__scan]); --__scan)
		if (__scan == 0)
		  return std::make_pair(__first, __first + __patlen);
	      auto __shift = _M_bad_char_shift(__first[__patlen - 1]);
	      __len -= __shift;
	      __first += __shift;
	    }
	  return std::make_pair(__last, __last);
	}

    private:
      template&lt;typename _Tp&gt;
	__diff_type
	_M_bad_char_shift(_Tp __c) const
	{ return this-&gt;_M_lookup(__c, _M_pat_end - _M_pat); }

      _RAIter _M_pat;
      _RAIter _M_pat_end;
    };

  template&lt;typename _RAIter, typename _Hash, typename _BinaryPredicate&gt;
    boyer_moore_searcher&lt;_RAIter, _Hash, _BinaryPredicate&gt;::
    boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end,
			 _Hash __hf, _BinaryPredicate __pred)
    : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
      _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat)
    {
      auto __patlen = __pat_end - __pat;
      if (__patlen == 0)
	return;
      __diff_type __last_prefix = __patlen - 1;
      for (__diff_type __p = __patlen - 1; __p &gt;= 0; --__p)
	{
	  if (_M_is_prefix(__pat, __patlen, __p + 1))
	    __last_prefix = __p + 1;
	  _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p);
	}
      for (__diff_type __p = 0; __p &lt; __patlen - 1; ++__p)
	{
	  auto __slen = _M_suffix_length(__pat, __patlen, __p);
	  auto __pos = __patlen - 1 - __slen;
	  if (!__pred(__pat[__p - __slen], __pat[__pos]))
	    _M_good_suffix[__pos] = __patlen - 1 - __p + __slen;
	}
    }

  template&lt;typename _RAIter, typename _Hash, typename _BinaryPredicate&gt;
  template&lt;typename _RandomAccessIterator2&gt;
    pair&lt;_RandomAccessIterator2, _RandomAccessIterator2&gt;
    boyer_moore_searcher&lt;_RAIter, _Hash, _BinaryPredicate&gt;::
    operator()(_RandomAccessIterator2 __first,
	       _RandomAccessIterator2 __last) const
    {
      auto __patlen = _M_pat_end - _M_pat;
      if (__patlen == 0)
	return std::make_pair(__first, __first);
      const auto&amp; __pred = this-&gt;_M_pred();
      __diff_type __i = __patlen - 1;
      auto __stringlen = __last - __first;
      while (__i &lt; __stringlen)
	{
	  __diff_type __j = __patlen - 1;
	  while (__j &gt;= 0 &amp;&amp; __pred(__first[__i], _M_pat[__j]))
	    {
	      --__i;
	      --__j;
	    }
	  if (__j &lt; 0)
	    {
	      const auto __match = __first + __i + 1;
	      return std::make_pair(__match, __match + __patlen);
	    }
	  __i += std::max(_M_bad_char_shift(__first[__i]),
			  _M_good_suffix[__j]);
	}
      return std::make_pair(__last, __last);
    }

#endif // C++17
#endif // C++14

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++11

#endif // _GLIBCXX_FUNCTIONAL
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Fusr%2Finclude%2Fc%2B%2B%2F8'>⬅ Back to Directory</a>