path: root/contrib/libs/cxxsupp/libcxx/include/istream

// -*- C++ -*- 
//===--------------------------- istream ----------------------------------===// 
// 
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// 
//===----------------------------------------------------------------------===// 
 
#ifndef _LIBCPP_ISTREAM 
#define _LIBCPP_ISTREAM 
 
/* 
    istream synopsis 
 
template <class charT, class traits = char_traits<charT> > 
class basic_istream 
    : virtual public basic_ios<charT,traits> 
{ 
public: 
    // types (inherited from basic_ios (27.5.4)): 
    typedef charT                          char_type; 
    typedef traits                         traits_type; 
    typedef typename traits_type::int_type int_type; 
    typedef typename traits_type::pos_type pos_type; 
    typedef typename traits_type::off_type off_type; 
 
    // 27.7.1.1.1 Constructor/destructor: 
    explicit basic_istream(basic_streambuf<char_type, traits_type>* sb); 
    basic_istream(basic_istream&& rhs); 
    virtual ~basic_istream(); 
 
    // 27.7.1.1.2 Assign/swap: 
    basic_istream& operator=(basic_istream&& rhs); 
    void swap(basic_istream& rhs); 
 
    // 27.7.1.1.3 Prefix/suffix: 
    class sentry; 
 
    // 27.7.1.2 Formatted input: 
    basic_istream& operator>>(basic_istream& (*pf)(basic_istream&)); 
    basic_istream& operator>>(basic_ios<char_type, traits_type>& 
                              (*pf)(basic_ios<char_type, traits_type>&)); 
    basic_istream& operator>>(ios_base& (*pf)(ios_base&)); 
    basic_istream& operator>>(basic_streambuf<char_type, traits_type>* sb); 
    basic_istream& operator>>(bool& n); 
    basic_istream& operator>>(short& n); 
    basic_istream& operator>>(unsigned short& n); 
    basic_istream& operator>>(int& n); 
    basic_istream& operator>>(unsigned int& n); 
    basic_istream& operator>>(long& n); 
    basic_istream& operator>>(unsigned long& n); 
    basic_istream& operator>>(long long& n); 
    basic_istream& operator>>(unsigned long long& n); 
    basic_istream& operator>>(float& f); 
    basic_istream& operator>>(double& f); 
    basic_istream& operator>>(long double& f); 
    basic_istream& operator>>(void*& p); 
 
    // 27.7.1.3 Unformatted input: 
    streamsize gcount() const; 
    int_type get(); 
    basic_istream& get(char_type& c); 
    basic_istream& get(char_type* s, streamsize n); 
    basic_istream& get(char_type* s, streamsize n, char_type delim); 
    basic_istream& get(basic_streambuf<char_type,traits_type>& sb); 
    basic_istream& get(basic_streambuf<char_type,traits_type>& sb, char_type delim); 
 
    basic_istream& getline(char_type* s, streamsize n); 
    basic_istream& getline(char_type* s, streamsize n, char_type delim); 
 
    basic_istream& ignore(streamsize n = 1, int_type delim = traits_type::eof()); 
    int_type peek(); 
    basic_istream& read (char_type* s, streamsize n); 
    streamsize readsome(char_type* s, streamsize n); 
 
    basic_istream& putback(char_type c); 
    basic_istream& unget(); 
    int sync(); 
 
    pos_type tellg(); 
    basic_istream& seekg(pos_type); 
    basic_istream& seekg(off_type, ios_base::seekdir); 
protected: 
    basic_istream(const basic_istream& rhs) = delete; 
    basic_istream(basic_istream&& rhs); 
    // 27.7.2.1.2 Assign/swap: 
    basic_istream& operator=(const basic_istream& rhs) = delete; 
    basic_istream& operator=(basic_istream&& rhs); 
    void swap(basic_istream& rhs); 
}; 
 
// 27.7.1.2.3 character extraction templates: 
template<class charT, class traits> 
  basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, charT&); 
 
template<class traits> 
  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, unsigned char&); 
 
template<class traits> 
  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, signed char&); 
 
template<class charT, class traits> 
  basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, charT*); 
 
template<class traits> 
  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, unsigned char*); 
 
template<class traits> 
  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, signed char*); 
 
template <class charT, class traits> 
  void 
  swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y); 
 
typedef basic_istream<char> istream; 
typedef basic_istream<wchar_t> wistream; 
 
template <class charT, class traits = char_traits<charT> > 
class basic_iostream : 
    public basic_istream<charT,traits>, 
    public basic_ostream<charT,traits> 
{ 
public: 
    // types: 
    typedef charT                          char_type; 
    typedef traits                         traits_type; 
    typedef typename traits_type::int_type int_type; 
    typedef typename traits_type::pos_type pos_type; 
    typedef typename traits_type::off_type off_type; 
 
    // constructor/destructor 
    explicit basic_iostream(basic_streambuf<char_type, traits_type>* sb); 
    basic_iostream(basic_iostream&& rhs); 
    virtual ~basic_iostream(); 
 
    // assign/swap 
    basic_iostream& operator=(basic_iostream&& rhs); 
    void swap(basic_iostream& rhs); 
}; 
 
template <class charT, class traits> 
  void 
  swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y); 
 
typedef basic_iostream<char> iostream; 
typedef basic_iostream<wchar_t> wiostream; 
 
template <class charT, class traits> 
  basic_istream<charT,traits>& 
  ws(basic_istream<charT,traits>& is); 
 
// rvalue stream extraction 
template <class Stream, class T> 
  Stream&& operator>>(Stream&& is, T&& x); 
 
}  // std 
 
*/ 
 
