抄一下我另一个机构的

"AC=Answer Coarse=粗劣的答案"
"WA=Wonderful Answer=好答案"
"TLE=Time Limit Enough=时间充裕"
"MLE=Memory Limit Enough=内存充裕"
"CE=Compile Easily=轻松通过编译"
"RE=Run Excellently=完美运行"
"UKE=Unbelievably Keep Enough Score=难以置信地保持足够的分数"

AC只能得低分！

千万别AC

所以：

file:///C:/Users/86177/Downloads/yu5SdbBaPDTiiWo9gEjR1%20(5).png

把如上文件全选后拖动放进最上面可以放入的地方按一下enter有祝福哦！

猜猜图片在那个题 https://kedaoi.cn/p/1041/file/xigViBgJSApza_8nB2klp.png 进去试试 你能几命过关 https://poki.com/zh/g/level-devil 猜猜是啥图片 https://kedaoi.cn/ 0 Time Exceeded P0001 A+B Problem 程子皓 ≥6586ms ≥392 KiB C++14 2 分钟前

战绩可查！！！！

代码如下

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstring>
using namespace std;
struct node 
{
    long long data,rev,sum, pig = 101;
    node *son[2],*pre;
    bool judge();
    bool isroot();
    void pushdown();
    void update();
    void setson(node *child,int lr);
}lct[233];
int top,a,b;
node *getnew(int x)
{
    node *now=lct+ ++top;
    now->data=x;
    now->pre=now->son[1]=now->son[0]=lct;
    now->sum=0;
    now->rev=0;
    return now;
}
bool node::judge(){return pre->son[1]==this;}
bool node::isroot()
{
    if(pre==lct)return true;
    return !(pre->son[1]==this||pre->son[0]==this);
}
void node::pushdown()
{
    if(this==lct||!rev)return;
    swap(son[0],son[1]);
    son[0]->rev^=1;
    son[1]->rev^=1;
    rev=0;
}
void node::update(){sum=son[1]->sum+son[0]->sum+data;}
void node::setson(node *child,int lr)
{
    this->pushdown();
    child->pre=this;
    son[lr]=child;
    this->update();
}
void rotate(node *now)
{
    node *father=now->pre,*grandfa=father->pre;
    if(!father->isroot()) grandfa->pushdown();
    father->pushdown();now->pushdown();
    int lr=now->judge();
    father->setson(now->son[lr^1],lr);
    if(father->isroot()) now->pre=grandfa;
    else grandfa->setson(now,father->judge());
    now->setson(father,lr^1);
    father->update();now->update();
    if(grandfa!=lct) grandfa->update();
}
void splay(node *now)
{
    if(now->isroot())return;
    for(;!now->isroot();rotate(now))
    if(!now->pre->isroot())
    now->judge()==now->pre->judge()?rotate(now->pre):rotate(now);
}
node *access(node *now)
{
    node *last=lct;
    for(;now!=lct;last=now,now=now->pre)
    {
        splay(now);
        now->setson(last,1);
    }
    return last;
}
void changeroot(node *now)
{
    access(now)->rev^=1;
    splay(now);
}
void connect(node *x,node *y)
{
    changeroot(x);
    x->pre=y;
    access(x);
}
void cut(node *x,node *y)
{
    changeroot(x);
    access(y);
    splay(x);
    x->pushdown();
    x->son[1]=y->pre=lct;
    x->update();
}
int query(node *x,node *y)
{
    changeroot(x);
    node *now=access(y);
    return now->sum;
}
int main()
{
    scanf("%d%d",&a,&b);
    node *A=getnew(a);
    node *B=getnew(b);
        connect(A,B);
        cut(A,B);
        connect(A,B);
    for(int i = 1; i <= 1000000000001; i++){
    	i -= 1;
	}
    printf("%d\n",query(A,B)); 
    return 0;
}

0 Runtime Error P1763 自己实现函数—min() 程子皓 10ms 416 KiB C++ 14 3 分钟前 我是第一个RE的！ 代码如下:

#include<bits/stdc++.h>
using namespace std;
int main(){
	int n = 1;
	int s = 1/0;
	cout << s;
	return 0;	
}

有谁知道为什么编译会出现这个啊？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？

// Core algorithmic facilities -*- C++ -*-

// Copyright (C) 2001-2014 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/>.

/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * 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.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1996-1998
 * 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 "as is" without express or implied warranty.
 */

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

#ifndef _STL_ALGOBASE_H
#define _STL_ALGOBASE_H 1

#include <bits/c++config.h>
#include <bits/functexcept.h>
#include <bits/cpp_type_traits.h>
#include <ext/type_traits.h>
#include <ext/numeric_traits.h>
#include <bits/stl_pair.h>
#include <bits/stl_iterator_base_types.h>
#include <bits/stl_iterator_base_funcs.h>
#include <bits/stl_iterator.h>
#include <bits/concept_check.h>
#include <debug/debug.h>
#include <bits/move.h> // For std::swap and _GLIBCXX_MOVE
#include <bits/predefined_ops.h>

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

#if __cplusplus < 201103L
  // See http://gcc.gnu.org/ml/libstdc++/2004-08/msg00167.html: in a
  // nutshell, we are partially implementing the resolution of DR 187,
  // when it's safe, i.e., the value_types are equal.
  template<bool _BoolType>
    struct __iter_swap
    {
      template<typename _ForwardIterator1, typename _ForwardIterator2>
        static void
        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
        {
          typedef typename iterator_traits<_ForwardIterator1>::value_type
            _ValueType1;
          _ValueType1 __tmp = _GLIBCXX_MOVE(*__a);
          *__a = _GLIBCXX_MOVE(*__b);
          *__b = _GLIBCXX_MOVE(__tmp);
	}
    };

  template<>
    struct __iter_swap<true>
    {
      template<typename _ForwardIterator1, typename _ForwardIterator2>
        static void 
        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
        {
          swap(*__a, *__b);
        }
    };
#endif

  /**
   *  @brief Swaps the contents of two iterators.
   *  @ingroup mutating_algorithms
   *  @param  __a  An iterator.
   *  @param  __b  Another iterator.
   *  @return   Nothing.
   *
   *  This function swaps the values pointed to by two iterators, not the
   *  iterators themselves.
  */
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    inline void
    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
    {
      // concept requirements
      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
				  _ForwardIterator1>)
      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
				  _ForwardIterator2>)

#if __cplusplus < 201103L
      typedef typename iterator_traits<_ForwardIterator1>::value_type
	_ValueType1;
      typedef typename iterator_traits<_ForwardIterator2>::value_type
	_ValueType2;

      __glibcxx_function_requires(_ConvertibleConcept<_ValueType1,
				  _ValueType2>)
      __glibcxx_function_requires(_ConvertibleConcept<_ValueType2,
				  _ValueType1>)

      typedef typename iterator_traits<_ForwardIterator1>::reference
	_ReferenceType1;
      typedef typename iterator_traits<_ForwardIterator2>::reference
	_ReferenceType2;
      std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
	&& __are_same<_ValueType1&, _ReferenceType1>::__value
	&& __are_same<_ValueType2&, _ReferenceType2>::__value>::
	iter_swap(__a, __b);
#else
      swap(*__a, *__b);
#endif
    }

  /**
   *  @brief Swap the elements of two sequences.
   *  @ingroup mutating_algorithms
   *  @param  __first1  A forward iterator.
   *  @param  __last1   A forward iterator.
   *  @param  __first2  A forward iterator.
   *  @return   An iterator equal to @p first2+(last1-first1).
   *
   *  Swaps each element in the range @p [first1,last1) with the
   *  corresponding element in the range @p [first2,(last1-first1)).
   *  The ranges must not overlap.
  */
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    _ForwardIterator2
    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
		_ForwardIterator2 __first2)
    {
      // concept requirements
      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
				  _ForwardIterator1>)
      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
				  _ForwardIterator2>)
      __glibcxx_requires_valid_range(__first1, __last1);

      for (; __first1 != __last1; ++__first1, ++__first2)
	std::iter_swap(__first1, __first2);
      return __first2;
    }

  /**
   *  @brief This does what you think it does.
   *  @ingroup sorting_algorithms
   *  @param  __a  A thing of arbitrary type.
   *  @param  __b  Another thing of arbitrary type.
   *  @return   The lesser of the parameters.
   *
   *  This is the simple classic generic implementation.  It will work on
   *  temporary expressions, since they are only evaluated once, unlike a
   *  preprocessor macro.
  */
  template<typename _Tp>
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b)
    {
      // concept requirements
      __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
      //return __b < __a ? __b : __a;
      if (__b < __a)
	return __b;
      return __a;
    }

  /**
   *  @brief This does what you think it does.
   *  @ingroup sorting_algorithms
   *  @param  __a  A thing of arbitrary type.
   *  @param  __b  Another thing of arbitrary type.
   *  @return   The greater of the parameters.
   *
   *  This is the simple classic generic implementation.  It will work on
   *  temporary expressions, since they are only evaluated once, unlike a
   *  preprocessor macro.
  */
  template<typename _Tp>
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b)
    {
      // concept requirements
      __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)
      //return  __a < __b ? __b : __a;
      if (__a < __b)
	return __b;
      return __a;
    }

  /**
   *  @brief This does what you think it does.
   *  @ingroup sorting_algorithms
   *  @param  __a  A thing of arbitrary type.
   *  @param  __b  Another thing of arbitrary type.
   *  @param  __comp  A @link comparison_functors comparison functor@endlink.
   *  @return   The lesser of the parameters.
   *
   *  This will work on temporary expressions, since they are only evaluated
   *  once, unlike a preprocessor macro.
  */
  template<typename _Tp, typename _Compare>
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {
      //return __comp(__b, __a) ? __b : __a;
      if (__comp(__b, __a))
	return __b;
      return __a;
    }

  /**
   *  @brief This does what you think it does.
   *  @ingroup sorting_algorithms
   *  @param  __a  A thing of arbitrary type.
   *  @param  __b  Another thing of arbitrary type.
   *  @param  __comp  A @link comparison_functors comparison functor@endlink.
   *  @return   The greater of the parameters.
   *
   *  This will work on temporary expressions, since they are only evaluated
   *  once, unlike a preprocessor macro.
  */
  template<typename _Tp, typename _Compare>
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {
      //return __comp(__a, __b) ? __b : __a;
      if (__comp(__a, __b))
	return __b;
      return __a;
    }

  // If _Iterator is a __normal_iterator return its base (a plain pointer,
  // normally) otherwise return it untouched.  See copy, fill, ... 
  template<typename _Iterator>
    struct _Niter_base
    : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
    { };

  template<typename _Iterator>
    inline typename _Niter_base<_Iterator>::iterator_type
    __niter_base(_Iterator __it)
    { return std::_Niter_base<_Iterator>::_S_base(__it); }

  // Likewise, for move_iterator.
  template<typename _Iterator>
    struct _Miter_base
    : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
    { };

  template<typename _Iterator>
    inline typename _Miter_base<_Iterator>::iterator_type
    __miter_base(_Iterator __it)
    { return std::_Miter_base<_Iterator>::_S_base(__it); }

  // All of these auxiliary structs serve two purposes.  (1) Replace
  // calls to copy with memmove whenever possible.  (Memmove, not memcpy,
  // because the input and output ranges are permitted to overlap.)
  // (2) If we're using random access iterators, then write the loop as
  // a for loop with an explicit count.

  template<bool, bool, typename>
    struct __copy_move
    {
      template<typename _II, typename _OI>
        static _OI
        __copy_m(_II __first, _II __last, _OI __result)
        {
	  for (; __first != __last; ++__result, ++__first)
	    *__result = *__first;
	  return __result;
	}
    };

#if __cplusplus >= 201103L
  template<typename _Category>
    struct __copy_move<true, false, _Category>
    {
      template<typename _II, typename _OI>
        static _OI
        __copy_m(_II __first, _II __last, _OI __result)
        {
	  for (; __first != __last; ++__result, ++__first)
	    *__result = std::move(*__first);
	  return __result;
	}
    };
#endif

  template<>
    struct __copy_move<false, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI>
        static _OI
        __copy_m(_II __first, _II __last, _OI __result)
        { 
	  typedef typename iterator_traits<_II>::difference_type _Distance;
	  for(_Distance __n = __last - __first; __n > 0; --__n)
	    {
	      *__result = *__first;
	      ++__first;
	      ++__result;
	    }
	  return __result;
	}
    };

#if __cplusplus >= 201103L
  template<>
    struct __copy_move<true, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI>
        static _OI
        __copy_m(_II __first, _II __last, _OI __result)
        { 
	  typedef typename iterator_traits<_II>::difference_type _Distance;
	  for(_Distance __n = __last - __first; __n > 0; --__n)
	    {
	      *__result = std::move(*__first);
	      ++__first;
	      ++__result;
	    }
	  return __result;
	}
    };
#endif

  template<bool _IsMove>
    struct __copy_move<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>
        static _Tp*
        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
        {
#if __cplusplus >= 201103L
	  // trivial types can have deleted assignment
	  static_assert( is_copy_assignable<_Tp>::value,
	                 "type is not assignable" );
#endif
	  const ptrdiff_t _Num = __last - __first;
	  if (_Num)
	    __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
	  return __result + _Num;
	}
    };

  template<bool _IsMove, typename _II, typename _OI>
    inline _OI
    __copy_move_a(_II __first, _II __last, _OI __result)
    {
      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
      typedef typename iterator_traits<_II>::iterator_category _Category;
      const bool __simple = (__is_trivial(_ValueTypeI)
	                     && __is_pointer<_II>::__value
	                     && __is_pointer<_OI>::__value
			     && __are_same<_ValueTypeI, _ValueTypeO>::__value);

      return std::__copy_move<_IsMove, __simple,
	                      _Category>::__copy_m(__first, __last, __result);
    }

  // Helpers for streambuf iterators (either istream or ostream).
  // NB: avoid including <iosfwd>, relatively large.
  template<typename _CharT>
    struct char_traits;

  template<typename _CharT, typename _Traits>
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator;

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, 
	     ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(_CharT*, _CharT*,
		   ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, 
	     ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(const _CharT*, const _CharT*,
		   ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
				    _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
		   istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);

  template<bool _IsMove, typename _II, typename _OI>
    inline _OI
    __copy_move_a2(_II __first, _II __last, _OI __result)
    {
      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
					     std::__niter_base(__last),
					     std::__niter_base(__result)));
    }

  /**
   *  @brief Copies the range [first,last) into result.
   *  @ingroup mutating_algorithms
   *  @param  __first  An input iterator.
   *  @param  __last   An input iterator.
   *  @param  __result An output iterator.
   *  @return   result + (first - last)
   *
   *  This inline function will boil down to a call to @c memmove whenever
   *  possible.  Failing that, if random access iterators are passed, then the
   *  loop count will be known (and therefore a candidate for compiler
   *  optimizations such as unrolling).  Result may not be contained within
   *  [first,last); the copy_backward function should be used instead.
   *
   *  Note that the end of the output range is permitted to be contained
   *  within [first,last).
  */
  template<typename _II, typename _OI>
    inline _OI
    copy(_II __first, _II __last, _OI __result)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_II>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OI,
	    typename iterator_traits<_II>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);

      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
	      (std::__miter_base(__first), std::__miter_base(__last),
	       __result));
    }

#if __cplusplus >= 201103L
  /**
   *  @brief Moves the range [first,last) into result.
   *  @ingroup mutating_algorithms
   *  @param  __first  An input iterator.
   *  @param  __last   An input iterator.
   *  @param  __result An output iterator.
   *  @return   result + (first - last)
   *
   *  This inline function will boil down to a call to @c memmove whenever
   *  possible.  Failing that, if random access iterators are passed, then the
   *  loop count will be known (and therefore a candidate for compiler
   *  optimizations such as unrolling).  Result may not be contained within
   *  [first,last); the move_backward function should be used instead.
   *
   *  Note that the end of the output range is permitted to be contained
   *  within [first,last).
  */
  template<typename _II, typename _OI>
    inline _OI
    move(_II __first, _II __last, _OI __result)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_II>)
      __glibcxx_function_requires(_OutputIteratorConcept<_OI,
	    typename iterator_traits<_II>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);

      return std::__copy_move_a2<true>(std::__miter_base(__first),
				       std::__miter_base(__last), __result);
    }

