// -*- C++ -*-

//===----------------------------------------------------------------------===//

//

// 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 <__assert> // all public C++ headers provide the assertion handler

#include <__config>

#include <__iterator/istreambuf_iterator.h>

#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); }

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::basic_istream(std::__1::basic_streambuf<char, std::__1::char_traits<char> >*)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::basic_istream(std::__1::basic_streambuf<char, std::__1::char_traits<char> >*)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::basic_istream(std::__1::basic_streambuf<wchar_t, std::__1::char_traits<wchar_t> >*)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::basic_istream(std::__1::basic_streambuf<wchar_t, std::__1::char_traits<wchar_t> >*)

    ~basic_istream() override;

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);

    }

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::swap(std::__1::basic_istream<char, std::__1::char_traits<char> >&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::swap(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&)

    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); }

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(std::__1::basic_istream<char, std::__1::char_traits<char> >& (*)(std::__1::basic_istream<char, std::__1::char_traits<char> >&))

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& (*)(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&))

    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; }

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(std::__1::basic_ios<char, std::__1::char_traits<char> >& (*)(std::__1::basic_ios<char, std::__1::char_traits<char> >&))

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(std::__1::basic_ios<wchar_t, std::__1::char_traits<wchar_t> >& (*)(std::__1::basic_ios<wchar_t, std::__1::char_traits<wchar_t> >&))

    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1

    basic_istream& operator>>(ios_base& (*__pf)(ios_base&))

    { __pf(*this); return *this; }

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(std::__1::ios_base& (*)(std::__1::ios_base&))

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(std::__1::ios_base& (*)(std::__1::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:

    _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;

    }

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::get(char&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::get(wchar_t&)

    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1

    basic_istream& get(char_type* __s, streamsize __n)

    { return get(__s, __n, this->widen('\n')); }

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::get(char*, long)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::get(wchar_t*, long)

    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')); }

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::get(std::__1::basic_streambuf<char, std::__1::char_traits<char> >&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::get(std::__1::basic_streambuf<wchar_t, std::__1::char_traits<wchar_t> >&)

    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')); }

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::getline(char*, long)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::getline(wchar_t*, long)

    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_;

public:

    explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);

//    ~sentry() = default;

    _LIBCPP_INLINE_VISIBILITY

    explicit operator bool() const {return __ok_;}

std::__1::basic_istream<char, std::__1::char_traits<char> >::sentry::operator bool[abi:v160006]() const

Line

Count

Source

301

5.30k

    explicit operator bool() const {return __ok_;}

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::sentry::operator bool[abi:v160006]() const

    sentry(const sentry&) = delete;

    sentry& operator=(const sentry&) = delete;

};

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 = std::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);

}

std::__1::basic_istream<char, std::__1::char_traits<char> >::sentry::sentry(std::__1::basic_istream<char, std::__1::char_traits<char> >&, bool)

Line

Count

Source

311

5.30k

{

312

5.30k

    if (__is.good())

313

2.84k

    {

314

2.84k

        if (__is.tie())

315

0

            __is.tie()->flush();

316

2.84k

        if (!__noskipws && (__is.flags() & ios_base::skipws))

317

2.84k

        {

318

2.84k

            typedef istreambuf_iterator<_CharT, _Traits> _Ip;

319

2.84k

            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());

320

2.84k

            _Ip __i(__is);

321

2.84k

            _Ip __eof;

322

41.2k

            for (; __i != __eof; ++__i)

323

41.1k

                if (!__ct.is(__ct.space, *__i))

324

2.81k

                    break;

325

2.84k

            if (__i == __eof)

326

39

                __is.setstate(ios_base::failbit | ios_base::eofbit);

327

2.84k

        }

328

2.84k

        __ok_ = __is.good();

329

2.84k

    }

330

2.45k

    else

331

2.45k

        __is.setstate(ios_base::failbit);

332

5.30k

}

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::sentry::sentry(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, bool)

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()

{

}

std::__1::basic_istream<char, std::__1::char_traits<char> >::~basic_istream()

Line

Count

Source

352

1.32k

{

353

1.32k

}

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::~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;

            std::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;

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<bool, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, bool&)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<unsigned short, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, unsigned short&)

std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<unsigned int, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, unsigned int&)

Line

Count

Source

358

5.30k