#include <__config> 
#include <__utility/forward.h> 
#include <ostream> 
#include <version>
 
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 
#pragma GCC system_header 
#endif 
 
_LIBCPP_PUSH_MACROS 
#include <__undef_macros> 
 
 
_LIBCPP_BEGIN_NAMESPACE_STD 
 
template <class _CharT, class _Traits> 
class _LIBCPP_TEMPLATE_VIS basic_istream 
    : virtual public basic_ios<_CharT, _Traits> 
{ 
    streamsize __gc_; 
public: 
    // types (inherited from basic_ios (27.5.4)): 
    typedef _CharT                         char_type; 
    typedef _Traits                        traits_type; 
    typedef typename traits_type::int_type int_type; 
    typedef typename traits_type::pos_type pos_type; 
    typedef typename traits_type::off_type off_type; 
 
    // 27.7.1.1.1 Constructor/destructor: 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb) : __gc_(0) 
    { this->init(__sb); } 
    virtual ~basic_istream(); 
protected: 
    inline _LIBCPP_INLINE_VISIBILITY 
    basic_istream(basic_istream&& __rhs); 
 
    // 27.7.1.1.2 Assign/swap: 
    inline _LIBCPP_INLINE_VISIBILITY 
    basic_istream& operator=(basic_istream&& __rhs); 
 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    void swap(basic_istream& __rhs) { 
      _VSTD::swap(__gc_, __rhs.__gc_); 
      basic_ios<char_type, traits_type>::swap(__rhs); 
    } 
 
    basic_istream           (const basic_istream& __rhs) = delete; 
    basic_istream& operator=(const basic_istream& __rhs) = delete; 
public: 
 
    // 27.7.1.1.3 Prefix/suffix: 
    class _LIBCPP_TEMPLATE_VIS sentry; 
 
    // 27.7.1.2 Formatted input: 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)) 
    { return __pf(*this); } 
 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    basic_istream& operator>>(basic_ios<char_type, traits_type>& 
                              (*__pf)(basic_ios<char_type, traits_type>&)) 
    { __pf(*this); return *this; } 
 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    basic_istream& operator>>(ios_base& (*__pf)(ios_base&)) 
    { __pf(*this); return *this; } 
 
    basic_istream& operator>>(basic_streambuf<char_type, traits_type>* __sb); 
    basic_istream& operator>>(bool& __n); 
    basic_istream& operator>>(short& __n); 
    basic_istream& operator>>(unsigned short& __n); 
    basic_istream& operator>>(int& __n); 
    basic_istream& operator>>(unsigned int& __n); 
    basic_istream& operator>>(long& __n); 
    basic_istream& operator>>(unsigned long& __n); 
    basic_istream& operator>>(long long& __n); 
    basic_istream& operator>>(unsigned long long& __n); 
    basic_istream& operator>>(float& __f); 
    basic_istream& operator>>(double& __f); 
    basic_istream& operator>>(long double& __f); 
    basic_istream& operator>>(void*& __p); 
 
    // 27.7.1.3 Unformatted input: 
    _LIBCPP_INLINE_VISIBILITY 
    streamsize gcount() const {return __gc_;} 
    int_type get(); 
 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    basic_istream& get(char_type& __c) { 
      int_type __ch = get(); 
      if (__ch != traits_type::eof()) 
        __c = traits_type::to_char_type(__ch); 
      return *this; 
    } 
 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    basic_istream& get(char_type* __s, streamsize __n) 
    { return get(__s, __n, this->widen('\n')); } 
 
    basic_istream& get(char_type* __s, streamsize __n, char_type __dlm); 
 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    basic_istream& get(basic_streambuf<char_type, traits_type>& __sb) 
    { return get(__sb, this->widen('\n')); } 
 
    basic_istream& get(basic_streambuf<char_type, traits_type>& __sb, char_type __dlm); 
 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    basic_istream& getline(char_type* __s, streamsize __n) 
    { return getline(__s, __n, this->widen('\n')); } 
 
    basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm); 
 
    basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof()); 
    int_type peek(); 
    basic_istream& read (char_type* __s, streamsize __n); 
    streamsize readsome(char_type* __s, streamsize __n); 
 
    basic_istream& putback(char_type __c); 
    basic_istream& unget(); 
    int sync(); 
 
    pos_type tellg(); 
    basic_istream& seekg(pos_type __pos); 
    basic_istream& seekg(off_type __off, ios_base::seekdir __dir); 
}; 
 