#define _GLIBCXX_MOVE3(_Tp, _Up, _Vp) std::move(_Tp, _Up, _Vp)
#else
#define _GLIBCXX_MOVE3(_Tp, _Up, _Vp) std::copy(_Tp, _Up, _Vp)
#endif

  template<bool, bool, typename>
    struct __copy_move_backward
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
	  while (__first != __last)
	    *--__result = *--__last;
	  return __result;
	}
    };

#if __cplusplus >= 201103L
  template<typename _Category>
    struct __copy_move_backward<true, false, _Category>
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
	  while (__first != __last)
	    *--__result = std::move(*--__last);
	  return __result;
	}
    };
#endif

  template<>
    struct __copy_move_backward<false, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
	  typename iterator_traits<_BI1>::difference_type __n;
	  for (__n = __last - __first; __n > 0; --__n)
	    *--__result = *--__last;
	  return __result;
	}
    };

#if __cplusplus >= 201103L
  template<>
    struct __copy_move_backward<true, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
	  typename iterator_traits<_BI1>::difference_type __n;
	  for (__n = __last - __first; __n > 0; --__n)
	    *--__result = std::move(*--__last);
	  return __result;
	}
    };
#endif

  template<bool _IsMove>
    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp>
        static _Tp*
        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
        {
#if __cplusplus >= 201103L
	  // trivial types can have deleted assignment
	  static_assert( is_copy_assignable<_Tp>::value,
	                 "type is not assignable" );
#endif
	  const ptrdiff_t _Num = __last - __first;
	  if (_Num)
	    __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
	  return __result - _Num;
	}
    };

  template<bool _IsMove, typename _BI1, typename _BI2>
    inline _BI2
    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
      typedef typename iterator_traits<_BI1>::iterator_category _Category;
      const bool __simple = (__is_trivial(_ValueType1)
	                     && __is_pointer<_BI1>::__value
	                     && __is_pointer<_BI2>::__value
			     && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__copy_move_backward<_IsMove, __simple,
	                               _Category>::__copy_move_b(__first,
								 __last,
								 __result);
    }

  template<bool _IsMove, typename _BI1, typename _BI2>
    inline _BI2
    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      return _BI2(std::__copy_move_backward_a<_IsMove>
		  (std::__niter_base(__first), std::__niter_base(__last),
		   std::__niter_base(__result)));
    }

  /**
   *  @brief Copies the range [first,last) into result.
   *  @ingroup mutating_algorithms
   *  @param  __first  A bidirectional iterator.
   *  @param  __last   A bidirectional iterator.
   *  @param  __result A bidirectional iterator.
   *  @return   result - (first - last)
   *
   *  The function has the same effect as copy, but starts at the end of the
   *  range and works its way to the start, returning the start of the result.
   *  This inline function will boil down to a call to @c memmove whenever
   *  possible.  Failing that, if random access iterators are passed, then the
   *  loop count will be known (and therefore a candidate for compiler
   *  optimizations such as unrolling).
   *
   *  Result may not be in the range (first,last].  Use copy instead.  Note
   *  that the start of the output range may overlap [first,last).
  */
  template<typename _BI1, typename _BI2>
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      // concept requirements
      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>)
      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>)
      __glibcxx_function_requires(_ConvertibleConcept<
	    typename iterator_traits<_BI1>::value_type,
	    typename iterator_traits<_BI2>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);

      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
	      (std::__miter_base(__first), std::__miter_base(__last),
	       __result));
    }

#if __cplusplus >= 201103L
  /**
   *  @brief Moves the range [first,last) into result.
   *  @ingroup mutating_algorithms
   *  @param  __first  A bidirectional iterator.
   *  @param  __last   A bidirectional iterator.
   *  @param  __result A bidirectional iterator.
   *  @return   result - (first - last)
   *
   *  The function has the same effect as move, but starts at the end of the
   *  range and works its way to the start, returning the start of the result.
   *  This inline function will boil down to a call to @c memmove whenever
   *  possible.  Failing that, if random access iterators are passed, then the
   *  loop count will be known (and therefore a candidate for compiler
   *  optimizations such as unrolling).
   *
   *  Result may not be in the range (first,last].  Use move instead.  Note
   *  that the start of the output range may overlap [first,last).
  */
  template<typename _BI1, typename _BI2>
    inline _BI2
    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      // concept requirements
      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>)
      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>)
      __glibcxx_function_requires(_ConvertibleConcept<
	    typename iterator_traits<_BI1>::value_type,
	    typename iterator_traits<_BI2>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);

      return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
						std::__miter_base(__last),
						__result);
    }

#define _GLIBCXX_MOVE_BACKWARD3(_Tp, _Up, _Vp) std::move_backward(_Tp, _Up, _Vp)
#else
#define _GLIBCXX_MOVE_BACKWARD3(_Tp, _Up, _Vp) std::copy_backward(_Tp, _Up, _Vp)
#endif

  template<typename _ForwardIterator, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
 	     const _Tp& __value)
    {
      for (; __first != __last; ++__first)
	*__first = __value;
    }
    
  template<typename _ForwardIterator, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
	     const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __first != __last; ++__first)
	*__first = __tmp;
    }

  // Specialization: for char types we can use memset.
  template<typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
    {
      const _Tp __tmp = __c;
      __builtin_memset(__first, static_cast<unsigned char>(__tmp),
		       __last - __first);
    }

  /**
   *  @brief Fills the range [first,last) with copies of value.
   *  @ingroup mutating_algorithms
   *  @param  __first  A forward iterator.
   *  @param  __last   A forward iterator.
   *  @param  __value  A reference-to-const of arbitrary type.
   *  @return   Nothing.
   *
   *  This function fills a range with copies of the same value.  For char
   *  types filling contiguous areas of memory, this becomes an inline call
   *  to @c memset or @c wmemset.
  */
  template<typename _ForwardIterator, typename _Tp>
    inline void
    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
    {
      // concept requirements
      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
				  _ForwardIterator>)
      __glibcxx_requires_valid_range(__first, __last);

      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
		    __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      for (__decltype(__n + 0) __niter = __n;
	   __niter > 0; --__niter, ++__first)
	*__first = __value;
      return __first;
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (__decltype(__n + 0) __niter = __n;
	   __niter > 0; --__niter, ++__first)
	*__first = __tmp;
      return __first;
    }

  template<typename _Size, typename _Tp>
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
    {
      std::__fill_a(__first, __first + __n, __c);
      return __first + __n;
    }

  /**
   *  @brief Fills the range [first,first+n) with copies of value.
   *  @ingroup mutating_algorithms
   *  @param  __first  An output iterator.
   *  @param  __n      The count of copies to perform.
   *  @param  __value  A reference-to-const of arbitrary type.
   *  @return   The iterator at first+n.
   *
   *  This function fills a range with copies of the same value.  For char
   *  types filling contiguous areas of memory, this becomes an inline call
   *  to @c memset or @ wmemset.
   *
   *  _GLIBCXX_RESOLVE_LIB_DEFECTS
   *  DR 865. More algorithms that throw away information
  */
  template<typename _OI, typename _Size, typename _Tp>
    inline _OI
    fill_n(_OI __first, _Size __n, const _Tp& __value)
    {
      // concept requirements
      __glibcxx_function_requires(_OutputIteratorConcept<_OI, _Tp>)

      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
    }

  template<bool _BoolType>
    struct __equal
    {
      template<typename _II1, typename _II2>
        static bool
        equal(_II1 __first1, _II1 __last1, _II2 __first2)
        {
	  for (; __first1 != __last1; ++__first1, ++__first2)
	    if (!(*__first1 == *__first2))
	      return false;
	  return true;
	}
    };

  template<>
    struct __equal<true>
    {
      template<typename _Tp>
        static bool
        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
        {
	  return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
				   * (__last1 - __first1));
	}
    };

  template<typename _II1, typename _II2>
    inline bool
    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple = ((__is_integer<_ValueType1>::__value
			      || __is_pointer<_ValueType1>::__value)
	                     && __is_pointer<_II1>::__value
	                     && __is_pointer<_II2>::__value
			     && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__equal<__simple>::equal(__first1, __last1, __first2);
    }

  template<typename, typename>
    struct __lc_rai
    {
      template<typename _II1, typename _II2>
        static _II1
        __newlast1(_II1, _II1 __last1, _II2, _II2)
        { return __last1; }

      template<typename _II>
        static bool
        __cnd2(_II __first, _II __last)
        { return __first != __last; }
    };

  template<>
    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
    {
      template<typename _RAI1, typename _RAI2>
        static _RAI1
        __newlast1(_RAI1 __first1, _RAI1 __last1,
		   _RAI2 __first2, _RAI2 __last2)
        {
	  const typename iterator_traits<_RAI1>::difference_type
	    __diff1 = __last1 - __first1;
	  const typename iterator_traits<_RAI2>::difference_type
	    __diff2 = __last2 - __first2;
	  return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
	}

      template<typename _RAI>
        static bool
        __cnd2(_RAI, _RAI)
        { return true; }
    };

  template<typename _II1, typename _II2, typename _Compare>
    bool
    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
				   _II2 __first2, _II2 __last2,
				   _Compare __comp)
    {
      typedef typename iterator_traits<_II1>::iterator_category _Category1;
      typedef typename iterator_traits<_II2>::iterator_category _Category2;
      typedef std::__lc_rai<_Category1, _Category2> __rai_type;

      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
	   ++__first1, ++__first2)
	{
	  if (__comp(__first1, __first2))
	    return true;
	  if (__comp(__first2, __first1))
	    return false;
	}
      return __first1 == __last1 && __first2 != __last2;
    }

  template<bool _BoolType>
    struct __lexicographical_compare
    {
      template<typename _II1, typename _II2>
        static bool __lc(_II1, _II1, _II2, _II2);
    };

  template<bool _BoolType>
    template<typename _II1, typename _II2>
      bool
      __lexicographical_compare<_BoolType>::
      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
      {
	return std::__lexicographical_compare_impl(__first1, __last1,
						   __first2, __last2,
					__gnu_cxx::__ops::__iter_less_iter());
      }

  template<>
    struct __lexicographical_compare<true>
    {
      template<typename _Tp, typename _Up>
        static bool
        __lc(const _Tp* __first1, const _Tp* __last1,
	     const _Up* __first2, const _Up* __last2)
	{
	  const size_t __len1 = __last1 - __first1;
	  const size_t __len2 = __last2 - __first2;
	  const int __result = __builtin_memcmp(__first1, __first2,
						std::min(__len1, __len2));
	  return __result != 0 ? __result < 0 : __len1 < __len2;
	}
    };

  template<typename _II1, typename _II2>
    inline bool
    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
				  _II2 __first2, _II2 __last2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple =
	(__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
	 && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
	 && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
	 && __is_pointer<_II1>::__value
	 && __is_pointer<_II2>::__value);

      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
							    __first2, __last2);
    }

  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    _ForwardIterator
    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
		  const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
	_DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
	{
	  _DistanceType __half = __len >> 1;
	  _ForwardIterator __middle = __first;
	  std::advance(__middle, __half);
	  if (__comp(__middle, __val))
	    {
	      __first = __middle;
	      ++__first;
	      __len = __len - __half - 1;
	    }
	  else
	    __len = __half;
	}
      return __first;
    }

  /**
   *  @brief Finds the first position in which @a val could be inserted
   *         without changing the ordering.
   *  @param  __first   An iterator.
   *  @param  __last    Another iterator.
   *  @param  __val     The search term.
   *  @return         An iterator pointing to the first element <em>not less
   *                  than</em> @a val, or end() if every element is less than 
   *                  @a val.
   *  @ingroup binary_search_algorithms
  */
  template<typename _ForwardIterator, typename _Tp>
    inline _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
		const _Tp& __val)
    {
      // concept requirements
      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
      __glibcxx_function_requires(_LessThanOpConcept<
	    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)
      __glibcxx_requires_partitioned_lower(__first, __last, __val);

      return std::__lower_bound(__first, __last, __val,
				__gnu_cxx::__ops::__iter_less_val());
    }

  /// This is a helper function for the sort routines and for random.tcc.
  //  Precondition: __n > 0.
  inline _GLIBCXX_CONSTEXPR int
  __lg(int __n)
  { return sizeof(int) * __CHAR_BIT__  - 1 - __builtin_clz(__n); }

  inline _GLIBCXX_CONSTEXPR unsigned
  __lg(unsigned __n)
  { return sizeof(int) * __CHAR_BIT__  - 1 - __builtin_clz(__n); }

  inline _GLIBCXX_CONSTEXPR long
  __lg(long __n)
  { return sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); }

  inline _GLIBCXX_CONSTEXPR unsigned long
  __lg(unsigned long __n)
  { return sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); }

  inline _GLIBCXX_CONSTEXPR long long
  __lg(long long __n)
  { return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); }

  inline _GLIBCXX_CONSTEXPR unsigned long long
  __lg(unsigned long long __n)
  { return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); }

_GLIBCXX_END_NAMESPACE_VERSION

_GLIBCXX_BEGIN_NAMESPACE_ALGO

  /**
   *  @brief Tests a range for element-wise equality.
   *  @ingroup non_mutating_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @return   A boolean true or false.
   *
   *  This compares the elements of two ranges using @c == and returns true or
   *  false depending on whether all of the corresponding elements of the
   *  ranges are equal.
  */
  template<typename _II1, typename _II2>
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_II1>)
      __glibcxx_function_requires(_InputIteratorConcept<_II2>)
      __glibcxx_function_requires(_EqualOpConcept<
	    typename iterator_traits<_II1>::value_type,
	    typename iterator_traits<_II2>::value_type>)
      __glibcxx_requires_valid_range(__first1, __last1);

      return std::__equal_aux(std::__niter_base(__first1),
			      std::__niter_base(__last1),
			      std::__niter_base(__first2));
    }

  /**
   *  @brief Tests a range for element-wise equality.
   *  @ingroup non_mutating_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @param __binary_pred A binary predicate @link functors
   *                  functor@endlink.
   *  @return         A boolean true or false.
   *
   *  This compares the elements of two ranges using the binary_pred
   *  parameter, and returns true or
   *  false depending on whether all of the corresponding elements of the
   *  ranges are equal.
  */
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
	  _IIter2 __first2, _BinaryPredicate __binary_pred)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_IIter1>)
      __glibcxx_function_requires(_InputIteratorConcept<_IIter2>)
      __glibcxx_requires_valid_range(__first1, __last1);

      for (; __first1 != __last1; ++__first1, ++__first2)
	if (!bool(__binary_pred(*__first1, *__first2)))
	  return false;
      return true;
    }

#if __cplusplus > 201103L

#define __cpp_lib_robust_nonmodifying_seq_ops 201304

  /**
   *  @brief Tests a range for element-wise equality.
   *  @ingroup non_mutating_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @param  __last2   An input iterator.
   *  @return   A boolean true or false.
   *
   *  This compares the elements of two ranges using @c == and returns true or
   *  false depending on whether all of the corresponding elements of the
   *  ranges are equal.
  */
  template<typename _II1, typename _II2>
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_II1>)
      __glibcxx_function_requires(_InputIteratorConcept<_II2>)
      __glibcxx_function_requires(_EqualOpConcept<
	    typename iterator_traits<_II1>::value_type,
	    typename iterator_traits<_II2>::value_type>)
      __glibcxx_requires_valid_range(__first1, __last1);
      __glibcxx_requires_valid_range(__first2, __last2);

      using _RATag = random_access_iterator_tag;
      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
      if (_RAIters())
	{
	  auto __d1 = std::distance(__first1, __last1);
	  auto __d2 = std::distance(__first2, __last2);
	  if (__d1 != __d2)
	    return false;
	  return _GLIBCXX_STD_A::equal(__first1, __last1, __first2);
	}

      for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
	if (!(*__first1 == *__first2))
	  return false;
      return __first1 == __last1 && __first2 == __last2;
    }

  /**
   *  @brief Tests a range for element-wise equality.
   *  @ingroup non_mutating_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @param  __last2   An input iterator.
   *  @param __binary_pred A binary predicate @link functors
   *                  functor@endlink.
   *  @return         A boolean true or false.
   *
   *  This compares the elements of two ranges using the binary_pred
   *  parameter, and returns true or
   *  false depending on whether all of the corresponding elements of the
   *  ranges are equal.
  */
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
	  _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_IIter1>)
      __glibcxx_function_requires(_InputIteratorConcept<_IIter2>)
      __glibcxx_requires_valid_range(__first1, __last1);
      __glibcxx_requires_valid_range(__first2, __last2);

      using _RATag = random_access_iterator_tag;
      using _Cat1 = typename iterator_traits<_IIter1>::iterator_category;
      using _Cat2 = typename iterator_traits<_IIter2>::iterator_category;
      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
      if (_RAIters())
	{
	  auto __d1 = std::distance(__first1, __last1);
	  auto __d2 = std::distance(__first2, __last2);
	  if (__d1 != __d2)
	    return false;
	  return _GLIBCXX_STD_A::equal(__first1, __last1, __first2,
				       __binary_pred);
	}

      for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
	if (!bool(__binary_pred(*__first1, *__first2)))
	  return false;
      return __first1 == __last1 && __first2 == __last2;
    }