__input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {

359

5.30k

    ios_base::iostate __state = ios_base::goodbit;

360

5.30k

    typename basic_istream<_CharT, _Traits>::sentry __s(__is);

361

5.30k

    if (__s)

362

2.81k

    {

363

2.81k

#ifndef _LIBCPP_NO_EXCEPTIONS

364

2.81k

        try

365

2.81k

        {

366

2.81k

#endif // _LIBCPP_NO_EXCEPTIONS

367

2.81k

            typedef istreambuf_iterator<_CharT, _Traits> _Ip;

368

2.81k

            typedef num_get<_CharT, _Ip> _Fp;

369

2.81k

            std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n);

370

2.81k

#ifndef _LIBCPP_NO_EXCEPTIONS

371

2.81k

        }

372

2.81k

        catch (...)

373

2.81k

        {

374

0

            __state |= ios_base::badbit;

375

0

            __is.__setstate_nothrow(__state);

376

0

            if (__is.exceptions() & ios_base::badbit)

377

0

            {

378

0

                throw;

379

0

            }

380

0

        }

381

0

#endif

382

2.81k

        __is.setstate(__state);

383

2.81k

    }

384

5.30k

    return __is;

385

5.30k

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<long, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, long&)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<unsigned long, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, unsigned long&)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<long long, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, long long&)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<unsigned long long, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, unsigned long long&)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<float, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, float&)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<double, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, double&)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<long double, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, long double&)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic[abi:v160006]<void*, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, void*&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<bool, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, bool&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<unsigned short, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, unsigned short&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<unsigned int, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, unsigned int&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<long, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, long&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<unsigned long, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, unsigned long&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<long long, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, long long&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<unsigned long long, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, unsigned long long&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<float, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, float&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<double, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, double&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<long double, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, long double&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic[abi:v160006]<void*, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, void*&)

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);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(unsigned short&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(unsigned short&)

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);

}

std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(unsigned int&)

Line

Count

Source

397

5.30k

{

398

5.30k

    return _VSTD::__input_arithmetic<unsigned int>(*this, __n);

399

5.30k

}

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(unsigned int&)

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::operator>>(long& __n)

{

    return _VSTD::__input_arithmetic<long>(*this, __n);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(long&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(long&)

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);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(unsigned long&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(unsigned long&)

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);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(long long&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(long long&)

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);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(unsigned long long&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(unsigned long long&)

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::operator>>(float& __n)

{

    return _VSTD::__input_arithmetic<float>(*this, __n);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(float&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(float&)

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::operator>>(double& __n)

{

    return _VSTD::__input_arithmetic<double>(*this, __n);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(double&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(double&)

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);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(long double&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(long double&)

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::operator>>(bool& __n)

{

    return _VSTD::__input_arithmetic<bool>(*this, __n);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(bool&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(bool&)

template <class _CharT, class _Traits>

basic_istream<_CharT, _Traits>&

basic_istream<_CharT, _Traits>::operator>>(void*& __n)

{

    return _VSTD::__input_arithmetic<void*>(*this, __n);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(void*&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(void*&)

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;

            std::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;

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic_with_numeric_limits[abi:v160006]<short, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, short&)

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >& std::__1::__input_arithmetic_with_numeric_limits[abi:v160006]<int, char, std::__1::char_traits<char> >(std::__1::basic_istream<char, std::__1::char_traits<char> >&, int&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic_with_numeric_limits[abi:v160006]<short, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, short&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >& std::__1::__input_arithmetic_with_numeric_limits[abi:v160006]<int, wchar_t, std::__1::char_traits<wchar_t> >(std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >&, int&)

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);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(short&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(short&)

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);

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(int&)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(int&)

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 = std::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>

_LIBCPP_HIDE_FROM_ABI 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;

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::operator>>(std::__1::basic_streambuf<char, std::__1::char_traits<char> >*)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::operator>>(std::__1::basic_streambuf<wchar_t, std::__1::char_traits<wchar_t> >*)

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;

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::get()

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::get()

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;

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::get(char*, long, char)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::get(wchar_t*, long, wchar_t)

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;

}

Unexecuted instantiation: std::__1::basic_istream<char, std::__1::char_traits<char> >::get(std::__1::basic_streambuf<char, std::__1::char_traits<char> >&, char)

Unexecuted instantiation: std::__1::basic_istream<wchar_t, std::__1::char_traits<wchar_t> >::get(std::__1::basic_streambuf<wchar_t, std::__1::char_traits<wchar_t> >&, wchar_t)

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))

                {