template <class _CharT, class _Traits> 
class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry 
{ 
    bool __ok_; 
 
    sentry(const sentry&); // = delete; 
    sentry& operator=(const sentry&); // = delete; 
 
public: 
    explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); 
//    ~sentry() = default; 
 
    _LIBCPP_INLINE_VISIBILITY 
    explicit operator bool() const {return __ok_;} 
}; 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is, 
                                               bool __noskipws) 
    : __ok_(false) 
{ 
    if (__is.good()) 
    { 
        if (__is.tie()) 
            __is.tie()->flush(); 
        if (!__noskipws && (__is.flags() & ios_base::skipws)) 
        { 
            typedef istreambuf_iterator<_CharT, _Traits> _Ip; 
            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 
            _Ip __i(__is); 
            _Ip __eof; 
            for (; __i != __eof; ++__i) 
                if (!__ct.is(__ct.space, *__i)) 
                    break; 
            if (__i == __eof) 
                __is.setstate(ios_base::failbit | ios_base::eofbit); 
        } 
        __ok_ = __is.good(); 
    } 
    else 
        __is.setstate(ios_base::failbit); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs) 
    : __gc_(__rhs.__gc_) 
{ 
    __rhs.__gc_ = 0; 
    this->move(__rhs); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs) 
{ 
    swap(__rhs); 
    return *this; 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>::~basic_istream() 
{ 
} 
 
template <class _Tp, class _CharT, class _Traits> 
_LIBCPP_INLINE_VISIBILITY 
basic_istream<_CharT, _Traits>& 
__input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) { 
    ios_base::iostate __state = ios_base::goodbit; 
    typename basic_istream<_CharT, _Traits>::sentry __s(__is); 
    if (__s) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            typedef istreambuf_iterator<_CharT, _Traits> _Ip; 
            typedef num_get<_CharT, _Ip> _Fp; 
            use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n); 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            __is.__setstate_nothrow(__state); 
            if (__is.exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        } 