#endif

  /**
   *  @brief Performs @b dictionary comparison on ranges.
   *  @ingroup sorting_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @param  __last2   An input iterator.
   *  @return   A boolean true or false.
   *
   *  <em>Returns true if the sequence of elements defined by the range
   *  [first1,last1) is lexicographically less than the sequence of elements
   *  defined by the range [first2,last2).  Returns false otherwise.</em>
   *  (Quoted from [25.3.8]/1.)  If the iterators are all character pointers,
   *  then this is an inline call to @c memcmp.
  */
  template<typename _II1, typename _II2>
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
			    _II2 __first2, _II2 __last2)
    {
#ifdef _GLIBCXX_CONCEPT_CHECKS
      // concept requirements
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
#endif
      __glibcxx_function_requires(_InputIteratorConcept<_II1>)
      __glibcxx_function_requires(_InputIteratorConcept<_II2>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)
      __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)
      __glibcxx_requires_valid_range(__first1, __last1);
      __glibcxx_requires_valid_range(__first2, __last2);

      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
						std::__niter_base(__last1),
						std::__niter_base(__first2),
						std::__niter_base(__last2));
    }

  /**
   *  @brief Performs @b dictionary comparison on ranges.
   *  @ingroup sorting_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @param  __last2   An input iterator.
   *  @param  __comp  A @link comparison_functors comparison functor@endlink.
   *  @return   A boolean true or false.
   *
   *  The same as the four-parameter @c lexicographical_compare, but uses the
   *  comp parameter instead of @c <.
  */
  template<typename _II1, typename _II2, typename _Compare>
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
			    _II2 __first2, _II2 __last2, _Compare __comp)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_II1>)
      __glibcxx_function_requires(_InputIteratorConcept<_II2>)
      __glibcxx_requires_valid_range(__first1, __last1);
      __glibcxx_requires_valid_range(__first2, __last2);

      return std::__lexicographical_compare_impl
	(__first1, __last1, __first2, __last2,
	 __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
	   typename _BinaryPredicate>
    pair<_InputIterator1, _InputIterator2>
    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
	       _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {
      while (__first1 != __last1 && __binary_pred(__first1, __first2))
        {
	  ++__first1;
	  ++__first2;
        }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }

  /**
   *  @brief Finds the places in ranges which don't match.
   *  @ingroup non_mutating_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @return   A pair of iterators pointing to the first mismatch.
   *
   *  This compares the elements of two ranges using @c == and returns a pair
   *  of iterators.  The first iterator points into the first range, the
   *  second iterator points into the second range, and the elements pointed
   *  to by the iterators are not equal.
  */
  template<typename _InputIterator1, typename _InputIterator2>
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_EqualOpConcept<
	    typename iterator_traits<_InputIterator1>::value_type,
	    typename iterator_traits<_InputIterator2>::value_type>)
      __glibcxx_requires_valid_range(__first1, __last1);

      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,
			     __gnu_cxx::__ops::__iter_equal_to_iter());
    }

  /**
   *  @brief Finds the places in ranges which don't match.
   *  @ingroup non_mutating_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @param __binary_pred A binary predicate @link functors
   *         functor@endlink.
   *  @return   A pair of iterators pointing to the first mismatch.
   *
   *  This compares the elements of two ranges using the binary_pred
   *  parameter, and returns a pair
   *  of iterators.  The first iterator points into the first range, the
   *  second iterator points into the second range, and the elements pointed
   *  to by the iterators are not equal.
  */
  template<typename _InputIterator1, typename _InputIterator2,
	   typename _BinaryPredicate>
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_requires_valid_range(__first1, __last1);

      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,
	__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }

#if __cplusplus > 201103L

  template<typename _InputIterator1, typename _InputIterator2,
	   typename _BinaryPredicate>
    pair<_InputIterator1, _InputIterator2>
    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
	       _InputIterator2 __first2, _InputIterator2 __last2,
	       _BinaryPredicate __binary_pred)
    {
      while (__first1 != __last1 && __first2 != __last2
	     && __binary_pred(__first1, __first2))
        {
	  ++__first1;
	  ++__first2;
        }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }

  /**
   *  @brief Finds the places in ranges which don't match.
   *  @ingroup non_mutating_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @param  __last2   An input iterator.
   *  @return   A pair of iterators pointing to the first mismatch.
   *
   *  This compares the elements of two ranges using @c == and returns a pair
   *  of iterators.  The first iterator points into the first range, the
   *  second iterator points into the second range, and the elements pointed
   *  to by the iterators are not equal.
  */
  template<typename _InputIterator1, typename _InputIterator2>
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2, _InputIterator2 __last2)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_function_requires(_EqualOpConcept<
	    typename iterator_traits<_InputIterator1>::value_type,
	    typename iterator_traits<_InputIterator2>::value_type>)
      __glibcxx_requires_valid_range(__first1, __last1);
      __glibcxx_requires_valid_range(__first2, __last2);

      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2,
			     __gnu_cxx::__ops::__iter_equal_to_iter());
    }

  /**
   *  @brief Finds the places in ranges which don't match.
   *  @ingroup non_mutating_algorithms
   *  @param  __first1  An input iterator.
   *  @param  __last1   An input iterator.
   *  @param  __first2  An input iterator.
   *  @param  __last2   An input iterator.
   *  @param __binary_pred A binary predicate @link functors
   *         functor@endlink.
   *  @return   A pair of iterators pointing to the first mismatch.
   *
   *  This compares the elements of two ranges using the binary_pred
   *  parameter, and returns a pair
   *  of iterators.  The first iterator points into the first range, the
   *  second iterator points into the second range, and the elements pointed
   *  to by the iterators are not equal.
  */
  template<typename _InputIterator1, typename _InputIterator2,
	   typename _BinaryPredicate>
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
	     _InputIterator2 __first2, _InputIterator2 __last2,
	     _BinaryPredicate __binary_pred)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
      __glibcxx_requires_valid_range(__first1, __last1);
      __glibcxx_requires_valid_range(__first2, __last2);

      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2,
			     __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }
#endif

_GLIBCXX_END_NAMESPACE_ALGO
} // namespace std

// NB: This file is included within many other C++ includes, as a way
// of getting the base 
#ifdekandouIBCXX_PAk·ndoEL
# inclukan··<parallel/alkanba··e.h>
#endif
#endif

乱按按出来的

