break;      ++__first;    }    while (__first != __last) {      _Integer __n = __count - 1;      _ForwardIter __i = __first;      ++__i;      while (__i != __last && __n != 0 && __binary_pred(*__i, __val)) {        ++__i;        --__n;      }      if (__n == 0)        return __first;      else {        while (__i != __last) {          if (__binary_pred(*__i, __val))            break;          ++__i;        }        __first = __i;      }    }    return __last;  }} // swap_rangestemplate <class _ForwardIter1, class _ForwardIter2>_ForwardIter2 swap_ranges(_ForwardIter1 __first1, _ForwardIter1 __last1,                          _ForwardIter2 __first2) {  for ( ; __first1 != __last1; ++__first1, ++__first2)    iter_swap(__first1, __first2);  return __first2;}// transformtemplate <class _InputIter, class _OutputIter, class _UnaryOperation>_OutputIter transform(_InputIter __first, _InputIter __last,                      _OutputIter __result, _UnaryOperation __opr) {  for ( ; __first != __last; ++__first, ++__result)    *__result = __opr(*__first);  return __result;}template <class _InputIter1, class _InputIter2, class _OutputIter,          class _BinaryOperation>_OutputIter transform(_InputIter1 __first1, _InputIter1 __last1,                      _InputIter2 __first2, _OutputIter __result,                      _BinaryOperation __binary_op) {  for ( ; __first1 != __last1; ++__first1, ++__first2, ++__result)    *__result = __binary_op(*__first1, *__first2);  return __result;}// replace, replace_if, replace_copy, replace_copy_iftemplate <class _ForwardIter, class _Tp>void replace(_ForwardIter __first, _ForwardIter __last,             const _Tp& __old_value, const _Tp& __new_value) {  for ( ; __first != __last; ++__first)    if (*__first == __old_value)      *__first = __new_value;}template <class _ForwardIter, class _Predicate, class _Tp>void replace_if(_ForwardIter __first, _ForwardIter __last,                _Predicate __pred, const _Tp& __new_value) {  for ( ; __first != __last; ++__first)    if (__pred(*__first))      *__first = __new_value;}template <class _InputIter, class _OutputIter, class _Tp>_OutputIter replace_copy(_InputIter __first, _InputIter __last,                         _OutputIter __result,                         const _Tp& __old_value, const _Tp& __new_value) {  for ( ; __first != __last; ++__first, ++__result)    *__result = *__first == __old_value ? __new_value : *__first;  return __result;}template <class Iterator, class _OutputIter, class _Predicate, class _Tp>_OutputIter replace_copy_if(Iterator __first, Iterator __last,                            _OutputIter __result,                            _Predicate __pred, const _Tp& __new_value) {  for ( ; __first != __last; ++__first, ++__result)    *__result = __pred(*__first) ? __new_value : *__first;  return __result;}// generate and generate_ntemplate <class _ForwardIter, class _Generator>void generate(_ForwardIter __first, _ForwardIter __last, _Generator __gen) {  for ( ; __first != __last; ++__first)    *__first = __gen();}template <class _OutputIter, class _Size, class _Generator>_OutputIter generate_n(_OutputIter __first, _Size __n, _Generator __gen) {  for ( ; __n > 0; --__n, ++__first)    *__first = __gen();  return __first;}// remove, remove_if, remove_copy, remove_copy_iftemplate <class _InputIter, class _OutputIter, class _Tp>_OutputIter remove_copy(_InputIter __first, _InputIter __last,                        _OutputIter __result, const _Tp& __value) {  for ( ; __first != __last; ++__first)    if (*__first != __value) {      *__result = *__first;      ++__result;    }  return __result;}template <class _InputIter, class _OutputIter, class _Predicate>_OutputIter remove_copy_if(_InputIter __first, _InputIter __last,                           _OutputIter __result, _Predicate __pred) {  for ( ; __first != __last; ++__first)    if (!__pred(*__first)) {      *__result = *__first;      ++__result;    }  return __result;}template <class _ForwardIter, class _Tp>_ForwardIter remove(_ForwardIter __first, _ForwardIter __last,                    const _Tp& __value) {  __first = find(__first, __last, __value);  _ForwardIter __i = __first;  return __first == __last ? __first                            : remove_copy(++__i, __last, __first, __value);}template <class _ForwardIter, class _Predicate>_ForwardIter remove_if(_ForwardIter __first, _ForwardIter __last,                       _Predicate __pred) {  __first = find_if(__first, __last, __pred);  _ForwardIter __i = __first;  return __first == __last ? __first                            : remove_copy_if(++__i, __last, __first, __pred);}// unique and unique_copytemplate <class _InputIter, class _OutputIter, class _Tp>_OutputIter __unique_copy(_InputIter __first, _InputIter __last,                          _OutputIter __result, _Tp*) {  _Tp __value = *__first;  *__result = __value;  while (++__first != __last)    if (__value != *__first) {      __value = *__first;      *++__result = __value;    }  return ++__result;}template <class _InputIter, class _OutputIter>inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,                                 _OutputIter __result,                                  output_iterator_tag) {  return __unique_copy(__first, __last, __result, __VALUE_TYPE(__first));}template <class _InputIter, class _ForwardIter>_ForwardIter __unique_copy(_InputIter __first, _InputIter __last,                           _ForwardIter __result, forward_iterator_tag) {  *__result = *__first;  while (++__first != __last)    if (*__result != *__first) *++__result = *__first;  return ++__result;}template <class _InputIter, class _OutputIter>inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,                               _OutputIter __result) {  if (__first == __last) return __result;  return __unique_copy(__first, __last, __result,                       __ITERATOR_CATEGORY(__result));}template <class _InputIter, class _OutputIter, class _BinaryPredicate,          class _Tp>_OutputIter __unique_copy(_InputIter __first, _InputIter __last,                          _OutputIter __result,                          _BinaryPredicate __binary_pred, _Tp*) {  _Tp __value = *__first;  *__result = __value;  while (++__first != __last)    if (!__binary_pred(__value, *__first)) {      __value = *__first;      *++__result = __value;    }  return ++__result;}template <class _InputIter, class _OutputIter, class _BinaryPredicate>inline _OutputIter __unique_copy(_InputIter __first, _InputIter __last,                                 _OutputIter __result,                                 _BinaryPredicate __binary_pred,                                 output_iterator_tag) {  return __unique_copy(__first, __last, __result, __binary_pred,                       __VALUE_TYPE(__first));}template <class _InputIter, class _ForwardIter, class _BinaryPredicate>_ForwardIter __unique_copy(_InputIter __first, _InputIter __last,                           _ForwardIter __result,                            _BinaryPredicate __binary_pred,                           forward_iterator_tag) {  *__result = *__first;  while (++__first != __last)    if (!__binary_pred(*__result, *__first)) *++__result = *__first;  return ++__result;}template <class _InputIter, class _OutputIter, class _BinaryPredicate>inline _OutputIter unique_copy(_InputIter __first, _InputIter __last,                               _OutputIter __result,                               _BinaryPredicate __binary_pred) {  if (__first == __last) return __result;  return __unique_copy(__first, __last, __result, __binary_pred,                       __ITERATOR_CATEGORY(__result));}template <class _ForwardIter>_ForwardIter unique(_ForwardIter __first, _ForwardIter __last) {  __first = adjacent_find(__first, __last);  return unique_copy(__first, __last, __first);}template <class _ForwardIter, class _BinaryPredicate>_ForwardIter unique(_ForwardIter __first, _ForwardIter __last,                    _BinaryPredicate __binary_pred) {  __first = adjacent_find(__first, __last, __binary_pred);  return unique_copy(__first, __last, __first, __binary_pred);}// reverse and reverse_copy, and their auxiliary functionstemplate <class _BidirectionalIter>void __reverse(_BidirectionalIter __first, _BidirectionalIter __last,                bidirectional_iterator_tag) {  while (true)    if (__first == __last || __first == --__last)      return;    else      iter_swap(__first++, __last);}template <class _RandomAccessIter>void __reverse(_RandomAccessIter __first, _RandomAccessIter __last,               random_access_iterator_tag) {  while (__first < __last)    iter_swap(__first++, --__last);}template <class _BidirectionalIter>inline void reverse(_BidirectionalIter __first, _BidirectionalIter __last) {  __reverse(__first, __last, __ITERATOR_CATEGORY(__first));}template <class _BidirectionalIter, class _OutputIter>_OutputIter reverse_copy(_BidirectionalIter __first,                            _BidirectionalIter __last,                            _OutputIter __result) {  while (__first != __last) {    --__last;    *__result = *__last;    ++__result;  }  return __result;}// rotate and rotate_copy, and their auxiliary functionstemplate <class _EuclideanRingElement>_EuclideanRingElement __gcd(_EuclideanRingElement __m,                            _EuclideanRingElement __n){  while (__n != 0) {    _EuclideanRingElement __t = __m % __n;    __m = __n;    __n = __t;  }  return __m;}template <class _ForwardIter, class _Distance>_ForwardIter __rotate(_ForwardIter __first,                      _ForwardIter __middle,                      _ForwardIter __last,                      _Distance*,                      forward_iterator_tag) {  if (__first == __middle)    return __last;  if (__last  == __middle)    return __first;  _ForwardIter __first2 = __middle;  do {    swap(*__first++, *__first2++);    if (__first == __middle)      __middle = __first2;  } while (__first2 != __last);  _ForwardIter __new_middle = __first;  __first2 = __middle;  while (__first2 != __last) {    swap (*__first++, *__first2++);    if (__first == __middle)      __middle = __first2;    else if (__first2 == __last)      __first2 = __middle;  }  return __new_middle;}template <class _BidirectionalIter, class _Distance>_BidirectionalIter __rotate(_BidirectionalIter __first,                            _BidirectionalIter __middle,                            _BidirectionalIter __last,                            _Distance*,                            bidirectional_iterator_tag) {  if (__first == __middle)    return __last;  if (__last  == __middle)    return __first;  __reverse(__first,  __middle, bidirectional_iterator_tag());  __reverse(__middle, __last,   bidirectional_iterator_tag());  while (__first != __middle && __middle != __last)    swap (*__first++, *--__last);  if (__first == __middle) {    __reverse(__middle, __last,   bidirectional_iterator_tag());    return __last;  }  else {    __reverse(__first,  __middle, bidirectional_iterator_tag());    return __first;  }}template <class _RandomAccessIter, class _Distance, class _Tp>_RandomAccessIter __rotate(_RandomAccessIter __first,                           _RandomAccessIter __middle,                           _RandomAccessIter __last,                           _Distance *, _Tp *) {  _Distance __n = __last   - __first;  _Distance __k = __middle - __first;  _Distance __l = __n - __k;  _RandomAccessIter __result = __first + (__last - __middle);  if (__k == 0)    return __last;  else if (__k == __l) {    swap_ranges(__first, __middle, __middle);    return __result;  }  _Distance __d = __gcd(__n, __k);  for (_Distance __i = 0; __i < __d; __i++) {    _Tp __tmp = *__first;    _RandomAccessIter __p = __first;    if (__k < __l) {      for (_Distance __j = 0; __j < __l/__d; __j++) {        if (__p > __first + __l) {          *__p = *(__p - __l);          __p -= __l;        }        *__p = *(__p + __k);        __p += __k;      }    }    else {      for (_Distance __j = 0; __j < __k/__d - 1; __j ++) {        if (__p < __last - __k) {          *__p = *(__p + __k);          __p += __k;        }        *__p = * (__p - __l);        __p -= __l;      }    }    *__p = __tmp;    ++__first;  }  return __result;}