#endif 
        __is.setstate(__state); 
    } 
    return __is; 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n) 
{
    return _VSTD::__input_arithmetic<unsigned short>(*this, __n); 
}
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n) 
{
    return _VSTD::__input_arithmetic<unsigned int>(*this, __n); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(long& __n) 
{ 
    return _VSTD::__input_arithmetic<long>(*this, __n); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n) 
{ 
    return _VSTD::__input_arithmetic<unsigned long>(*this, __n); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(long long& __n) 
{ 
    return _VSTD::__input_arithmetic<long long>(*this, __n); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n) 
{ 
    return _VSTD::__input_arithmetic<unsigned long long>(*this, __n); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(float& __n) 
{ 
    return _VSTD::__input_arithmetic<float>(*this, __n); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(double& __n) 
{ 
    return _VSTD::__input_arithmetic<double>(*this, __n); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(long double& __n) 
{ 
    return _VSTD::__input_arithmetic<long double>(*this, __n); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(bool& __n) 
{ 
    return _VSTD::__input_arithmetic<bool>(*this, __n); 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(void*& __n) 
{ 
    return _VSTD::__input_arithmetic<void*>(*this, __n); 
} 
 
template <class _Tp, class _CharT, class _Traits> 
_LIBCPP_INLINE_VISIBILITY 
basic_istream<_CharT, _Traits>& 
__input_arithmetic_with_numeric_limits(basic_istream<_CharT, _Traits>& __is, _Tp& __n) { 
    ios_base::iostate __state = ios_base::goodbit; 
    typename basic_istream<_CharT, _Traits>::sentry __s(__is); 
    if (__s) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            typedef istreambuf_iterator<_CharT, _Traits> _Ip; 
            typedef num_get<_CharT, _Ip> _Fp; 
            long __temp; 
            use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __temp); 
            if (__temp < numeric_limits<_Tp>::min()) 
            { 
                __state |= ios_base::failbit; 
                __n = numeric_limits<_Tp>::min(); 
            } 
            else if (__temp > numeric_limits<_Tp>::max()) 
            { 
                __state |= ios_base::failbit; 
                __n = numeric_limits<_Tp>::max(); 
            } 
            else 
            { 
                __n = static_cast<_Tp>(__temp); 
            }
#ifndef _LIBCPP_NO_EXCEPTIONS
        } 
        catch (...)
        {
            __state |= ios_base::badbit; 
            __is.__setstate_nothrow(__state); 
            if (__is.exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
        __is.setstate(__state); 
    } 
    return __is; 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(short& __n) 
{
    return _VSTD::__input_arithmetic_with_numeric_limits<short>(*this, __n); 
}
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(int& __n) 
{
    return _VSTD::__input_arithmetic_with_numeric_limits<int>(*this, __n); 
} 
 
template<class _CharT, class _Traits>
_LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>& 
__input_c_string(basic_istream<_CharT, _Traits>& __is, _CharT* __p, size_t __n)
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
    if (__sen)
    {
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif 
            _CharT* __s = __p; 
            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 
            while (__s != __p + (__n-1))
            { 
                typename _Traits::int_type __i = __is.rdbuf()->sgetc(); 
                if (_Traits::eq_int_type(__i, _Traits::eof())) 
                { 
                   __state |= ios_base::eofbit; 
                   break; 
                } 
                _CharT __ch = _Traits::to_char_type(__i); 
                if (__ct.is(__ct.space, __ch)) 
                    break; 
                *__s++ = __ch; 
                 __is.rdbuf()->sbumpc(); 
            } 
            *__s = _CharT(); 
            __is.width(0); 
            if (__s == __p)
               __state |= ios_base::failbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            __is.__setstate_nothrow(__state); 
            if (__is.exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        } 
#endif 
        __is.setstate(__state); 
    } 
    return __is; 
} 
 
#if _LIBCPP_STD_VER > 17

template<class _CharT, class _Traits, size_t _Np>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _CharT (&__buf)[_Np])
{
    size_t __n = _Np; 
    if (__is.width() > 0)
        __n = _VSTD::min(size_t(__is.width()), _Np);
    return _VSTD::__input_c_string(__is, __buf, __n);
}

template<class _Traits, size_t _Np>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __is, unsigned char (&__buf)[_Np])
{
    return __is >> (char(&)[_Np])__buf;
}

template<class _Traits, size_t _Np>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<char, _Traits>&
operator>>(basic_istream<char, _Traits>& __is, signed char (&__buf)[_Np])
{
    return __is >> (char(&)[_Np])__buf;
}

#else

template<class _CharT, class _Traits>
inline _LIBCPP_INLINE_VISIBILITY
basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
{
    streamsize __n = __is.width();
    if (__n <= 0)
        __n = numeric_limits<streamsize>::max() / sizeof(_CharT) - 1;
    return _VSTD::__input_c_string(__is, __s, size_t(__n));
}

template<class _Traits> 
inline _LIBCPP_INLINE_VISIBILITY 
basic_istream<char, _Traits>& 
operator>>(basic_istream<char, _Traits>& __is, unsigned char* __s) 
{ 
    return __is >> (char*)__s; 
} 
 
template<class _Traits> 
inline _LIBCPP_INLINE_VISIBILITY 
basic_istream<char, _Traits>& 
operator>>(basic_istream<char, _Traits>& __is, signed char* __s) 
{ 
    return __is >> (char*)__s; 
} 
 
#endif // _LIBCPP_STD_VER > 17 

template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
    if (__sen)
    {
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif 
            typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); 
            if (_Traits::eq_int_type(__i, _Traits::eof())) 
                __state |= ios_base::eofbit | ios_base::failbit; 
            else 
                __c = _Traits::to_char_type(__i); 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            __is.__setstate_nothrow(__state); 
            if (__is.exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        } 
#endif 
        __is.setstate(__state); 
    } 
    return __is; 
} 
 
template<class _Traits> 
inline _LIBCPP_INLINE_VISIBILITY 
basic_istream<char, _Traits>& 
operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c) 
{ 
    return __is >> (char&)__c; 
} 
 
template<class _Traits> 
inline _LIBCPP_INLINE_VISIBILITY 
basic_istream<char, _Traits>& 
operator>>(basic_istream<char, _Traits>& __is, signed char& __c) 
{ 
    return __is >> (char&)__c; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_type>* __sb) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    __gc_ = 0; 
    sentry __s(*this, true);
    if (__s)
    {
        if (__sb)
        { 
#ifndef _LIBCPP_NO_EXCEPTIONS
            try
            { 
#endif // _LIBCPP_NO_EXCEPTIONS
                while (true)
                { 
                    typename traits_type::int_type __i = this->rdbuf()->sgetc();
                    if (traits_type::eq_int_type(__i, _Traits::eof()))
                    { 
                       __state |= ios_base::eofbit; 
                       break;
                    } 
                    if (traits_type::eq_int_type(
                            __sb->sputc(traits_type::to_char_type(__i)),
                            traits_type::eof()))
                        break;
                    ++__gc_;
                    this->rdbuf()->sbumpc();
                }
                if (__gc_ == 0)
                   __state |= ios_base::failbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
            }
            catch (...)
            {
                __state |= ios_base::badbit; 
                if (__gc_ == 0)
                    __state |= ios_base::failbit; 
 
                this->__setstate_nothrow(__state); 
                if (this->exceptions() & ios_base::failbit || this->exceptions() & ios_base::badbit) 
                { 
                    throw; 
                } 
            }
#endif // _LIBCPP_NO_EXCEPTIONS 
        }
        else
        {
            __state |= ios_base::failbit; 
        } 
        this->setstate(__state); 
    } 
    return *this; 
} 
 