<!DOCTYPE html>
<html data-page="user_detail" data-layout="basic" class="layout--basic page--user_detail theme--light nojs" lang="zh" data-app="Hydro">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
  <meta http-equiv="X-UA-Compatible" content="chrome=1"/>
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1" />

  <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-180x180.png">
  <link rel="icon" type="image/png" href="/favicon-32x32.png" sizes="32x32">
  <link rel="icon" type="image/png" href="/android-chrome-192x192.png" sizes="192x192">
  <link rel="icon" type="image/png" href="/favicon-96x96.png" sizes="96x96">
  <link rel="icon" type="image/png" href="/favicon-16x16.png" sizes="16x16">
  <link rel="canonical" href="https://kedaoi.cnuser/11001">  <meta name="theme-color" content="#56758f">
    <meta property="og:site_name" content="可达信奥" />
  <meta property="og:title" content="可达信奥 - 王煜喆 - 用户 - 可达信奥" />
  <meta property="og:url" content="https://kedaoi.cnuser/11001" />
  <meta property="og:image" content="/favicon-96x96.png" />
    <title>可达信奥 - 王煜喆 - 用户 - 可达信奥</title>
  <style>
    body {
      --font-family: "Open Sans", "Open Sans", "Seravek", "Segoe UI", "Verdana", "PingFang SC", "Hiragino Sans GB", "Lantinghei SC", "Microsoft Yahei", "WenQuanYi Micro Hei", "sans";
      --code-font-family: "Source Code Pro", "monaco", "Source Code Pro", "Consolas", "Lucida Console", "monospace";
      --font-ligatures: none !important;
    }
          #panel { display: flex; flex-direction: column; }
      </style>
      <link rel="stylesheet" media="all" href="/theme-4.54.1.css">
        <script>
      var _htmlNode = document.documentElement;
      _htmlNode.className = _htmlNode.className.replace(' nojs', ' hasjs');
      var UiContext = '{"cdn_prefix":"/","url_prefix":"/","ws_prefix":"/","onlyofficeApi":"https://documentserver/web-apps/apps/api/documents/api.js","constantVersion":"a7642cc1","domainId":"system","domain":{"_id":"system","lower":"system","owner":1,"name":"\u53EF\u8FBE","bulletin":"# \u53EF\u8FBE\u4FE1\u5965OJ\\r\\n\\r\\n# Welcome to KEDA!\\r\\n\\r\\n## Talk is cheap\uFF0C show me the code\\r\\n\\r\\n# [\u3010\u5FC5\u8BFB\u7CFB\u5217\u3011\u53EF\u8FBE\u5B89\u5168\u98DF\u7528\u6307\u5357\\\\[2023-06-28\u66F4\u65B0\\\\]](https://kedaoi.cn/blog/2/6302f9d4cc2e2304c1161acf)\\r\\n\\r\\n\x3C!-- # [\u3010\u590D\u8D5B\u5FC5\u770B\u3011NOI Linux \u865A\u62DF\u673A\u73AF\u5883\u642D\u5EFA\u30102023/09/29 \u66F4\u65B0\u3011](https://kedaoi.cn/discuss/64e82e4c03332fe07bf6da49) -->\\r\\n\\r\\n---\\r\\n\\r\\n## [2024\u6691\u5047\u96C6\u8BAD\u4E13\u5C5E\u57DF](https://kedaoi.cn/d/SummerCamp24/)\\r\\n\\r\\n---\\r\\n\\r\\n# [\u53EF\u8FBE\u4FE1\u5965 \u5E97\u94FA](https://appnheqdvw18818.h5.xiaoeknow.com)\\r\\n\\r\\n<a href=\\"https://appnheqdvw18818.h5.xiaoeknow.com/p/course/big_column/p_640ec84fe4b07b05583bc813\\" target=\\"_blank\\">L1 C++ \u96F6\u57FA\u7840\u8BAD\u7EC3\u8425\uFF08\u5347\u7EA7\u7248\uFF09</a>\\r\\n\\r\\n<a href=\\"https://appnheqdvw18818.h5.xiaoeknow.com/p/course/column/p_64464cede4b0f2aa7de1131d\\" target=\\"_blank\\">C++ CSP-J\u7B97\u6CD5\u4E2D\u6570\u5B66\uFF08\u5347\u7EA7\u7248\uFF09</a>\\r\\n\\r\\n<a href=\\"https://appnheqdvw18818.h5.xiaoeknow.com/p/course/big_column/p_654cbadee4b023c044fa6f74\\" target=\\"_blank\\">L2 C++\u8FDB\u9636\u4E0E\u57FA\u7840\u7B97\u6CD5\uFF08\u5347\u7EA7\u7248\uFF09</a>\\r\\n\\r\\n<a href=\\"https://appnheqdvw18818.pc.xiaoe-tech.com/p/t_pc/goods_pc_detail/goods_detail/p_6663126be4b0694c6ed35334\\" target=\\"_blank\\">L3 CSP-J\u7B97\u6CD5\u4E0E\u6570\u636E\u7ED3\u6784\uFF08\u5347\u7EA7\u7248\uFF09</a>\\r\\n\\r\\n<a href=\\"https://appnheqdvw18818.h5.xiaoeknow.com/p/course/column/p_66333810e4b0694c62c0563c\\" target=\\"_blank\\">CSP\u521D\u8D5B\u9AD8\u5206\u664B\u7EA7\u5305</a>\\r\\n\\r\\n---\\r\\n\\r\\n\x3C!-- <a href=\\"https://ovp.h5.xeknow.com/s/YrhIH\\" target=\\"_blank\\">CSP-J\u521D\u8D5B\u771F\u9898\u5206\u7C7B\u89E3\u6790</a> -->\\r\\n\\r\\n# [1. \u8F6F\u4EF6\u5B89\u88C5\u6559\u7A0B](https://kedaoi.cn/blog/2/62996a560c458b5395443b93)\\r\\n\\r\\n\x3C!--(/app.html)-->\\r\\n\\r\\n# 2. \u5E38\u7528\u8F6F\u4EF6\u4E0B\u8F7D\\r\\n\\r\\n- <a href=\\"http://www.google.cn/chrome?standalone=1&platform=win64\\" target=\\"_blank\\">\u8C37\u6B4C\u6D4F\u89C8\u5668(\u5F3A\u70C8\u63A8\u8350\u4F7F\u7528\u8C37\u6B4C\u6D4F\u89C8\u5668)</a>\\r\\n- <a href=\\"https://weixin.qq.com/\\" target=\\"_blank\\">\u5FAE\u4FE1 \u7535\u8111\u7248</a>\\r\\n- <a href=\\"/blog/2/6489b2c005bbdef3085fdad5\\" target=\\"_blank\\">Typora</a>\\r\\n\\r\\n\x3C!--\\r\\n\\r\\n## [\u952E\u76D8\u9F20\u6807\u63A8\u8350](https://kedaoi.cn/discuss/62bbd999e60fbe6529f36e1b)\\r\\n\\r\\n-->\\r\\n\\r\\n","roles":{"root":"-1","teacher":"10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831654836843204374400333813","guest":"10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831653804978457923079372801","default":"10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831653847145773401649578625","\u8001\u5E08":"10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831653923729372724703524853","\u7981\u8A00":"10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831653842534087366042190465","mod":"10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831653921223953154568872661","\u5B66\u751F":"10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831653847145773401653838465","\u5916\u90E8\u5B66\u751F":"10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831653847145773401649578625"},"avatar":"url:https://q1.qlogo.cn/g?b=qq&nk=491237847&s=160","langs":"c,cc.std98,cc.std11,cc.std17,codeforces.50,codeforces.54,py3,cc.std14,cc,codeforces","share":"*"},"extraTitleContent":"\u738B\u715C\u5586","SWConfig":{"preload":"","hosts":["http://kedaoi.cn","https://kedaoi.cn","https://kedaoi.cn","/"],"assets":[],"domains":[]}}';
      var UserContext = '{"_id":9760,"mail":"6362706@qq.com","uname":"\u7A0B\u5B50\u7693","hashType":"hydro","priv":65540,"regat":"2024-05-01T05:16:04.176Z","loginat":"2024-08-02T04:01:46.021Z","perm":"BigInt::10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831653842534087366042190465","role":"\u7981\u8A00","scope":"BigInt::-1","tfa":false,"authn":false,"group":["9760"],"domains":[],"viewLang":"zh","timeZone":"Asia/Shanghai","codeLang":"cc.std14","codeTemplate":"#include<bits/stdc++.h>\\r\\nusing namespace std;\\r\\nint main(){\\r\\n    \\r\\n    return 0;\\r\\n}","avatar":"gravatar:6362706@qq.com","qq":"","gender":"0","bio":"```\\r\\n\\"AC=Answer Coarse=\u7C97\u52A3\u7684\u7B54\u6848\\"\\r\\n\\"WA=Wonderful Answer=\u597D\u7B54\u6848\\"\\r\\n\\"TLE=Time Limit Enough=\u65F6\u95F4\u5145\u88D5\\"\\r\\n\\"MLE=Memory Limit Enough=\u5185\u5B58\u5145\u88D5\\"\\r\\n\\"CE=Compile Easily=\u8F7B\u677E\u901A\u8FC7\u7F16\u8BD1\\"\\r\\n\\"RE=Run Excellently=\u5B8C\u7F8E\u8FD0\u884C\\"\\r\\n\\"UKE=Unbelievably Keep Enough Score=\u96BE\u4EE5\u7F6E\u4FE1\u5730\u4FDD\u6301\u8DB3\u591F\u7684\u5206\u6570\\"\\r\\n```\\r\\n\\r\\nAC\u53EA\u80FD\u5F97\u4F4E\u5206\uFF01\\r\\n\\r\\n\u5343\u4E07\u522BAC\\r\\n\\r\\n\u6240\u4EE5\uFF1A\\r\\n\\r\\nfile:///C:/Users/86177/Downloads/yu5SdbBaPDTiiWo9gEjR1%20(5).png\\r\\n\\r\\n\u628A\u5982\u4E0A\u6587\u4EF6\u5168\u9009\u540E\u62D6\u52A8\u653E\u8FDB\u6700\u4E0A\u9762\u53EF\u4EE5\u653E\u5165\u7684\u5730\u65B9\u6309\u4E00\u4E0Benter\u6709\u795D\u798F\u54E6\uFF01\\r\\n\\r\\n\u731C\u731C\u56FE\u7247\u5728\u90A3\u4E2A\u9898\\r\\nhttps://kedaoi.cn/p/1041/file/xigViBgJSApza_8nB2klp.png\\r\\n\u8FDB\u53BB\u8BD5\u8BD5 \u4F60\u80FD\u51E0\u547D\u8FC7\u5173\\r\\nhttps://poki.com/zh/g/level-devil\\r\\n\\r\\n0 Time Exceeded P0001 A+B Problem \u7A0B\u5B50\u7693 \u22656586ms \u2265392 KiB C++14 2 \u5206\u949F\u524D\\r\\n\\r\\n\u6218\u7EE9\u53EF\u67E5\uFF01\uFF01\uFF01\uFF01\\r\\n\\r\\n\u4EE3\u7801\u5982\u4E0B\\r\\n\\r\\n```\\r\\n#include<iostream>\\r\\n#include<cstring>\\r\\n#include<cstdio>\\r\\n#include<cstring>\\r\\nusing namespace std;\\r\\nstruct node \\r\\n{\\r\\n    long long data,rev,sum, pig = 101;\\r\\n    node *son[2],*pre;\\r\\n    bool judge();\\r\\n    bool isroot();\\r\\n    void pushdown();\\r\\n    void update();\\r\\n    void setson(node *child,int lr);\\r\\n}lct[233];\\r\\nint top,a,b;\\r\\nnode *getnew(int x)\\r\\n{\\r\\n    node *now=lct+ ++top;\\r\\n    now->data=x;\\r\\n    now->pre=now->son[1]=now->son[0]=lct;\\r\\n    now->sum=0;\\r\\n    now->rev=0;\\r\\n    return now;\\r\\n}\\r\\nbool node::judge(){return pre->son[1]==this;}\\r\\nbool node::isroot()\\r\\n{\\r\\n    if(pre==lct)return true;\\r\\n    return !(pre->son[1]==this||pre->son[0]==this);\\r\\n}\\r\\nvoid node::pushdown()\\r\\n{\\r\\n    if(this==lct||!rev)return;\\r\\n    swap(son[0],son[1]);\\r\\n    son[0]->rev^=1;\\r\\n    son[1]->rev^=1;\\r\\n    rev=0;\\r\\n}\\r\\nvoid node::update(){sum=son[1]->sum+son[0]->sum+data;}\\r\\nvoid node::setson(node *child,int lr)\\r\\n{\\r\\n    this->pushdown();\\r\\n    child->pre=this;\\r\\n    son[lr]=child;\\r\\n    this->update();\\r\\n}\\r\\nvoid rotate(node *now)\\r\\n{\\r\\n    node *father=now->pre,*grandfa=father->pre;\\r\\n    if(!father->isroot()) grandfa->pushdown();\\r\\n    father->pushdown();now->pushdown();\\r\\n    int lr=now->judge();\\r\\n    father->setson(now->son[lr^1],lr);\\r\\n    if(father->isroot()) now->pre=grandfa;\\r\\n    else grandfa->setson(now,father->judge());\\r\\n    now->setson(father,lr^1);\\r\\n    father->update();now->update();\\r\\n    if(grandfa!=lct) grandfa->update();\\r\\n}\\r\\nvoid splay(node *now)\\r\\n{\\r\\n    if(now->isroot())return;\\r\\n    for(;!now->isroot();rotate(now))\\r\\n    if(!now->pre->isroot())\\r\\n    now->judge()==now->pre->judge()?rotate(now->pre):rotate(now);\\r\\n}\\r\\nnode *access(node *now)\\r\\n{\\r\\n    node *last=lct;\\r\\n    for(;now!=lct;last=now,now=now->pre)\\r\\n    {\\r\\n        splay(now);\\r\\n        now->setson(last,1);\\r\\n    }\\r\\n    return last;\\r\\n}\\r\\nvoid changeroot(node *now)\\r\\n{\\r\\n    access(now)->rev^=1;\\r\\n    splay(now);\\r\\n}\\r\\nvoid connect(node *x,node *y)\\r\\n{\\r\\n    changeroot(x);\\r\\n    x->pre=y;\\r\\n    access(x);\\r\\n}\\r\\nvoid cut(node *x,node *y)\\r\\n{\\r\\n    changeroot(x);\\r\\n    access(y);\\r\\n    splay(x);\\r\\n    x->pushdown();\\r\\n    x->son[1]=y->pre=lct;\\r\\n    x->update();\\r\\n}\\r\\nint query(node *x,node *y)\\r\\n{\\r\\n    changeroot(x);\\r\\n    node *now=access(y);\\r\\n    return now->sum;\\r\\n}\\r\\nint main()\\r\\n{\\r\\n    scanf(\\"%d%d\\",&a,&b);\\r\\n    node *A=getnew(a);\\r\\n    node *B=getnew(b);\\r\\n        connect(A,B);\\r\\n        cut(A,B);\\r\\n        connect(A,B);\\r\\n    for(int i = 1; i <= 1000000000001; i++){\\r\\n    \\ti -= 1;\\r\\n\\t}\\r\\n    printf(\\"%d\\\\n\\",query(A,B)); \\r\\n    return 0;\\r\\n}\\r\\n```\\r\\n0 Runtime Error\\r\\nP1763  \u81EA\u5DF1\u5B9E\u73B0\u51FD\u6570\u2014min()\\t\u7A0B\u5B50\u7693\\t10ms\\t416 KiB\\tC++ 14\\t3 \u5206\u949F\u524D\\r\\n\u6211\u662F\u7B2C\u4E00\u4E2ARE\u7684\uFF01\\r\\n\u4EE3\u7801\u5982\u4E0B:\\r\\n```\\r\\n#include<bits/stdc++.h>\\r\\nusing namespace std;\\r\\nint main(){\\r\\n\\tint n = 1;\\r\\n\\tint s = 1/0;\\r\\n\\tcout << s;\\r\\n\\treturn 0;\\t\\r\\n}\\r\\n```\\r\\n\u6709\u8C01\u77E5\u9053\u4E3A\u4EC0\u4E48\u7F16\u8BD1\u4F1A\u51FA\u73B0\u8FD9\u4E2A\u554A\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\uFF1F\\r\\n\\r\\n```\\r\\n// Core algorithmic facilities -*- C++ -*-\\r\\n\\r\\n// Copyright (C) 2001-2014 Free Software Foundation, Inc.\\r\\n//\\r\\n// This file is part of the GNU ISO C++ Library.  This library is free\\r\\n// software; you can redistribute it and/or modify it under the\\r\\n// terms of the GNU General Public License as published by the\\r\\n// Free Software Foundation; either version 3, or (at your option)\\r\\n// any later version.\\r\\n\\r\\n// This library is distributed in the hope that it will be useful,\\r\\n// but WITHOUT ANY WARRANTY; without even the implied warranty of\\r\\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\\r\\n// GNU General Public License for more details.\\r\\n\\r\\n// Under Section 7 of GPL version 3, you are granted additional\\r\\n// permissions described in the GCC Runtime Library Exception, version\\r\\n// 3.1, as published by the Free Software Foundation.\\r\\n\\r\\n// You should have received a copy of the GNU General Public License and\\r\\n// a copy of the GCC Runtime Library Exception along with this program;\\r\\n// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see\\r\\n// <http://www.gnu.org/licenses/>.\\r\\n\\r\\n/*\\r\\n *\\r\\n * Copyright (c) 1994\\r\\n * Hewlett-Packard Company\\r\\n *\\r\\n * Permission to use, copy, modify, distribute and sell this software\\r\\n * and its documentation for any purpose is hereby granted without fee,\\r\\n * provided that the above copyright notice appear in all copies and\\r\\n * that both that copyright notice and this permission notice appear\\r\\n * in supporting documentation.  Hewlett-Packard Company makes no\\r\\n * representations about the suitability of this software for any\\r\\n * purpose.  It is provided \\"as is\\" without express or implied warranty.\\r\\n *\\r\\n *\\r\\n * Copyright (c) 1996-1998\\r\\n * Silicon Graphics Computer Systems, Inc.\\r\\n *\\r\\n * Permission to use, copy, modify, distribute and sell this software\\r\\n * and its documentation for any purpose is hereby granted without fee,\\r\\n * provided that the above copyright notice appear in all copies and\\r\\n * that both that copyright notice and this permission notice appear\\r\\n * in supporting documentation.  Silicon Graphics makes no\\r\\n * representations about the suitability of this software for any\\r\\n * purpose.  It is provided \\"as is\\" without express or implied warranty.\\r\\n */\\r\\n\\r\\n/** @file bits/stl_algobase.h\\r\\n *  This is an internal header file, included by other library headers.\\r\\n *  Do not attempt to use it directly. @headername{algorithm}\\r\\n */\\r\\n\\r\\n#ifndef _STL_ALGOBASE_H\\r\\n#define _STL_ALGOBASE_H 1\\r\\n\\r\\n#include <bits/c++config.h>\\r\\n#include <bits/functexcept.h>\\r\\n#include <bits/cpp_type_traits.h>\\r\\n#include <ext/type_traits.h>\\r\\n#include <ext/numeric_traits.h>\\r\\n#include <bits/stl_pair.h>\\r\\n#include <bits/stl_iterator_base_types.h>\\r\\n#include <bits/stl_iterator_base_funcs.h>\\r\\n#include <bits/stl_iterator.h>\\r\\n#include <bits/concept_check.h>\\r\\n#include <debug/debug.h>\\r\\n#include <bits/move.h> // For std::swap and _GLIBCXX_MOVE\\r\\n#include <bits/predefined_ops.h>\\r\\n\\r\\nnamespace std _GLIBCXX_VISIBILITY(default)\\r\\n{\\r\\n_GLIBCXX_BEGIN_NAMESPACE_VERSION\\r\\n\\r\\n#if __cplusplus < 201103L\\r\\n  // See http://gcc.gnu.org/ml/libstdc++/2004-08/msg00167.html: in a\\r\\n  // nutshell, we are partially implementing the resolution of DR 187,\\r\\n  // when it\'s safe, i.e., the value_types are equal.\\r\\n  template<bool _BoolType>\\r\\n    struct __iter_swap\\r\\n    {\\r\\n      template<typename _ForwardIterator1, typename _ForwardIterator2>\\r\\n        static void\\r\\n        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)\\r\\n        {\\r\\n          typedef typename iterator_traits<_ForwardIterator1>::value_type\\r\\n            _ValueType1;\\r\\n          _ValueType1 __tmp = _GLIBCXX_MOVE(*__a);\\r\\n          *__a = _GLIBCXX_MOVE(*__b);\\r\\n          *__b = _GLIBCXX_MOVE(__tmp);\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n  template<>\\r\\n    struct __iter_swap<true>\\r\\n    {\\r\\n      template<typename _ForwardIterator1, typename _ForwardIterator2>\\r\\n        static void \\r\\n        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)\\r\\n        {\\r\\n          swap(*__a, *__b);\\r\\n        }\\r\\n    };\\r\\n#endif\\r\\n\\r\\n  /**\\r\\n   *  @brief Swaps the contents of two iterators.\\r\\n   *  @ingroup mutating_algorithms\\r\\n   *  @param  __a  An iterator.\\r\\n   *  @param  __b  Another iterator.\\r\\n   *  @return   Nothing.\\r\\n   *\\r\\n   *  This function swaps the values pointed to by two iterators, not the\\r\\n   *  iterators themselves.\\r\\n  */\\r\\n  template<typename _ForwardIterator1, typename _ForwardIterator2>\\r\\n    inline void\\r\\n    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<\\r\\n\\t\\t\\t\\t  _ForwardIterator1>)\\r\\n      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<\\r\\n\\t\\t\\t\\t  _ForwardIterator2>)\\r\\n\\r\\n#if __cplusplus < 201103L\\r\\n      typedef typename iterator_traits<_ForwardIterator1>::value_type\\r\\n\\t_ValueType1;\\r\\n      typedef typename iterator_traits<_ForwardIterator2>::value_type\\r\\n\\t_ValueType2;\\r\\n\\r\\n      __glibcxx_function_requires(_ConvertibleConcept<_ValueType1,\\r\\n\\t\\t\\t\\t  _ValueType2>)\\r\\n      __glibcxx_function_requires(_ConvertibleConcept<_ValueType2,\\r\\n\\t\\t\\t\\t  _ValueType1>)\\r\\n\\r\\n      typedef typename iterator_traits<_ForwardIterator1>::reference\\r\\n\\t_ReferenceType1;\\r\\n      typedef typename iterator_traits<_ForwardIterator2>::reference\\r\\n\\t_ReferenceType2;\\r\\n      std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value\\r\\n\\t&& __are_same<_ValueType1&, _ReferenceType1>::__value\\r\\n\\t&& __are_same<_ValueType2&, _ReferenceType2>::__value>::\\r\\n\\titer_swap(__a, __b);\\r\\n#else\\r\\n      swap(*__a, *__b);\\r\\n#endif\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Swap the elements of two sequences.\\r\\n   *  @ingroup mutating_algorithms\\r\\n   *  @param  __first1  A forward iterator.\\r\\n   *  @param  __last1   A forward iterator.\\r\\n   *  @param  __first2  A forward iterator.\\r\\n   *  @return   An iterator equal to @p first2+(last1-first1).\\r\\n   *\\r\\n   *  Swaps each element in the range @p [first1,last1) with the\\r\\n   *  corresponding element in the range @p [first2,(last1-first1)).\\r\\n   *  The ranges must not overlap.\\r\\n  */\\r\\n  template<typename _ForwardIterator1, typename _ForwardIterator2>\\r\\n    _ForwardIterator2\\r\\n    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,\\r\\n\\t\\t_ForwardIterator2 __first2)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<\\r\\n\\t\\t\\t\\t  _ForwardIterator1>)\\r\\n      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<\\r\\n\\t\\t\\t\\t  _ForwardIterator2>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n\\r\\n      for (; __first1 != __last1; ++__first1, ++__first2)\\r\\n\\tstd::iter_swap(__first1, __first2);\\r\\n      return __first2;\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief This does what you think it does.\\r\\n   *  @ingroup sorting_algorithms\\r\\n   *  @param  __a  A thing of arbitrary type.\\r\\n   *  @param  __b  Another thing of arbitrary type.\\r\\n   *  @return   The lesser of the parameters.\\r\\n   *\\r\\n   *  This is the simple classic generic implementation.  It will work on\\r\\n   *  temporary expressions, since they are only evaluated once, unlike a\\r\\n   *  preprocessor macro.\\r\\n  */\\r\\n  template<typename _Tp>\\r\\n    inline const _Tp&\\r\\n    min(const _Tp& __a, const _Tp& __b)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)\\r\\n      //return __b < __a ? __b : __a;\\r\\n      if (__b < __a)\\r\\n\\treturn __b;\\r\\n      return __a;\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief This does what you think it does.\\r\\n   *  @ingroup sorting_algorithms\\r\\n   *  @param  __a  A thing of arbitrary type.\\r\\n   *  @param  __b  Another thing of arbitrary type.\\r\\n   *  @return   The greater of the parameters.\\r\\n   *\\r\\n   *  This is the simple classic generic implementation.  It will work on\\r\\n   *  temporary expressions, since they are only evaluated once, unlike a\\r\\n   *  preprocessor macro.\\r\\n  */\\r\\n  template<typename _Tp>\\r\\n    inline const _Tp&\\r\\n    max(const _Tp& __a, const _Tp& __b)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_LessThanComparableConcept<_Tp>)\\r\\n      //return  __a < __b ? __b : __a;\\r\\n      if (__a < __b)\\r\\n\\treturn __b;\\r\\n      return __a;\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief This does what you think it does.\\r\\n   *  @ingroup sorting_algorithms\\r\\n   *  @param  __a  A thing of arbitrary type.\\r\\n   *  @param  __b  Another thing of arbitrary type.\\r\\n   *  @param  __comp  A @link comparison_functors comparison functor@endlink.\\r\\n   *  @return   The lesser of the parameters.\\r\\n   *\\r\\n   *  This will work on temporary expressions, since they are only evaluated\\r\\n   *  once, unlike a preprocessor macro.\\r\\n  */\\r\\n  template<typename _Tp, typename _Compare>\\r\\n    inline const _Tp&\\r\\n    min(const _Tp& __a, const _Tp& __b, _Compare __comp)\\r\\n    {\\r\\n      //return __comp(__b, __a) ? __b : __a;\\r\\n      if (__comp(__b, __a))\\r\\n\\treturn __b;\\r\\n      return __a;\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief This does what you think it does.\\r\\n   *  @ingroup sorting_algorithms\\r\\n   *  @param  __a  A thing of arbitrary type.\\r\\n   *  @param  __b  Another thing of arbitrary type.\\r\\n   *  @param  __comp  A @link comparison_functors comparison functor@endlink.\\r\\n   *  @return   The greater of the parameters.\\r\\n   *\\r\\n   *  This will work on temporary expressions, since they are only evaluated\\r\\n   *  once, unlike a preprocessor macro.\\r\\n  */\\r\\n  template<typename _Tp, typename _Compare>\\r\\n    inline const _Tp&\\r\\n    max(const _Tp& __a, const _Tp& __b, _Compare __comp)\\r\\n    {\\r\\n      //return __comp(__a, __b) ? __b : __a;\\r\\n      if (__comp(__a, __b))\\r\\n\\treturn __b;\\r\\n      return __a;\\r\\n    }\\r\\n\\r\\n  // If _Iterator is a __normal_iterator return its base (a plain pointer,\\r\\n  // normally) otherwise return it untouched.  See copy, fill, ... \\r\\n  template<typename _Iterator>\\r\\n    struct _Niter_base\\r\\n    : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>\\r\\n    { };\\r\\n\\r\\n  template<typename _Iterator>\\r\\n    inline typename _Niter_base<_Iterator>::iterator_type\\r\\n    __niter_base(_Iterator __it)\\r\\n    { return std::_Niter_base<_Iterator>::_S_base(__it); }\\r\\n\\r\\n  // Likewise, for move_iterator.\\r\\n  template<typename _Iterator>\\r\\n    struct _Miter_base\\r\\n    : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>\\r\\n    { };\\r\\n\\r\\n  template<typename _Iterator>\\r\\n    inline typename _Miter_base<_Iterator>::iterator_type\\r\\n    __miter_base(_Iterator __it)\\r\\n    { return std::_Miter_base<_Iterator>::_S_base(__it); }\\r\\n\\r\\n  // All of these auxiliary structs serve two purposes.  (1) Replace\\r\\n  // calls to copy with memmove whenever possible.  (Memmove, not memcpy,\\r\\n  // because the input and output ranges are permitted to overlap.)\\r\\n  // (2) If we\'re using random access iterators, then write the loop as\\r\\n  // a for loop with an explicit count.\\r\\n\\r\\n  template<bool, bool, typename>\\r\\n    struct __copy_move\\r\\n    {\\r\\n      template<typename _II, typename _OI>\\r\\n        static _OI\\r\\n        __copy_m(_II __first, _II __last, _OI __result)\\r\\n        {\\r\\n\\t  for (; __first != __last; ++__result, ++__first)\\r\\n\\t    *__result = *__first;\\r\\n\\t  return __result;\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n#if __cplusplus >= 201103L\\r\\n  template<typename _Category>\\r\\n    struct __copy_move<true, false, _Category>\\r\\n    {\\r\\n      template<typename _II, typename _OI>\\r\\n        static _OI\\r\\n        __copy_m(_II __first, _II __last, _OI __result)\\r\\n        {\\r\\n\\t  for (; __first != __last; ++__result, ++__first)\\r\\n\\t    *__result = std::move(*__first);\\r\\n\\t  return __result;\\r\\n\\t}\\r\\n    };\\r\\n#endif\\r\\n\\r\\n  template<>\\r\\n    struct __copy_move<false, false, random_access_iterator_tag>\\r\\n    {\\r\\n      template<typename _II, typename _OI>\\r\\n        static _OI\\r\\n        __copy_m(_II __first, _II __last, _OI __result)\\r\\n        { \\r\\n\\t  typedef typename iterator_traits<_II>::difference_type _Distance;\\r\\n\\t  for(_Distance __n = __last - __first; __n > 0; --__n)\\r\\n\\t    {\\r\\n\\t      *__result = *__first;\\r\\n\\t      ++__first;\\r\\n\\t      ++__result;\\r\\n\\t    }\\r\\n\\t  return __result;\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n#if __cplusplus >= 201103L\\r\\n  template<>\\r\\n    struct __copy_move<true, false, random_access_iterator_tag>\\r\\n    {\\r\\n      template<typename _II, typename _OI>\\r\\n        static _OI\\r\\n        __copy_m(_II __first, _II __last, _OI __result)\\r\\n        { \\r\\n\\t  typedef typename iterator_traits<_II>::difference_type _Distance;\\r\\n\\t  for(_Distance __n = __last - __first; __n > 0; --__n)\\r\\n\\t    {\\r\\n\\t      *__result = std::move(*__first);\\r\\n\\t      ++__first;\\r\\n\\t      ++__result;\\r\\n\\t    }\\r\\n\\t  return __result;\\r\\n\\t}\\r\\n    };\\r\\n#endif\\r\\n\\r\\n  template<bool _IsMove>\\r\\n    struct __copy_move<_IsMove, true, random_access_iterator_tag>\\r\\n    {\\r\\n      template<typename _Tp>\\r\\n        static _Tp*\\r\\n        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)\\r\\n        {\\r\\n#if __cplusplus >= 201103L\\r\\n\\t  // trivial types can have deleted assignment\\r\\n\\t  static_assert( is_copy_assignable<_Tp>::value,\\r\\n\\t                 \\"type is not assignable\\" );\\r\\n#endif\\r\\n\\t  const ptrdiff_t _Num = __last - __first;\\r\\n\\t  if (_Num)\\r\\n\\t    __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);\\r\\n\\t  return __result + _Num;\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n  template<bool _IsMove, typename _II, typename _OI>\\r\\n    inline _OI\\r\\n    __copy_move_a(_II __first, _II __last, _OI __result)\\r\\n    {\\r\\n      typedef typename iterator_traits<_II>::value_type _ValueTypeI;\\r\\n      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;\\r\\n      typedef typename iterator_traits<_II>::iterator_category _Category;\\r\\n      const bool __simple = (__is_trivial(_ValueTypeI)\\r\\n\\t                     && __is_pointer<_II>::__value\\r\\n\\t                     && __is_pointer<_OI>::__value\\r\\n\\t\\t\\t     && __are_same<_ValueTypeI, _ValueTypeO>::__value);\\r\\n\\r\\n      return std::__copy_move<_IsMove, __simple,\\r\\n\\t                      _Category>::__copy_m(__first, __last, __result);\\r\\n    }\\r\\n\\r\\n  // Helpers for streambuf iterators (either istream or ostream).\\r\\n  // NB: avoid including <iosfwd>, relatively large.\\r\\n  template<typename _CharT>\\r\\n    struct char_traits;\\r\\n\\r\\n  template<typename _CharT, typename _Traits>\\r\\n    class istreambuf_iterator;\\r\\n\\r\\n  template<typename _CharT, typename _Traits>\\r\\n    class ostreambuf_iterator;\\r\\n\\r\\n  template<bool _IsMove, typename _CharT>\\r\\n    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, \\r\\n\\t     ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type\\r\\n    __copy_move_a2(_CharT*, _CharT*,\\r\\n\\t\\t   ostreambuf_iterator<_CharT, char_traits<_CharT> >);\\r\\n\\r\\n  template<bool _IsMove, typename _CharT>\\r\\n    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, \\r\\n\\t     ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type\\r\\n    __copy_move_a2(const _CharT*, const _CharT*,\\r\\n\\t\\t   ostreambuf_iterator<_CharT, char_traits<_CharT> >);\\r\\n\\r\\n  template<bool _IsMove, typename _CharT>\\r\\n    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,\\r\\n\\t\\t\\t\\t    _CharT*>::__type\\r\\n    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,\\r\\n\\t\\t   istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);\\r\\n\\r\\n  template<bool _IsMove, typename _II, typename _OI>\\r\\n    inline _OI\\r\\n    __copy_move_a2(_II __first, _II __last, _OI __result)\\r\\n    {\\r\\n      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),\\r\\n\\t\\t\\t\\t\\t     std::__niter_base(__last),\\r\\n\\t\\t\\t\\t\\t     std::__niter_base(__result)));\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Copies the range [first,last) into result.\\r\\n   *  @ingroup mutating_algorithms\\r\\n   *  @param  __first  An input iterator.\\r\\n   *  @param  __last   An input iterator.\\r\\n   *  @param  __result An output iterator.\\r\\n   *  @return   result + (first - last)\\r\\n   *\\r\\n   *  This inline function will boil down to a call to @c memmove whenever\\r\\n   *  possible.  Failing that, if random access iterators are passed, then the\\r\\n   *  loop count will be known (and therefore a candidate for compiler\\r\\n   *  optimizations such as unrolling).  Result may not be contained within\\r\\n   *  [first,last); the copy_backward function should be used instead.\\r\\n   *\\r\\n   *  Note that the end of the output range is permitted to be contained\\r\\n   *  within [first,last).\\r\\n  */\\r\\n  template<typename _II, typename _OI>\\r\\n    inline _OI\\r\\n    copy(_II __first, _II __last, _OI __result)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II>)\\r\\n      __glibcxx_function_requires(_OutputIteratorConcept<_OI,\\r\\n\\t    typename iterator_traits<_II>::value_type>)\\r\\n      __glibcxx_requires_valid_range(__first, __last);\\r\\n\\r\\n      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>\\r\\n\\t      (std::__miter_base(__first), std::__miter_base(__last),\\r\\n\\t       __result));\\r\\n    }\\r\\n\\r\\n#if __cplusplus >= 201103L\\r\\n  /**\\r\\n   *  @brief Moves the range [first,last) into result.\\r\\n   *  @ingroup mutating_algorithms\\r\\n   *  @param  __first  An input iterator.\\r\\n   *  @param  __last   An input iterator.\\r\\n   *  @param  __result An output iterator.\\r\\n   *  @return   result + (first - last)\\r\\n   *\\r\\n   *  This inline function will boil down to a call to @c memmove whenever\\r\\n   *  possible.  Failing that, if random access iterators are passed, then the\\r\\n   *  loop count will be known (and therefore a candidate for compiler\\r\\n   *  optimizations such as unrolling).  Result may not be contained within\\r\\n   *  [first,last); the move_backward function should be used instead.\\r\\n   *\\r\\n   *  Note that the end of the output range is permitted to be contained\\r\\n   *  within [first,last).\\r\\n  */\\r\\n  template<typename _II, typename _OI>\\r\\n    inline _OI\\r\\n    move(_II __first, _II __last, _OI __result)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II>)\\r\\n      __glibcxx_function_requires(_OutputIteratorConcept<_OI,\\r\\n\\t    typename iterator_traits<_II>::value_type>)\\r\\n      __glibcxx_requires_valid_range(__first, __last);\\r\\n\\r\\n      return std::__copy_move_a2<true>(std::__miter_base(__first),\\r\\n\\t\\t\\t\\t       std::__miter_base(__last), __result);\\r\\n    }\\r\\n\\r\\n#define _GLIBCXX_MOVE3(_Tp, _Up, _Vp) std::move(_Tp, _Up, _Vp)\\r\\n#else\\r\\n#define _GLIBCXX_MOVE3(_Tp, _Up, _Vp) std::copy(_Tp, _Up, _Vp)\\r\\n#endif\\r\\n\\r\\n  template<bool, bool, typename>\\r\\n    struct __copy_move_backward\\r\\n    {\\r\\n      template<typename _BI1, typename _BI2>\\r\\n        static _BI2\\r\\n        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)\\r\\n        {\\r\\n\\t  while (__first != __last)\\r\\n\\t    *--__result = *--__last;\\r\\n\\t  return __result;\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n#if __cplusplus >= 201103L\\r\\n  template<typename _Category>\\r\\n    struct __copy_move_backward<true, false, _Category>\\r\\n    {\\r\\n      template<typename _BI1, typename _BI2>\\r\\n        static _BI2\\r\\n        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)\\r\\n        {\\r\\n\\t  while (__first != __last)\\r\\n\\t    *--__result = std::move(*--__last);\\r\\n\\t  return __result;\\r\\n\\t}\\r\\n    };\\r\\n#endif\\r\\n\\r\\n  template<>\\r\\n    struct __copy_move_backward<false, false, random_access_iterator_tag>\\r\\n    {\\r\\n      template<typename _BI1, typename _BI2>\\r\\n        static _BI2\\r\\n        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)\\r\\n        {\\r\\n\\t  typename iterator_traits<_BI1>::difference_type __n;\\r\\n\\t  for (__n = __last - __first; __n > 0; --__n)\\r\\n\\t    *--__result = *--__last;\\r\\n\\t  return __result;\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n#if __cplusplus >= 201103L\\r\\n  template<>\\r\\n    struct __copy_move_backward<true, false, random_access_iterator_tag>\\r\\n    {\\r\\n      template<typename _BI1, typename _BI2>\\r\\n        static _BI2\\r\\n        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)\\r\\n        {\\r\\n\\t  typename iterator_traits<_BI1>::difference_type __n;\\r\\n\\t  for (__n = __last - __first; __n > 0; --__n)\\r\\n\\t    *--__result = std::move(*--__last);\\r\\n\\t  return __result;\\r\\n\\t}\\r\\n    };\\r\\n#endif\\r\\n\\r\\n  template<bool _IsMove>\\r\\n    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>\\r\\n    {\\r\\n      template<typename _Tp>\\r\\n        static _Tp*\\r\\n        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)\\r\\n        {\\r\\n#if __cplusplus >= 201103L\\r\\n\\t  // trivial types can have deleted assignment\\r\\n\\t  static_assert( is_copy_assignable<_Tp>::value,\\r\\n\\t                 \\"type is not assignable\\" );\\r\\n#endif\\r\\n\\t  const ptrdiff_t _Num = __last - __first;\\r\\n\\t  if (_Num)\\r\\n\\t    __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);\\r\\n\\t  return __result - _Num;\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n  template<bool _IsMove, typename _BI1, typename _BI2>\\r\\n    inline _BI2\\r\\n    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)\\r\\n    {\\r\\n      typedef typename iterator_traits<_BI1>::value_type _ValueType1;\\r\\n      typedef typename iterator_traits<_BI2>::value_type _ValueType2;\\r\\n      typedef typename iterator_traits<_BI1>::iterator_category _Category;\\r\\n      const bool __simple = (__is_trivial(_ValueType1)\\r\\n\\t                     && __is_pointer<_BI1>::__value\\r\\n\\t                     && __is_pointer<_BI2>::__value\\r\\n\\t\\t\\t     && __are_same<_ValueType1, _ValueType2>::__value);\\r\\n\\r\\n      return std::__copy_move_backward<_IsMove, __simple,\\r\\n\\t                               _Category>::__copy_move_b(__first,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t __last,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t __result);\\r\\n    }\\r\\n\\r\\n  template<bool _IsMove, typename _BI1, typename _BI2>\\r\\n    inline _BI2\\r\\n    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)\\r\\n    {\\r\\n      return _BI2(std::__copy_move_backward_a<_IsMove>\\r\\n\\t\\t  (std::__niter_base(__first), std::__niter_base(__last),\\r\\n\\t\\t   std::__niter_base(__result)));\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Copies the range [first,last) into result.\\r\\n   *  @ingroup mutating_algorithms\\r\\n   *  @param  __first  A bidirectional iterator.\\r\\n   *  @param  __last   A bidirectional iterator.\\r\\n   *  @param  __result A bidirectional iterator.\\r\\n   *  @return   result - (first - last)\\r\\n   *\\r\\n   *  The function has the same effect as copy, but starts at the end of the\\r\\n   *  range and works its way to the start, returning the start of the result.\\r\\n   *  This inline function will boil down to a call to @c memmove whenever\\r\\n   *  possible.  Failing that, if random access iterators are passed, then the\\r\\n   *  loop count will be known (and therefore a candidate for compiler\\r\\n   *  optimizations such as unrolling).\\r\\n   *\\r\\n   *  Result may not be in the range (first,last].  Use copy instead.  Note\\r\\n   *  that the start of the output range may overlap [first,last).\\r\\n  */\\r\\n  template<typename _BI1, typename _BI2>\\r\\n    inline _BI2\\r\\n    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>)\\r\\n      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>)\\r\\n      __glibcxx_function_requires(_ConvertibleConcept<\\r\\n\\t    typename iterator_traits<_BI1>::value_type,\\r\\n\\t    typename iterator_traits<_BI2>::value_type>)\\r\\n      __glibcxx_requires_valid_range(__first, __last);\\r\\n\\r\\n      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>\\r\\n\\t      (std::__miter_base(__first), std::__miter_base(__last),\\r\\n\\t       __result));\\r\\n    }\\r\\n\\r\\n#if __cplusplus >= 201103L\\r\\n  /**\\r\\n   *  @brief Moves the range [first,last) into result.\\r\\n   *  @ingroup mutating_algorithms\\r\\n   *  @param  __first  A bidirectional iterator.\\r\\n   *  @param  __last   A bidirectional iterator.\\r\\n   *  @param  __result A bidirectional iterator.\\r\\n   *  @return   result - (first - last)\\r\\n   *\\r\\n   *  The function has the same effect as move, but starts at the end of the\\r\\n   *  range and works its way to the start, returning the start of the result.\\r\\n   *  This inline function will boil down to a call to @c memmove whenever\\r\\n   *  possible.  Failing that, if random access iterators are passed, then the\\r\\n   *  loop count will be known (and therefore a candidate for compiler\\r\\n   *  optimizations such as unrolling).\\r\\n   *\\r\\n   *  Result may not be in the range (first,last].  Use move instead.  Note\\r\\n   *  that the start of the output range may overlap [first,last).\\r\\n  */\\r\\n  template<typename _BI1, typename _BI2>\\r\\n    inline _BI2\\r\\n    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_BidirectionalIteratorConcept<_BI1>)\\r\\n      __glibcxx_function_requires(_Mutable_BidirectionalIteratorConcept<_BI2>)\\r\\n      __glibcxx_function_requires(_ConvertibleConcept<\\r\\n\\t    typename iterator_traits<_BI1>::value_type,\\r\\n\\t    typename iterator_traits<_BI2>::value_type>)\\r\\n      __glibcxx_requires_valid_range(__first, __last);\\r\\n\\r\\n      return std::__copy_move_backward_a2<true>(std::__miter_base(__first),\\r\\n\\t\\t\\t\\t\\t\\tstd::__miter_base(__last),\\r\\n\\t\\t\\t\\t\\t\\t__result);\\r\\n    }\\r\\n\\r\\n#define _GLIBCXX_MOVE_BACKWARD3(_Tp, _Up, _Vp) std::move_backward(_Tp, _Up, _Vp)\\r\\n#else\\r\\n#define _GLIBCXX_MOVE_BACKWARD3(_Tp, _Up, _Vp) std::copy_backward(_Tp, _Up, _Vp)\\r\\n#endif\\r\\n\\r\\n  template<typename _ForwardIterator, typename _Tp>\\r\\n    inline typename\\r\\n    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type\\r\\n    __fill_a(_ForwardIterator __first, _ForwardIterator __last,\\r\\n \\t     const _Tp& __value)\\r\\n    {\\r\\n      for (; __first != __last; ++__first)\\r\\n\\t*__first = __value;\\r\\n    }\\r\\n    \\r\\n  template<typename _ForwardIterator, typename _Tp>\\r\\n    inline typename\\r\\n    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type\\r\\n    __fill_a(_ForwardIterator __first, _ForwardIterator __last,\\r\\n\\t     const _Tp& __value)\\r\\n    {\\r\\n      const _Tp __tmp = __value;\\r\\n      for (; __first != __last; ++__first)\\r\\n\\t*__first = __tmp;\\r\\n    }\\r\\n\\r\\n  // Specialization: for char types we can use memset.\\r\\n  template<typename _Tp>\\r\\n    inline typename\\r\\n    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type\\r\\n    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)\\r\\n    {\\r\\n      const _Tp __tmp = __c;\\r\\n      __builtin_memset(__first, static_cast<unsigned char>(__tmp),\\r\\n\\t\\t       __last - __first);\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Fills the range [first,last) with copies of value.\\r\\n   *  @ingroup mutating_algorithms\\r\\n   *  @param  __first  A forward iterator.\\r\\n   *  @param  __last   A forward iterator.\\r\\n   *  @param  __value  A reference-to-const of arbitrary type.\\r\\n   *  @return   Nothing.\\r\\n   *\\r\\n   *  This function fills a range with copies of the same value.  For char\\r\\n   *  types filling contiguous areas of memory, this becomes an inline call\\r\\n   *  to @c memset or @c wmemset.\\r\\n  */\\r\\n  template<typename _ForwardIterator, typename _Tp>\\r\\n    inline void\\r\\n    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<\\r\\n\\t\\t\\t\\t  _ForwardIterator>)\\r\\n      __glibcxx_requires_valid_range(__first, __last);\\r\\n\\r\\n      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),\\r\\n\\t\\t    __value);\\r\\n    }\\r\\n\\r\\n  template<typename _OutputIterator, typename _Size, typename _Tp>\\r\\n    inline typename\\r\\n    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type\\r\\n    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)\\r\\n    {\\r\\n      for (__decltype(__n + 0) __niter = __n;\\r\\n\\t   __niter > 0; --__niter, ++__first)\\r\\n\\t*__first = __value;\\r\\n      return __first;\\r\\n    }\\r\\n\\r\\n  template<typename _OutputIterator, typename _Size, typename _Tp>\\r\\n    inline typename\\r\\n    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type\\r\\n    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)\\r\\n    {\\r\\n      const _Tp __tmp = __value;\\r\\n      for (__decltype(__n + 0) __niter = __n;\\r\\n\\t   __niter > 0; --__niter, ++__first)\\r\\n\\t*__first = __tmp;\\r\\n      return __first;\\r\\n    }\\r\\n\\r\\n  template<typename _Size, typename _Tp>\\r\\n    inline typename\\r\\n    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type\\r\\n    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)\\r\\n    {\\r\\n      std::__fill_a(__first, __first + __n, __c);\\r\\n      return __first + __n;\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Fills the range [first,first+n) with copies of value.\\r\\n   *  @ingroup mutating_algorithms\\r\\n   *  @param  __first  An output iterator.\\r\\n   *  @param  __n      The count of copies to perform.\\r\\n   *  @param  __value  A reference-to-const of arbitrary type.\\r\\n   *  @return   The iterator at first+n.\\r\\n   *\\r\\n   *  This function fills a range with copies of the same value.  For char\\r\\n   *  types filling contiguous areas of memory, this becomes an inline call\\r\\n   *  to @c memset or @ wmemset.\\r\\n   *\\r\\n   *  _GLIBCXX_RESOLVE_LIB_DEFECTS\\r\\n   *  DR 865. More algorithms that throw away information\\r\\n  */\\r\\n  template<typename _OI, typename _Size, typename _Tp>\\r\\n    inline _OI\\r\\n    fill_n(_OI __first, _Size __n, const _Tp& __value)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_OutputIteratorConcept<_OI, _Tp>)\\r\\n\\r\\n      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));\\r\\n    }\\r\\n\\r\\n  template<bool _BoolType>\\r\\n    struct __equal\\r\\n    {\\r\\n      template<typename _II1, typename _II2>\\r\\n        static bool\\r\\n        equal(_II1 __first1, _II1 __last1, _II2 __first2)\\r\\n        {\\r\\n\\t  for (; __first1 != __last1; ++__first1, ++__first2)\\r\\n\\t    if (!(*__first1 == *__first2))\\r\\n\\t      return false;\\r\\n\\t  return true;\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n  template<>\\r\\n    struct __equal<true>\\r\\n    {\\r\\n      template<typename _Tp>\\r\\n        static bool\\r\\n        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)\\r\\n        {\\r\\n\\t  return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)\\r\\n\\t\\t\\t\\t   * (__last1 - __first1));\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n  template<typename _II1, typename _II2>\\r\\n    inline bool\\r\\n    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)\\r\\n    {\\r\\n      typedef typename iterator_traits<_II1>::value_type _ValueType1;\\r\\n      typedef typename iterator_traits<_II2>::value_type _ValueType2;\\r\\n      const bool __simple = ((__is_integer<_ValueType1>::__value\\r\\n\\t\\t\\t      || __is_pointer<_ValueType1>::__value)\\r\\n\\t                     && __is_pointer<_II1>::__value\\r\\n\\t                     && __is_pointer<_II2>::__value\\r\\n\\t\\t\\t     && __are_same<_ValueType1, _ValueType2>::__value);\\r\\n\\r\\n      return std::__equal<__simple>::equal(__first1, __last1, __first2);\\r\\n    }\\r\\n\\r\\n  template<typename, typename>\\r\\n    struct __lc_rai\\r\\n    {\\r\\n      template<typename _II1, typename _II2>\\r\\n        static _II1\\r\\n        __newlast1(_II1, _II1 __last1, _II2, _II2)\\r\\n        { return __last1; }\\r\\n\\r\\n      template<typename _II>\\r\\n        static bool\\r\\n        __cnd2(_II __first, _II __last)\\r\\n        { return __first != __last; }\\r\\n    };\\r\\n\\r\\n  template<>\\r\\n    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>\\r\\n    {\\r\\n      template<typename _RAI1, typename _RAI2>\\r\\n        static _RAI1\\r\\n        __newlast1(_RAI1 __first1, _RAI1 __last1,\\r\\n\\t\\t   _RAI2 __first2, _RAI2 __last2)\\r\\n        {\\r\\n\\t  const typename iterator_traits<_RAI1>::difference_type\\r\\n\\t    __diff1 = __last1 - __first1;\\r\\n\\t  const typename iterator_traits<_RAI2>::difference_type\\r\\n\\t    __diff2 = __last2 - __first2;\\r\\n\\t  return __diff2 < __diff1 ? __first1 + __diff2 : __last1;\\r\\n\\t}\\r\\n\\r\\n      template<typename _RAI>\\r\\n        static bool\\r\\n        __cnd2(_RAI, _RAI)\\r\\n        { return true; }\\r\\n    };\\r\\n\\r\\n  template<typename _II1, typename _II2, typename _Compare>\\r\\n    bool\\r\\n    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,\\r\\n\\t\\t\\t\\t   _II2 __first2, _II2 __last2,\\r\\n\\t\\t\\t\\t   _Compare __comp)\\r\\n    {\\r\\n      typedef typename iterator_traits<_II1>::iterator_category _Category1;\\r\\n      typedef typename iterator_traits<_II2>::iterator_category _Category2;\\r\\n      typedef std::__lc_rai<_Category1, _Category2> __rai_type;\\r\\n\\r\\n      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);\\r\\n      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);\\r\\n\\t   ++__first1, ++__first2)\\r\\n\\t{\\r\\n\\t  if (__comp(__first1, __first2))\\r\\n\\t    return true;\\r\\n\\t  if (__comp(__first2, __first1))\\r\\n\\t    return false;\\r\\n\\t}\\r\\n      return __first1 == __last1 && __first2 != __last2;\\r\\n    }\\r\\n\\r\\n  template<bool _BoolType>\\r\\n    struct __lexicographical_compare\\r\\n    {\\r\\n      template<typename _II1, typename _II2>\\r\\n        static bool __lc(_II1, _II1, _II2, _II2);\\r\\n    };\\r\\n\\r\\n  template<bool _BoolType>\\r\\n    template<typename _II1, typename _II2>\\r\\n      bool\\r\\n      __lexicographical_compare<_BoolType>::\\r\\n      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)\\r\\n      {\\r\\n\\treturn std::__lexicographical_compare_impl(__first1, __last1,\\r\\n\\t\\t\\t\\t\\t\\t   __first2, __last2,\\r\\n\\t\\t\\t\\t\\t__gnu_cxx::__ops::__iter_less_iter());\\r\\n      }\\r\\n\\r\\n  template<>\\r\\n    struct __lexicographical_compare<true>\\r\\n    {\\r\\n      template<typename _Tp, typename _Up>\\r\\n        static bool\\r\\n        __lc(const _Tp* __first1, const _Tp* __last1,\\r\\n\\t     const _Up* __first2, const _Up* __last2)\\r\\n\\t{\\r\\n\\t  const size_t __len1 = __last1 - __first1;\\r\\n\\t  const size_t __len2 = __last2 - __first2;\\r\\n\\t  const int __result = __builtin_memcmp(__first1, __first2,\\r\\n\\t\\t\\t\\t\\t\\tstd::min(__len1, __len2));\\r\\n\\t  return __result != 0 ? __result < 0 : __len1 < __len2;\\r\\n\\t}\\r\\n    };\\r\\n\\r\\n  template<typename _II1, typename _II2>\\r\\n    inline bool\\r\\n    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,\\r\\n\\t\\t\\t\\t  _II2 __first2, _II2 __last2)\\r\\n    {\\r\\n      typedef typename iterator_traits<_II1>::value_type _ValueType1;\\r\\n      typedef typename iterator_traits<_II2>::value_type _ValueType2;\\r\\n      const bool __simple =\\r\\n\\t(__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value\\r\\n\\t && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed\\r\\n\\t && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed\\r\\n\\t && __is_pointer<_II1>::__value\\r\\n\\t && __is_pointer<_II2>::__value);\\r\\n\\r\\n      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,\\r\\n\\t\\t\\t\\t\\t\\t\\t    __first2, __last2);\\r\\n    }\\r\\n\\r\\n  template<typename _ForwardIterator, typename _Tp, typename _Compare>\\r\\n    _ForwardIterator\\r\\n    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,\\r\\n\\t\\t  const _Tp& __val, _Compare __comp)\\r\\n    {\\r\\n      typedef typename iterator_traits<_ForwardIterator>::difference_type\\r\\n\\t_DistanceType;\\r\\n\\r\\n      _DistanceType __len = std::distance(__first, __last);\\r\\n\\r\\n      while (__len > 0)\\r\\n\\t{\\r\\n\\t  _DistanceType __half = __len >> 1;\\r\\n\\t  _ForwardIterator __middle = __first;\\r\\n\\t  std::advance(__middle, __half);\\r\\n\\t  if (__comp(__middle, __val))\\r\\n\\t    {\\r\\n\\t      __first = __middle;\\r\\n\\t      ++__first;\\r\\n\\t      __len = __len - __half - 1;\\r\\n\\t    }\\r\\n\\t  else\\r\\n\\t    __len = __half;\\r\\n\\t}\\r\\n      return __first;\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Finds the first position in which @a val could be inserted\\r\\n   *         without changing the ordering.\\r\\n   *  @param  __first   An iterator.\\r\\n   *  @param  __last    Another iterator.\\r\\n   *  @param  __val     The search term.\\r\\n   *  @return         An iterator pointing to the first element <em>not less\\r\\n   *                  than</em> @a val, or end() if every element is less than \\r\\n   *                  @a val.\\r\\n   *  @ingroup binary_search_algorithms\\r\\n  */\\r\\n  template<typename _ForwardIterator, typename _Tp>\\r\\n    inline _ForwardIterator\\r\\n    lower_bound(_ForwardIterator __first, _ForwardIterator __last,\\r\\n\\t\\tconst _Tp& __val)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)\\r\\n      __glibcxx_function_requires(_LessThanOpConcept<\\r\\n\\t    typename iterator_traits<_ForwardIterator>::value_type, _Tp>)\\r\\n      __glibcxx_requires_partitioned_lower(__first, __last, __val);\\r\\n\\r\\n      return std::__lower_bound(__first, __last, __val,\\r\\n\\t\\t\\t\\t__gnu_cxx::__ops::__iter_less_val());\\r\\n    }\\r\\n\\r\\n  /// This is a helper function for the sort routines and for random.tcc.\\r\\n  //  Precondition: __n > 0.\\r\\n  inline _GLIBCXX_CONSTEXPR int\\r\\n  __lg(int __n)\\r\\n  { return sizeof(int) * __CHAR_BIT__  - 1 - __builtin_clz(__n); }\\r\\n\\r\\n  inline _GLIBCXX_CONSTEXPR unsigned\\r\\n  __lg(unsigned __n)\\r\\n  { return sizeof(int) * __CHAR_BIT__  - 1 - __builtin_clz(__n); }\\r\\n\\r\\n  inline _GLIBCXX_CONSTEXPR long\\r\\n  __lg(long __n)\\r\\n  { return sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); }\\r\\n\\r\\n  inline _GLIBCXX_CONSTEXPR unsigned long\\r\\n  __lg(unsigned long __n)\\r\\n  { return sizeof(long) * __CHAR_BIT__ - 1 - __builtin_clzl(__n); }\\r\\n\\r\\n  inline _GLIBCXX_CONSTEXPR long long\\r\\n  __lg(long long __n)\\r\\n  { return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); }\\r\\n\\r\\n  inline _GLIBCXX_CONSTEXPR unsigned long long\\r\\n  __lg(unsigned long long __n)\\r\\n  { return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); }\\r\\n\\r\\n_GLIBCXX_END_NAMESPACE_VERSION\\r\\n\\r\\n_GLIBCXX_BEGIN_NAMESPACE_ALGO\\r\\n\\r\\n  /**\\r\\n   *  @brief Tests a range for element-wise equality.\\r\\n   *  @ingroup non_mutating_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @return   A boolean true or false.\\r\\n   *\\r\\n   *  This compares the elements of two ranges using @c == and returns true or\\r\\n   *  false depending on whether all of the corresponding elements of the\\r\\n   *  ranges are equal.\\r\\n  */\\r\\n  template<typename _II1, typename _II2>\\r\\n    inline bool\\r\\n    equal(_II1 __first1, _II1 __last1, _II2 __first2)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II2>)\\r\\n      __glibcxx_function_requires(_EqualOpConcept<\\r\\n\\t    typename iterator_traits<_II1>::value_type,\\r\\n\\t    typename iterator_traits<_II2>::value_type>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n\\r\\n      return std::__equal_aux(std::__niter_base(__first1),\\r\\n\\t\\t\\t      std::__niter_base(__last1),\\r\\n\\t\\t\\t      std::__niter_base(__first2));\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Tests a range for element-wise equality.\\r\\n   *  @ingroup non_mutating_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @param __binary_pred A binary predicate @link functors\\r\\n   *                  functor@endlink.\\r\\n   *  @return         A boolean true or false.\\r\\n   *\\r\\n   *  This compares the elements of two ranges using the binary_pred\\r\\n   *  parameter, and returns true or\\r\\n   *  false depending on whether all of the corresponding elements of the\\r\\n   *  ranges are equal.\\r\\n  */\\r\\n  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>\\r\\n    inline bool\\r\\n    equal(_IIter1 __first1, _IIter1 __last1,\\r\\n\\t  _IIter2 __first2, _BinaryPredicate __binary_pred)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_IIter1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_IIter2>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n\\r\\n      for (; __first1 != __last1; ++__first1, ++__first2)\\r\\n\\tif (!bool(__binary_pred(*__first1, *__first2)))\\r\\n\\t  return false;\\r\\n      return true;\\r\\n    }\\r\\n\\r\\n#if __cplusplus > 201103L\\r\\n\\r\\n#define __cpp_lib_robust_nonmodifying_seq_ops 201304\\r\\n\\r\\n  /**\\r\\n   *  @brief Tests a range for element-wise equality.\\r\\n   *  @ingroup non_mutating_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @param  __last2   An input iterator.\\r\\n   *  @return   A boolean true or false.\\r\\n   *\\r\\n   *  This compares the elements of two ranges using @c == and returns true or\\r\\n   *  false depending on whether all of the corresponding elements of the\\r\\n   *  ranges are equal.\\r\\n  */\\r\\n  template<typename _II1, typename _II2>\\r\\n    inline bool\\r\\n    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II2>)\\r\\n      __glibcxx_function_requires(_EqualOpConcept<\\r\\n\\t    typename iterator_traits<_II1>::value_type,\\r\\n\\t    typename iterator_traits<_II2>::value_type>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n      __glibcxx_requires_valid_range(__first2, __last2);\\r\\n\\r\\n      using _RATag = random_access_iterator_tag;\\r\\n      using _Cat1 = typename iterator_traits<_II1>::iterator_category;\\r\\n      using _Cat2 = typename iterator_traits<_II2>::iterator_category;\\r\\n      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;\\r\\n      if (_RAIters())\\r\\n\\t{\\r\\n\\t  auto __d1 = std::distance(__first1, __last1);\\r\\n\\t  auto __d2 = std::distance(__first2, __last2);\\r\\n\\t  if (__d1 != __d2)\\r\\n\\t    return false;\\r\\n\\t  return _GLIBCXX_STD_A::equal(__first1, __last1, __first2);\\r\\n\\t}\\r\\n\\r\\n      for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)\\r\\n\\tif (!(*__first1 == *__first2))\\r\\n\\t  return false;\\r\\n      return __first1 == __last1 && __first2 == __last2;\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Tests a range for element-wise equality.\\r\\n   *  @ingroup non_mutating_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @param  __last2   An input iterator.\\r\\n   *  @param __binary_pred A binary predicate @link functors\\r\\n   *                  functor@endlink.\\r\\n   *  @return         A boolean true or false.\\r\\n   *\\r\\n   *  This compares the elements of two ranges using the binary_pred\\r\\n   *  parameter, and returns true or\\r\\n   *  false depending on whether all of the corresponding elements of the\\r\\n   *  ranges are equal.\\r\\n  */\\r\\n  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>\\r\\n    inline bool\\r\\n    equal(_IIter1 __first1, _IIter1 __last1,\\r\\n\\t  _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_IIter1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_IIter2>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n      __glibcxx_requires_valid_range(__first2, __last2);\\r\\n\\r\\n      using _RATag = random_access_iterator_tag;\\r\\n      using _Cat1 = typename iterator_traits<_IIter1>::iterator_category;\\r\\n      using _Cat2 = typename iterator_traits<_IIter2>::iterator_category;\\r\\n      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;\\r\\n      if (_RAIters())\\r\\n\\t{\\r\\n\\t  auto __d1 = std::distance(__first1, __last1);\\r\\n\\t  auto __d2 = std::distance(__first2, __last2);\\r\\n\\t  if (__d1 != __d2)\\r\\n\\t    return false;\\r\\n\\t  return _GLIBCXX_STD_A::equal(__first1, __last1, __first2,\\r\\n\\t\\t\\t\\t       __binary_pred);\\r\\n\\t}\\r\\n\\r\\n      for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)\\r\\n\\tif (!bool(__binary_pred(*__first1, *__first2)))\\r\\n\\t  return false;\\r\\n      return __first1 == __last1 && __first2 == __last2;\\r\\n    }\\r\\n#endif\\r\\n\\r\\n  /**\\r\\n   *  @brief Performs @b dictionary comparison on ranges.\\r\\n   *  @ingroup sorting_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @param  __last2   An input iterator.\\r\\n   *  @return   A boolean true or false.\\r\\n   *\\r\\n   *  <em>Returns true if the sequence of elements defined by the range\\r\\n   *  [first1,last1) is lexicographically less than the sequence of elements\\r\\n   *  defined by the range [first2,last2).  Returns false otherwise.</em>\\r\\n   *  (Quoted from [25.3.8]/1.)  If the iterators are all character pointers,\\r\\n   *  then this is an inline call to @c memcmp.\\r\\n  */\\r\\n  template<typename _II1, typename _II2>\\r\\n    inline bool\\r\\n    lexicographical_compare(_II1 __first1, _II1 __last1,\\r\\n\\t\\t\\t    _II2 __first2, _II2 __last2)\\r\\n    {\\r\\n#ifdef _GLIBCXX_CONCEPT_CHECKS\\r\\n      // concept requirements\\r\\n      typedef typename iterator_traits<_II1>::value_type _ValueType1;\\r\\n      typedef typename iterator_traits<_II2>::value_type _ValueType2;\\r\\n#endif\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II2>)\\r\\n      __glibcxx_function_requires(_LessThanOpConcept<_ValueType1, _ValueType2>)\\r\\n      __glibcxx_function_requires(_LessThanOpConcept<_ValueType2, _ValueType1>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n      __glibcxx_requires_valid_range(__first2, __last2);\\r\\n\\r\\n      return std::__lexicographical_compare_aux(std::__niter_base(__first1),\\r\\n\\t\\t\\t\\t\\t\\tstd::__niter_base(__last1),\\r\\n\\t\\t\\t\\t\\t\\tstd::__niter_base(__first2),\\r\\n\\t\\t\\t\\t\\t\\tstd::__niter_base(__last2));\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Performs @b dictionary comparison on ranges.\\r\\n   *  @ingroup sorting_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @param  __last2   An input iterator.\\r\\n   *  @param  __comp  A @link comparison_functors comparison functor@endlink.\\r\\n   *  @return   A boolean true or false.\\r\\n   *\\r\\n   *  The same as the four-parameter @c lexicographical_compare, but uses the\\r\\n   *  comp parameter instead of @c <.\\r\\n  */\\r\\n  template<typename _II1, typename _II2, typename _Compare>\\r\\n    inline bool\\r\\n    lexicographical_compare(_II1 __first1, _II1 __last1,\\r\\n\\t\\t\\t    _II2 __first2, _II2 __last2, _Compare __comp)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_II2>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n      __glibcxx_requires_valid_range(__first2, __last2);\\r\\n\\r\\n      return std::__lexicographical_compare_impl\\r\\n\\t(__first1, __last1, __first2, __last2,\\r\\n\\t __gnu_cxx::__ops::__iter_comp_iter(__comp));\\r\\n    }\\r\\n\\r\\n  template<typename _InputIterator1, typename _InputIterator2,\\r\\n\\t   typename _BinaryPredicate>\\r\\n    pair<_InputIterator1, _InputIterator2>\\r\\n    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,\\r\\n\\t       _InputIterator2 __first2, _BinaryPredicate __binary_pred)\\r\\n    {\\r\\n      while (__first1 != __last1 && __binary_pred(__first1, __first2))\\r\\n        {\\r\\n\\t  ++__first1;\\r\\n\\t  ++__first2;\\r\\n        }\\r\\n      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Finds the places in ranges which don\'t match.\\r\\n   *  @ingroup non_mutating_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @return   A pair of iterators pointing to the first mismatch.\\r\\n   *\\r\\n   *  This compares the elements of two ranges using @c == and returns a pair\\r\\n   *  of iterators.  The first iterator points into the first range, the\\r\\n   *  second iterator points into the second range, and the elements pointed\\r\\n   *  to by the iterators are not equal.\\r\\n  */\\r\\n  template<typename _InputIterator1, typename _InputIterator2>\\r\\n    inline pair<_InputIterator1, _InputIterator2>\\r\\n    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,\\r\\n\\t     _InputIterator2 __first2)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)\\r\\n      __glibcxx_function_requires(_EqualOpConcept<\\r\\n\\t    typename iterator_traits<_InputIterator1>::value_type,\\r\\n\\t    typename iterator_traits<_InputIterator2>::value_type>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n\\r\\n      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,\\r\\n\\t\\t\\t     __gnu_cxx::__ops::__iter_equal_to_iter());\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Finds the places in ranges which don\'t match.\\r\\n   *  @ingroup non_mutating_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @param __binary_pred A binary predicate @link functors\\r\\n   *         functor@endlink.\\r\\n   *  @return   A pair of iterators pointing to the first mismatch.\\r\\n   *\\r\\n   *  This compares the elements of two ranges using the binary_pred\\r\\n   *  parameter, and returns a pair\\r\\n   *  of iterators.  The first iterator points into the first range, the\\r\\n   *  second iterator points into the second range, and the elements pointed\\r\\n   *  to by the iterators are not equal.\\r\\n  */\\r\\n  template<typename _InputIterator1, typename _InputIterator2,\\r\\n\\t   typename _BinaryPredicate>\\r\\n    inline pair<_InputIterator1, _InputIterator2>\\r\\n    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,\\r\\n\\t     _InputIterator2 __first2, _BinaryPredicate __binary_pred)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n\\r\\n      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2,\\r\\n\\t__gnu_cxx::__ops::__iter_comp_iter(__binary_pred));\\r\\n    }\\r\\n\\r\\n#if __cplusplus > 201103L\\r\\n\\r\\n  template<typename _InputIterator1, typename _InputIterator2,\\r\\n\\t   typename _BinaryPredicate>\\r\\n    pair<_InputIterator1, _InputIterator2>\\r\\n    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,\\r\\n\\t       _InputIterator2 __first2, _InputIterator2 __last2,\\r\\n\\t       _BinaryPredicate __binary_pred)\\r\\n    {\\r\\n      while (__first1 != __last1 && __first2 != __last2\\r\\n\\t     && __binary_pred(__first1, __first2))\\r\\n        {\\r\\n\\t  ++__first1;\\r\\n\\t  ++__first2;\\r\\n        }\\r\\n      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Finds the places in ranges which don\'t match.\\r\\n   *  @ingroup non_mutating_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @param  __last2   An input iterator.\\r\\n   *  @return   A pair of iterators pointing to the first mismatch.\\r\\n   *\\r\\n   *  This compares the elements of two ranges using @c == and returns a pair\\r\\n   *  of iterators.  The first iterator points into the first range, the\\r\\n   *  second iterator points into the second range, and the elements pointed\\r\\n   *  to by the iterators are not equal.\\r\\n  */\\r\\n  template<typename _InputIterator1, typename _InputIterator2>\\r\\n    inline pair<_InputIterator1, _InputIterator2>\\r\\n    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,\\r\\n\\t     _InputIterator2 __first2, _InputIterator2 __last2)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)\\r\\n      __glibcxx_function_requires(_EqualOpConcept<\\r\\n\\t    typename iterator_traits<_InputIterator1>::value_type,\\r\\n\\t    typename iterator_traits<_InputIterator2>::value_type>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n      __glibcxx_requires_valid_range(__first2, __last2);\\r\\n\\r\\n      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2,\\r\\n\\t\\t\\t     __gnu_cxx::__ops::__iter_equal_to_iter());\\r\\n    }\\r\\n\\r\\n  /**\\r\\n   *  @brief Finds the places in ranges which don\'t match.\\r\\n   *  @ingroup non_mutating_algorithms\\r\\n   *  @param  __first1  An input iterator.\\r\\n   *  @param  __last1   An input iterator.\\r\\n   *  @param  __first2  An input iterator.\\r\\n   *  @param  __last2   An input iterator.\\r\\n   *  @param __binary_pred A binary predicate @link functors\\r\\n   *         functor@endlink.\\r\\n   *  @return   A pair of iterators pointing to the first mismatch.\\r\\n   *\\r\\n   *  This compares the elements of two ranges using the binary_pred\\r\\n   *  parameter, and returns a pair\\r\\n   *  of iterators.  The first iterator points into the first range, the\\r\\n   *  second iterator points into the second range, and the elements pointed\\r\\n   *  to by the iterators are not equal.\\r\\n  */\\r\\n  template<typename _InputIterator1, typename _InputIterator2,\\r\\n\\t   typename _BinaryPredicate>\\r\\n    inline pair<_InputIterator1, _InputIterator2>\\r\\n    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,\\r\\n\\t     _InputIterator2 __first2, _InputIterator2 __last2,\\r\\n\\t     _BinaryPredicate __binary_pred)\\r\\n    {\\r\\n      // concept requirements\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)\\r\\n      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)\\r\\n      __glibcxx_requires_valid_range(__first1, __last1);\\r\\n      __glibcxx_requires_valid_range(__first2, __last2);\\r\\n\\r\\n      return _GLIBCXX_STD_A::__mismatch(__first1, __last1, __first2, __last2,\\r\\n\\t\\t\\t     __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));\\r\\n    }\\r\\n#endif\\r\\n\\r\\n_GLIBCXX_END_NAMESPACE_ALGO\\r\\n} // namespace std\\r\\n\\r\\n// NB: This file is included within many other C++ includes, as a way\\r\\n// of getting the base \\r\\n#ifdekandouIBCXX_PAk\xB7ndoEL\\r\\n# inclukan\xB7\xB7<parallel/alkanba\xB7\xB7e.h>\\r\\n#endif\\r\\n#endif\\r\\n```\\r\\n\\r\\n```\\r\\n\\r\\n```\\r\\n```\\r\\n\\r\\n```\\r\\n```\\r\\n\\r\\n```\\r\\n```\\r\\n\\r\\n```\\r\\n```\\r\\n\\r\\n```\\r\\n```\\r\\n\\r\\n```\\r\\n\\r\\n```\\r\\n```","school":"\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6","studentId":"\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6\u56D6","backgroundImage":"https://www.bing.com/images/search?q=&view=detailv2&id=198DDDFE72B8EBDDE4906D7188CB4CD1B78BA84A&ccid=QRNt64HX&iss=fav&FORM=SVIM01&idpview=singleimage&mediaurl=https%253a%252f%252fimgo.hackhome.com%252fimg2022%252f6%252f28%252f13%252f2022062813510493092.jpg&expw=1596&exph=896&thid=OIP.QRNt64HXeNwDhDXuCTebpQHaEK&idpbck=1","unreadMsg":0,"pinnedDomains":[],"fontFamily":"Open Sans","codeFontFamily":"Source Code Pro","preferredEditorType":"sv","theme":"light","showInvisibleChar":false,"formatCode":true,"skipAnimate":true,"showTimeAgo":true,"displayName":"#include<bits/stdc++.h>","nAccept":248,"nSubmit":264,"rp":235.3620915839097,"rpInfo":{"problem":235.3620915839097},"rank":1197,"level":6,"avatarUrl":"//cn.gravatar.com/avatar/79eb74243d420aa0d2371aba7e843244?d=mm&s=128"}';
    </script>
      </head>
