typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = asin(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> atan(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = atan(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> atan2(const valarray<_Tp>& __x,                           const valarray<_Tp>& __y) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = atan2(__x[__i], __y[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> atan2(const valarray<_Tp>& __x, const _Tp& __c) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = atan2(__x[__i], __c);  return __tmp;}template <class _Tp>inline valarray<_Tp> atan2(const _Tp& __c, const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = atan2(__c, __x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> cos(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = cos(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> cosh(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = cosh(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> exp(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = exp(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> log(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = log(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> log10(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = log10(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> pow(const valarray<_Tp>& __x,                           const valarray<_Tp>& __y) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = pow(__x[__i], __y[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> pow(const valarray<_Tp>& __x, const _Tp& __c) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = pow(__x[__i], __c);  return __tmp;}template <class _Tp>inline valarray<_Tp> pow(const _Tp& __c, const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = pow(__c, __x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> sin(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = sin(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> sinh(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = sinh(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> sqrt(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = sqrt(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> tan(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = tan(__x[__i]);  return __tmp;}template <class _Tp>inline valarray<_Tp> tanh(const valarray<_Tp>& __x) {  typedef typename valarray<_Tp>::_NoInit _NoInit;  valarray<_Tp> __tmp(__x.size(), _NoInit());  for (size_t __i = 0; __i < __x.size(); ++__i)    __tmp[__i] = tanh(__x[__i]);  return __tmp;}//----------------------------------------------------------------------// slice and slice_arrayclass slice {public:  slice() : _M_start(0), _M_length(0), _M_stride(0) {}  slice(size_t __start, size_t __length, size_t __stride)    : _M_start(__start), _M_length(__length), _M_stride(__stride)    {}  size_t start()  const { return _M_start; }  size_t size()   const { return _M_length; }  size_t stride() const { return _M_stride; }   private:  size_t _M_start;  size_t _M_length;  size_t _M_stride;};template <class _Tp>class slice_array {  friend class valarray<_Tp>;public:  typedef _Tp value_type;  void operator=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] = __x[__i];  }  void operator*=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] *= __x[__i];  }  void operator/=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] /= __x[__i];  }  void operator%=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] %= __x[__i];  }  void operator+=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] += __x[__i];  }  void operator-=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] -= __x[__i];  }  void operator^=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] ^= __x[__i];  }  void operator&=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] &= __x[__i];  }  void operator|=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] |= __x[__i];  }  void operator<<=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] <<= __x[__i];  }  void operator>>=(const valarray<value_type>& __x) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] >>= __x[__i];  }  void operator=(const value_type& __c) const {    size_t __index = _M_slice.start();    for (size_t __i = 0;         __i < _M_slice.size();         ++__i, __index += _M_slice.stride())      _M_array[__index] = __c;  }  ~slice_array() {}private:  slice_array(const slice& __slice, valarray<_Tp>& __array)    : _M_slice(__slice), _M_array(__array)    {}  slice          _M_slice;  valarray<_Tp>& _M_array;private:                        // Disable assignment and default constructor  slice_array();};// valarray member functions dealing with slice and slice_arraytemplate <class _Tp>inline valarray<_Tp>::valarray(const slice_array<_Tp>& __x)  : _Valarray_base<_Tp>(__x._M_slice.size()){  typedef typename __type_traits<_Tp>::has_trivial_default_constructor          _Is_Trivial;  _M_initialize(_Is_Trivial());    *this = __x;}// Behavior is undefined if __x and *this have different sizestemplate <class _Tp>valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<_Tp>& __x){  size_t __index = __x._M_slice.start();  for (size_t __i = 0;       __i < __x._M_slice.size();       ++__i, __index += __x._M_slice.stride())    (*this)[__i] = __x._M_array[__index];  return *this;}template <class _Tp>valarray<_Tp> valarray<_Tp>::operator[](slice __slice) const {  valarray<_Tp> __tmp(__slice.size(), _NoInit());  size_t __index = __slice.start();  for (size_t __i = 0;       __i < __slice.size();       ++__i, __index += __slice.stride())    __tmp[__i] = (*this)[__index];  return __tmp;}template <class _Tp>inline slice_array<_Tp> valarray<_Tp>::operator[](slice __slice) {  return slice_array<_Tp>(__slice, *this);}//----------------------------------------------------------------------// gslice and gslice_arraystruct _Gslice_Iter;class gslice {  friend struct _Gslice_Iter;public:  gslice() : _M_start(0), _M_lengths(0), _M_strides(0) {}  gslice(size_t __start,         const valarray<size_t>& __lengths, const valarray<size_t>& __strides)    : _M_start(__start), _M_lengths(__lengths), _M_strides(__strides)    {}  size_t start()            const { return _M_start; }  valarray<size_t> size()   const { return _M_lengths; }  valarray<size_t> stride() const { return _M_strides; }  // Extension: check for an empty gslice.  bool _M_empty() const { return _M_lengths.size() == 0; }  // Extension: number of indices this gslice represents.  (For a degenerate  // gslice, they're not necessarily all distinct.)  size_t _M_size() const {    return !this->_M_empty()      ? accumulate(_M_lengths._M_first + 1,                   _M_lengths._M_first + _M_lengths._M_size,                   _M_lengths[0],                   multiplies<size_t>())      : 0;  }private:  size_t _M_start;  valarray<size_t> _M_lengths;  valarray<size_t> _M_strides;};// This is not an STL iterator.  It is constructed from a gslice, and it// steps through the gslice indices in sequence.  See 23.3.6 of the C++// standard, paragraphs 2-3, for an explanation of the sequence.  At// each step we get two things: the ordinal (i.e. number of steps taken),// and the one-dimensional index.struct _Gslice_Iter {  _Gslice_Iter(const gslice& __gslice)    : _M_step(0), _M_1d_idx(__gslice.start()),      _M_indices(size_t(0), __gslice._M_lengths.size()),      _M_gslice(__gslice)    {}      bool _M_done() const { return _M_indices[0] == _M_gslice._M_lengths[0]; }  bool _M_incr() {    size_t __dim = _M_indices.size() - 1;    ++_M_step;    while (true) {      _M_1d_idx += _M_gslice._M_strides[__dim];      if (++_M_indices[__dim] != _M_gslice._M_lengths[__dim])        return true;      else if (__dim != 0) {        _M_1d_idx -=          _M_gslice._M_strides[__dim] * _M_gslice._M_lengths[__dim];        _M_indices[__dim] = 0;        --__dim;      }      else        return false;    }  }  size_t _M_step;  size_t _M_1d_idx;  valarray<size_t> _M_indices;  const gslice& _M_gslice;};template <class _Tp>class gslice_array {  friend class valarray<_Tp>;public:  typedef _Tp value_type;  void operator= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] = __x[__i._M_step]; while(__i._M_incr());    }  }  void operator*= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] *= __x[__i._M_step]; while(__i._M_incr());    }  }  void operator/= (const valarray<value_type>& __x) const {    if (!_M_gslice._M_empty()) {      _Gslice_Iter __i(_M_gslice);      do _M_array[__i._M_1d_idx] /= __x[__i._M_step]; while(__i._M_incr());    }  }