template<class _CharT, class _Traits> 
typename basic_istream<_CharT, _Traits>::int_type 
basic_istream<_CharT, _Traits>::get() 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    __gc_ = 0; 
    int_type __r = traits_type::eof(); 
    sentry __s(*this, true);
    if (__s)
    {
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif 
            __r = this->rdbuf()->sbumpc(); 
            if (traits_type::eq_int_type(__r, traits_type::eof())) 
               __state |= ios_base::failbit | ios_base::eofbit; 
            else 
                __gc_ = 1; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            this->__setstate_nothrow(this->rdstate() | ios_base::badbit); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        } 
#endif 
        this->setstate(__state); 
    } 
    return __r; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    __gc_ = 0; 
    sentry __sen(*this, true);
    if (__sen)
    {
        if (__n > 0)
        { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
            try 
            { 
#endif 
                while (__gc_ < __n-1) 
                { 
                    int_type __i = this->rdbuf()->sgetc(); 
                    if (traits_type::eq_int_type(__i, traits_type::eof())) 
                    { 
                       __state |= ios_base::eofbit; 
                       break; 
                    } 
                    char_type __ch = traits_type::to_char_type(__i); 
                    if (traits_type::eq(__ch, __dlm)) 
                        break; 
                    *__s++ = __ch; 
                    ++__gc_; 
                     this->rdbuf()->sbumpc(); 
                } 
                if (__gc_ == 0) 
                   __state |= ios_base::failbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
            }
            catch (...) 
            { 
                __state |= ios_base::badbit; 
                this->__setstate_nothrow(__state); 
                if (this->exceptions() & ios_base::badbit) 
                { 
                    if (__n > 0)
                        *__s = char_type();
                    throw; 
                }
            } 
#endif 
        } 
        else 
        {
            __state |= ios_base::failbit; 
        } 
 
        if (__n > 0) 
            *__s = char_type(); 
        this->setstate(__state); 
    } 
    if (__n > 0) 
        *__s = char_type(); 
    return *this; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb, 
                                    char_type __dlm) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    __gc_ = 0; 
    sentry __sen(*this, true);
    if (__sen)
    {
#ifndef _LIBCPP_NO_EXCEPTIONS
        try
        { 
#endif // _LIBCPP_NO_EXCEPTIONS 
            while (true)
            { 
                typename traits_type::int_type __i = this->rdbuf()->sgetc();
                if (traits_type::eq_int_type(__i, traits_type::eof()))
                { 
                   __state |= ios_base::eofbit; 
                   break;
                } 
                char_type __ch = traits_type::to_char_type(__i);
                if (traits_type::eq(__ch, __dlm))
                    break;
                if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
                    break;
                ++__gc_;
                this->rdbuf()->sbumpc();
            }
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            // according to the spec, exceptions here are caught but not rethrown 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
        if (__gc_ == 0)
           __state |= ios_base::failbit; 
        this->setstate(__state); 
    }
    return *this; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    __gc_ = 0; 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            while (true) 
            { 
                typename traits_type::int_type __i = this->rdbuf()->sgetc(); 
                if (traits_type::eq_int_type(__i, traits_type::eof())) 
                { 
                   __state |= ios_base::eofbit; 
                   break; 
                } 
                char_type __ch = traits_type::to_char_type(__i); 
                if (traits_type::eq(__ch, __dlm)) 
                { 
                    this->rdbuf()->sbumpc(); 
                    ++__gc_; 
                    break; 
                } 
                if (__gc_ >= __n-1) 
                { 
                    __state |= ios_base::failbit; 
                    break; 
                } 
                *__s++ = __ch; 
                this->rdbuf()->sbumpc(); 
                ++__gc_; 
            } 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                if (__n > 0)
                    *__s = char_type();
                if (__gc_ == 0) 
                    __state |= ios_base::failbit; 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
    } 
    if (__n > 0) 
        *__s = char_type(); 
    if (__gc_ == 0) 
        __state |= ios_base::failbit; 
    this->setstate(__state); 
    return *this; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    __gc_ = 0; 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            if (__n == numeric_limits<streamsize>::max()) 
            { 
                while (true) 
                { 
                    typename traits_type::int_type __i = this->rdbuf()->sbumpc(); 
                    if (traits_type::eq_int_type(__i, traits_type::eof())) 
                    { 
                       __state |= ios_base::eofbit; 
                       break; 
                    } 
                    ++__gc_; 
                    if (traits_type::eq_int_type(__i, __dlm)) 
                        break; 
                } 
            } 
            else 
            { 
                while (__gc_ < __n) 
                { 
                    typename traits_type::int_type __i = this->rdbuf()->sbumpc(); 
                    if (traits_type::eq_int_type(__i, traits_type::eof())) 
                    { 
                       __state |= ios_base::eofbit; 
                       break; 
                    } 
                    ++__gc_; 
                    if (traits_type::eq_int_type(__i, __dlm)) 
                        break; 
                } 
            } 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
        this->setstate(__state); 
    } 
    return *this; 
} 
 