<body>
      <script type="text/javascript" src="/constant/a7642cc1.js"></script>
    <script type="text/javascript" src="/resource/4.54.1/lang-zh.js"></script>
    <script type="text/javascript" src="/hydro-4.54.1.js"></script>
    <nav class="nav slideout-menu" id="menu">
  <div class="row"><div class="columns clearfix">
    <ol class="nav__list nav__list--main clearfix">
      <li class="nav__list-item">
        <a href="/"><img class="nav__logo" src="https://img.kedaoi.cn/logo.png"></a>
      </li>         <li class="nav__list-item">
  <a href="/" class="nav__item">
    首页
  </a>
</li>                <li class="nav__list-item">
  <a href="/p" class="nav__item">
    题库
  </a>
</li>                <li class="nav__list-item">
  <a href="/training" class="nav__item">
    训练
  </a>
</li>                <li class="nav__list-item">
  <a href="/contest" class="nav__item">
    比赛
  </a>
</li>                              <li class="nav__list-item">
  <a href="/discuss" class="nav__item">
    讨论
  </a>
</li>                <li class="nav__list-item">
  <a href="/record?uidOrName=9760" class="nav__item">
    评测记录
  </a>
</li>                <li class="nav__list-item">
  <a href="/ranking" class="nav__item">
    排名
  </a>