template<class _CharT, class _Traits> 
typename basic_istream<_CharT, _Traits>::int_type 
basic_istream<_CharT, _Traits>::peek() 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    __gc_ = 0; 
    int_type __r = traits_type::eof(); 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            __r = this->rdbuf()->sgetc(); 
            if (traits_type::eq_int_type(__r, traits_type::eof())) 
                __state |= ios_base::eofbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
        this->setstate(__state); 
    } 
    return __r; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    __gc_ = 0; 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            __gc_ = this->rdbuf()->sgetn(__s, __n); 
            if (__gc_ != __n) 
                __state |= ios_base::failbit | ios_base::eofbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
    } 
    else 
    { 
        __state |= ios_base::failbit; 
    } 
    this->setstate(__state); 
    return *this; 
} 
 
template<class _CharT, class _Traits> 
streamsize 
basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    __gc_ = 0; 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            streamsize __c = this->rdbuf()->in_avail(); 
            switch (__c) 
            { 
            case -1: 
                __state |= ios_base::eofbit; 
                break; 
            case 0: 
                break; 
            default: 
                __n = _VSTD::min(__c, __n); 
                __gc_ = this->rdbuf()->sgetn(__s, __n); 
                if (__gc_ != __n) 
                    __state |= ios_base::failbit | ios_base::eofbit; 
                break; 
            } 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
    } 
    else 
    { 
        __state |= ios_base::failbit; 
    } 
    this->setstate(__state); 
    return __gc_; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::putback(char_type __c) 
{ 
    ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; 
    __gc_ = 0; 
    this->clear(__state); 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            if (this->rdbuf() == nullptr || this->rdbuf()->sputbackc(__c) == traits_type::eof()) 
                __state |= ios_base::badbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
    } 
    else 
    { 
        __state |= ios_base::failbit; 
    } 
    this->setstate(__state); 
    return *this; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::unget() 
{ 
    ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; 
    __gc_ = 0; 
    this->clear(__state); 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            if (this->rdbuf() == nullptr || this->rdbuf()->sungetc() == traits_type::eof()) 
                __state |= ios_base::badbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
    } 
    else 
    { 
        __state |= ios_base::failbit; 
    } 
    this->setstate(__state); 
    return *this; 
} 
 
template<class _CharT, class _Traits> 
int 
basic_istream<_CharT, _Traits>::sync() 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    int __r = 0; 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            if (this->rdbuf() == nullptr) 
                return -1; 
            if (this->rdbuf()->pubsync() == -1) 
            { 
                __state |= ios_base::badbit; 
                return -1; 
            } 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
        this->setstate(__state); 
    } 
    return __r; 
} 
 
template<class _CharT, class _Traits> 
typename basic_istream<_CharT, _Traits>::pos_type 
basic_istream<_CharT, _Traits>::tellg() 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    pos_type __r(-1); 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
        __r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
        this->setstate(__state); 
    } 
    return __r; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::seekg(pos_type __pos) 
{ 
    ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; 
    this->clear(__state); 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1)) 
                __state |= ios_base::failbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
        this->setstate(__state); 
    } 
    return *this; 
} 
 
template<class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) 
{ 
    ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; 
    this->clear(__state); 
    sentry __sen(*this, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1)) 
                __state |= ios_base::failbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            this->__setstate_nothrow(__state); 
            if (this->exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
        this->setstate(__state); 
    } 
    return *this; 
} 
 
template <class _CharT, class _Traits> 
basic_istream<_CharT, _Traits>& 
ws(basic_istream<_CharT, _Traits>& __is) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); 
    if (__sen) 
    { 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try
        {
#endif // _LIBCPP_NO_EXCEPTIONS 
            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 
            while (true) 
            { 
                typename _Traits::int_type __i = __is.rdbuf()->sgetc(); 
                if (_Traits::eq_int_type(__i, _Traits::eof())) 
                { 
                   __state |= ios_base::eofbit; 
                   break; 
                } 
                if (!__ct.is(__ct.space, _Traits::to_char_type(__i))) 
                    break; 
                __is.rdbuf()->sbumpc(); 
            } 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            __is.__setstate_nothrow(__state); 
            if (__is.exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        }
#endif // _LIBCPP_NO_EXCEPTIONS 
        __is.setstate(__state); 
    } 
    return __is; 
} 
 
template <class _Stream, class _Tp, class = void> 
struct __is_istreamable : false_type { }; 
 
template <class _Stream, class _Tp> 
struct __is_istreamable<_Stream, _Tp, decltype( 
    declval<_Stream>() >> declval<_Tp>(), void() 
)> : true_type { }; 
 
template <class _Stream, class _Tp, class = typename enable_if< 
    _And<is_base_of<ios_base, _Stream>, 
         __is_istreamable<_Stream&, _Tp&&> >::value 
>::type> 
_LIBCPP_INLINE_VISIBILITY 
_Stream&& operator>>(_Stream&& __is, _Tp&& __x) 
{ 
    __is >> _VSTD::forward<_Tp>(__x); 
    return _VSTD::move(__is); 
} 
 
template <class _CharT, class _Traits> 
class _LIBCPP_TEMPLATE_VIS basic_iostream 
    : public basic_istream<_CharT, _Traits>, 
      public basic_ostream<_CharT, _Traits> 
{ 
public: 
    // types: 
    typedef _CharT                         char_type; 
    typedef _Traits                        traits_type; 
    typedef typename traits_type::int_type int_type; 
    typedef typename traits_type::pos_type pos_type; 
    typedef typename traits_type::off_type off_type; 
 
    // constructor/destructor 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb) 
      : basic_istream<_CharT, _Traits>(__sb) 
    {} 
 
    virtual ~basic_iostream(); 
protected: 
    inline _LIBCPP_INLINE_VISIBILITY 
    basic_iostream(basic_iostream&& __rhs); 
 
    // assign/swap 
    inline _LIBCPP_INLINE_VISIBILITY 
    basic_iostream& operator=(basic_iostream&& __rhs); 
 
    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
    void swap(basic_iostream& __rhs) 
    { basic_istream<char_type, traits_type>::swap(__rhs); } 
}; 
 
template <class _CharT, class _Traits> 
basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs) 
    : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)) 
{ 
} 
 
template <class _CharT, class _Traits> 
basic_iostream<_CharT, _Traits>& 
basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs) 
{ 
    swap(__rhs); 
    return *this; 
} 
 
template <class _CharT, class _Traits> 
basic_iostream<_CharT, _Traits>::~basic_iostream() 
{ 
} 
 