</li>                <li class="nav__list-item">
  <a href="/keda" class="nav__item">
    可达班
  </a>
</li>                <li class="nav__list-item">
  <a href="/dazi" class="nav__item">
    打字
  </a>
</li>       </ol>
    <ol class="nav__list nav__list--secondary clearfix">
              <li class="nav__list-item" data-dropdown-pos="bottom right" data-dropdown-custom-class="nav__dropdown" data-dropdown-target="#menu-nav-domain" data-dropdown-disabledconstrainToWindow data-dropdown-trigger-desktop-only>
        <span class="nav__item"><span class="icon"><img class="small user-profile-avatar v-center" loading="lazy" src="https://q1.qlogo.cn/g?b=qq&amp;nk=491237847&amp;s=160" width="20" height="20"></span> 可达 <span class="icon icon-expand_more nojs--hide"></span></span>
        <ol class="dropdown-target menu" id="menu-nav-domain"><li class="menu__item">
            <a href="/home/domain" class="menu__link">
              <span class="icon icon-wrench"></span> 管理
            </a>
          </li>
        </ol>
      </li>
          <li class="nav__list-item" data-dropdown-pos="bottom right" data-dropdown-custom-class="nav__dropdown" data-dropdown-target="#menu-nav-user" data-dropdown-disabledconstrainToWindow data-dropdown-trigger-desktop-only>
        <a href="/user/9760" class="nav__item">程子皓 <span class="icon icon-expand_more nojs--hide"></span></a>
        <ol class="dropdown-target menu" id="menu-nav-user">
          <li class="menu__item">
            <a href="/user/9760" class="menu__link">
              <span class="icon icon-account--circle"></span> 我的资料
            </a>
          </li><li class="menu__item">
            <a href="/home/messages" class="menu__link">
              <span class="icon icon-comment--multiple"></span> 站内消息
            </a>
          </li>
          <li class="menu__seperator"></li>
          <li class="menu__item">
            <a href="/home/settings/domain" class="menu__link">
              <span class="icon icon-web"></span> @ 可达
            </a>
          </li>
          <li class="menu__seperator"></li>
          <li class="menu__item">
            <a href="/home/settings/account" class="menu__link">
              <span class="icon icon-wrench"></span> 账户设置
            </a>
          </li>
          <li class="menu__item">
            <a href="/home/settings/preference" class="menu__link">
              <span class="icon icon-sliders"></span> 偏好设置
            </a>
          </li>
          <li class="menu__item">
            <a href="/home/security" class="menu__link">
              <span class="icon icon-security"></span> 安全设置
            </a>
          </li>
          <li class="menu__seperator"></li>
          <li class="menu__item">
            <a href="/home/domain" class="menu__link">
              <span class="icon icon-web"></span> 我的域
            </a>
          </li>
                      <li class="menu__item">
              <a href="/file" class="menu__link">
                <span class="icon icon-file"></span> 我的文件
              </a>
            </li>
                                <li class="menu__seperator"></li><li class="menu__item nojs--hide">
                            <a href="/blog/9760" class="menu__link">
                <span class="icon icon-book"></span> 博客
              </a>
            </li>          <li class="menu__seperator"></li>
                    <li class="menu__item">
            <a href="/logout" class="menu__link" name="nav_logout">
              <span class="icon icon-logout"></span> 登出
            </a>
          </li>
        </ol>
      </li>
        </ol>
  </div></div>
</nav>
<nav class="nav--shadow"></nav>
<div class="slideout-panel" id="panel">
    <div class="slideout-overlay"></div>
  <div class="header--mobile">
  <div class="row"><div class="columns clearfix">
    <div class="float-left">
      <a class="header--mobile__domain" href="/" target="_self">
        <img src="https://img.kedaoi.cn/logo.png">
      </a>
    </div>
    <div class="float-right">
      <button type="button" class="header__hamburger">
  <div class="hamburger hamburger--spin">
    <span class="hamburger-box">
      <span class="hamburger-inner"></span>
    </span>
  </div>
</button>
    </div>
  </div></div>
</div>
  <div class="main">
        
<style>
  .user-profile-bg {
    background-image: url("/components/profile/backgrounds/1.jpg"), url("/components/profile/backgrounds/1.jpg");
  }
</style>
<div class="row">
  <div class="medium-9 columns">
    <div class="section">
      <div class="profile-header user-profile-bg">
        <div class="profile-header__content">
          <div class="media">
            <div class="media__left">
              <img src="//cn.gravatar.com/avatar/d65a08433ae360fb0013958aba993d81?d=mm&amp;s=120" width="120" height="120" class="large user-profile-avatar">
            </div>
            <div class="media__body profile-header__main">
              <h1> 王煜喆 </h1>
              <p>
                UID: 11001,
                <!-- 注册于 <span class="time relative" data-timestamp="1728030727.777">2024-10-4 16:32:07</span>, -->
                最后登录于 <span class="time relative" data-timestamp="1728038957.142">2024-10-4 18:49:17</span>,
                              目前离线.
                            </p>
              <p>解决了 0 道题目，RP: 0 (No. ?)</p>
                            <div class="profile-header__contact-bar">
                              <a class="profile-header__contact-item" href="/home/messages?target=11001" target="_blank" data-tooltip="发送站内信息">
                  <span class="icon icon-comment--multiple"></span>
                </a>
                                                                      </div>
            </div>
          </div>
        </div>
      </div>
      <div class="profile-content">
        <div class="section__tab-container immersive">
          <ul class="section__tabs">
            <li class="section__tab-item">
              <h1 class="section__tab-title">个人简介</h1>
              <div class="section__tab-main">
                              <div class="section__body typo richmedia">
                  <p>坚持日拱一卒，每天进步一点点。</p>

                </div>
                            </div>
            </li>
                        <li class="section__tab-item">
  <h1 class="section__tab-title">最近活动</h1>
  <div class="section__tab-main">
          <div class="nothing-placeholder">
  <div class="nothing-icon"></div>
  This person is lazy and didn&#39;t join any contests or homework.