template<class _CharT, class _Traits, class _Allocator> 
basic_istream<_CharT, _Traits>& 
operator>>(basic_istream<_CharT, _Traits>& __is, 
           basic_string<_CharT, _Traits, _Allocator>& __str) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
    if (__sen)
    {
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif 
            __str.clear(); 
            streamsize __n = __is.width(); 
            if (__n <= 0) 
                __n = __str.max_size(); 
            if (__n <= 0) 
                __n = numeric_limits<streamsize>::max(); 
            streamsize __c = 0; 
            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 
            while (__c < __n) 
            { 
                typename _Traits::int_type __i = __is.rdbuf()->sgetc(); 
                if (_Traits::eq_int_type(__i, _Traits::eof())) 
                { 
                   __state |= ios_base::eofbit; 
                   break; 
                } 
                _CharT __ch = _Traits::to_char_type(__i); 
                if (__ct.is(__ct.space, __ch)) 
                    break; 
                __str.push_back(__ch); 
                ++__c; 
                 __is.rdbuf()->sbumpc(); 
            } 
            __is.width(0); 
            if (__c == 0) 
               __state |= ios_base::failbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            __is.__setstate_nothrow(__state); 
            if (__is.exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        } 
#endif 
        __is.setstate(__state); 
    } 
    return __is; 
} 
 
template<class _CharT, class _Traits, class _Allocator> 
basic_istream<_CharT, _Traits>& 
getline(basic_istream<_CharT, _Traits>& __is, 
        basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
    if (__sen)
    {
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif 
            __str.clear(); 
            streamsize __extr = 0; 
            while (true) 
            { 
                typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); 
                if (_Traits::eq_int_type(__i, _Traits::eof())) 
                { 
                   __state |= ios_base::eofbit; 
                   break; 
                } 
                ++__extr; 
                _CharT __ch = _Traits::to_char_type(__i); 
                if (_Traits::eq(__ch, __dlm)) 
                    break; 
                __str.push_back(__ch); 
                if (__str.size() == __str.max_size()) 
                { 
                    __state |= ios_base::failbit; 
                    break; 
                } 
            } 
            if (__extr == 0) 
               __state |= ios_base::failbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            __is.__setstate_nothrow(__state); 
            if (__is.exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        } 
#endif 
        __is.setstate(__state); 
    } 
    return __is; 
} 
 
template<class _CharT, class _Traits, class _Allocator> 
inline _LIBCPP_INLINE_VISIBILITY 
basic_istream<_CharT, _Traits>& 
getline(basic_istream<_CharT, _Traits>& __is, 
        basic_string<_CharT, _Traits, _Allocator>& __str) 
{ 
    return getline(__is, __str, __is.widen('\n')); 
} 
 
template<class _CharT, class _Traits, class _Allocator> 
inline _LIBCPP_INLINE_VISIBILITY 
basic_istream<_CharT, _Traits>& 
getline(basic_istream<_CharT, _Traits>&& __is, 
        basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) 
{ 
    return getline(__is, __str, __dlm); 
} 
 
template<class _CharT, class _Traits, class _Allocator> 
inline _LIBCPP_INLINE_VISIBILITY 
basic_istream<_CharT, _Traits>& 
getline(basic_istream<_CharT, _Traits>&& __is, 
        basic_string<_CharT, _Traits, _Allocator>& __str) 
{ 
    return getline(__is, __str, __is.widen('\n')); 
} 
 
template <class _CharT, class _Traits, size_t _Size> 
basic_istream<_CharT, _Traits>& 
operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x) 
{ 
    ios_base::iostate __state = ios_base::goodbit; 
    typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
    if (__sen)
    {
#ifndef _LIBCPP_NO_EXCEPTIONS 
        try 
        { 
#endif 
            basic_string<_CharT, _Traits> __str; 
            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 
            size_t __c = 0; 
            _CharT __zero = __ct.widen('0'); 
            _CharT __one = __ct.widen('1'); 
            while (__c < _Size) 
            { 
                typename _Traits::int_type __i = __is.rdbuf()->sgetc(); 
                if (_Traits::eq_int_type(__i, _Traits::eof())) 
                { 
                   __state |= ios_base::eofbit; 
                   break; 
                } 
                _CharT __ch = _Traits::to_char_type(__i); 
                if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one)) 
                    break; 
                __str.push_back(__ch); 
                ++__c; 
                 __is.rdbuf()->sbumpc(); 
            } 
            __x = bitset<_Size>(__str); 
            if (_Size > 0 && __c == 0) 
               __state |= ios_base::failbit; 
#ifndef _LIBCPP_NO_EXCEPTIONS 
        }
        catch (...)
        {
            __state |= ios_base::badbit; 
            __is.__setstate_nothrow(__state); 
            if (__is.exceptions() & ios_base::badbit) 
            { 
                throw; 
            } 
        } 
#endif 
        __is.setstate(__state); 
    } 
    return __is; 
} 
 
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<char>) 
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<wchar_t>) 
#endif 
_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream<char>) 
 
_LIBCPP_END_NAMESPACE_STD 
 
_LIBCPP_POP_MACROS 
 
#endif // _LIBCPP_ISTREAM