</div>

      </div>
</li>          </ul>
        </div>
      </div>
    </div>
  </div>
  <div class="medium-3 columns">
        <div class="section side">
      <div class="section__body">
        <div class="balancer sidebar-user-stat">
          <div class="balancer__body">
            <div class="numbox">
              <div class="numbox__num medium">0</div>
              <div class="numbox__text">已递交</div>
            </div>
          </div>
          <div class="balancer__body">
            <div class="numbox">
              <div class="numbox__num medium">0</div>
              <div class="numbox__text">已通过</div>
            </div>
          </div>
          <div class="balancer__body">
            <div class="numbox">
              <div class="numbox__num medium">0</div>
              <div class="numbox__text">题解被赞</div>
            </div>
          </div>
        </div>
      </div>
    </div>
      </div>
</div>
  </div>
  <div class="footer">
  <div class="row"><div class="columns">
      <div class="row footer__links">
      <div class="medium-3 large-2 columns footer__category expandable">
        <h1>
          状态
          <span class="expand-icon">
            <span class="icon icon-expand_more"></span>
          </span>
        </h1>
        <div class="footer__category__expander"><ul class="footer__category__list">
          <li class="footer__category__item"><a href="/record">评测队列</a></li>
          <li class="footer__category__item"><a href="/status">服务状态</a></li>
        </ul></div>
      </div>
      <div class="medium-3 large-2 columns footer__category expandable">
        <h1>
          开发
          <span class="expand-icon">
            <span class="icon icon-expand_more"></span>
          </span>
        </h1>
        <div class="footer__category__expander"><ul class="footer__category__list">
          <li class="footer__category__item"><a href="https://github.com/hydro-dev/Hydro" target="_blank">开源</a></li>
          <li class="footer__category__item"><a href="/api">API</a></li>
        </ul></div>
      </div>
      <div class="medium-3 large-2 columns footer__category expandable end">
        <h1>
          支持
          <span class="expand-icon">
            <span class="icon icon-expand_more"></span>
          </span>
        </h1>
        <div class="footer__category__expander"><ul class="footer__category__list">
          <li class="footer__category__item"><a href="/wiki/help">帮助</a></li>
          <li class="footer__category__item"><a href="/wiki/about#contact">QQ 群</a></li>
        </ul></div>
      </div>
    </div>
      <div class="footer__extra-link clearfix">
      <div class="footer__extra-left">
        <ol class="clearfix">
          <li class="footer__extra-link-item"><a href="/wiki/about">关于</a></li>
          <!-- <li class="footer__extra-link-item"><a href="/wiki/about#contact">联系我们</a></li> -->
          <!-- <li class="footer__extra-link-item"><a href="/wiki/about#privacy">隐私</a></li> -->
          <!-- <li class="footer__extra-link-item"><a href="/wiki/about#tos">服务条款</a></li> -->
          <!-- <li class="footer__extra-link-item"><a href="/wiki/about#contact">版权申诉</a></li> -->
          <li class="footer__extra-link-item nojs--hide" data-dropdown-target="#menu-footer-lang">
            <span><span class="icon icon-global"></span> Language <span class="icon icon-expand_less"></span></span>
            <ol class="dropdown-target menu" id="menu-footer-lang"><li class="menu__item"><a class="menu__link" href="/language/en">English</a></li><li class="menu__item"><a class="menu__link" href="/language/ko">한국어</a></li><li class="menu__item"><a class="menu__link" href="/language/zh">简体中文</a></li><li class="menu__item"><a class="menu__link" href="/language/zh_TW">正體中文</a></li></ol>
          </li>
          <li class="footer__extra-link-item">
                          <a href="/legacy">兼容模式</a>
                      </li>
          <li class="footer__extra-link-item nojs--hide" data-dropdown-target="#menu-footer-theme">
            <span><span class="icon icon-global"></span> 主题 <span class="icon icon-expand_less"></span></span>
            <ol class="dropdown-target menu" id="menu-footer-theme">
              <li class="menu__item"><a class="menu__link" href="/set_theme/light">亮色</a></li>
              <li class="menu__item"><a class="menu__link" href="/set_theme/dark">暗色</a></li>
            </ol>
          </li>
        </ol>
      </div>
      <div class="footer__extra-right">
        <ol class="clearfix"><li class="footer__extra-link-item"></li><li class="footer__extra-link-item"><a href="https://beian.miit.gov.cn">粤ICP备19104337号</a> &emsp;<a href="https://kedaoi.cn/blog/2/6302fb60cc2e2304c1161d3f">子题库导航 </a>
</li><li class="footer__extra-link-item">
</li><li class="footer__extra-link-item"></li><!-- <li class="footer__extra-link-item">Worker 0, 13ms</li> -->
          <!-- Prepare 0ms -->
          <!-- Method 3ms -->
          <li class="footer__extra-link-item">Powered by <a href="https://hydro.js.org">Hydro v4.15.0</a> Community</li>
        </ol>
      </div>
    </div>
  </div></div>
<script>
var _hmt = _hmt || [];
(function() {
  var hm = document.createElement("script");
  hm.src = "https://hm.baidu.com/hm.js?ca5af897b6e9c781b4f9d2037e9c8d83";
  var s = document.getElementsByTagName("script")[0]; 
  s.parentNode.insertBefore(hm, s);
})();
</script>

    <script> 
      var url = document.location.toString();
      var arrUrl = url.split("//");
      var start = arrUrl[1].indexOf("/");
      var relUrl = arrUrl[1].substring(start);//stop省略，截取从start开始到结尾的所有字符
      if(relUrl.indexOf("?") != -1){
        relUrl = relUrl.split("?")[0];
      }
      var h = Date.parse(new Date()) / 1000 % (24*3600);
      h = h / 3600 + 8;
      if(h > 23) h = h % 24;
      // var specialUser = [9934];   specialUser.includes( 9760 )
      if(document.domain == "kedaoi.cn" && (relUrl.startsWith("/d/system/") || (relUrl.startsWith("/d/AutumnCamp24/") && ( h >= 18 || h <= 4 )) || !relUrl.startsWith("/d/"))){
        (function (w, d, e, x) {
            w[e] = function () {
                w.cbk = w.cbk || [];
                w.cbk.push(arguments);
            };
            x = d.createElement('script');
            x.async = true;
            x.id = 'zhichiScript';
            x.src = 'https://corp10010436.soboten.com/chat/frame/v6/entrance.js?sysnum=91c092936d734e79b0e82407813de2ef';
            d.body.appendChild(x);
        })(window, document, 'zc');
        zc('config', {
            channelid: 11,
            type: 2,
            man_trace: true,
            hide_max: true,
            partnerid: "学号：9760",
            uname: "程子皓",
            face: UserContext.avatarUrl,
            sign: "0218237d0c1de1300b3aaea964689703"
        });
      }
    </script>


</div></div>
        <script>
      var UiContextNew = '{"udoc":{"_id":11001,"mail":"6646464663@qq.com","uname":"\u738B\u715C\u5586","hashType":"hydro","priv":65540,"regat":"2024-10-04T08:32:07.777Z","loginat":"2024-10-04T10:49:17.142Z","perm":"BigInt::10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831653804978457923079372801","role":"guest","scope":"BigInt::-1","tfa":false,"authn":false,"group":["11001"],"domains":[],"timeZone":"Asia/Shanghai","codeLang":"cc.std14","avatar":"gravatar:6646464663@qq.com","gender":2,"bio":"\u575A\u6301\u65E5\u62F1\u4E00\u5352\uFF0C\u6BCF\u5929\u8FDB\u6B65\u4E00\u70B9\u70B9\u3002","backgroundImage":"/components/profile/backgrounds/1.jpg","pinnedDomains":[],"fontFamily":"Open Sans","codeFontFamily":"Source Code Pro","preferredEditorType":"sv","theme":"light","formatCode":true,"showTimeAgo":true,"rp":0,"rpInfo":{},"level":0,"avatarUrl":"//cn.gravatar.com/avatar/d65a08433ae360fb0013958aba993d81?d=mm&s=64"}}';
      var UserContextNew = '{}';
    </script>
  </body>
</html>