include/ios - chromium/llvm-project/libcxx - Git at Google

 // -*- C++ -*-
 //===---------------------------- ios -------------------------------------===//
 //
 // The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #ifndef _LIBCPP_IOS
 #define _LIBCPP_IOS

 /*
  ios synopsis

 #include <iosfwd>

 namespace std
 {

 typedef OFF_T streamoff;
 typedef SZ_T streamsize;
 template <class stateT> class fpos;

 class ios_base
 {
 public:
  class failure;

  typedef T1 fmtflags;
  static const fmtflags boolalpha;
  static const fmtflags dec;
  static const fmtflags fixed;
  static const fmtflags hex;
  static const fmtflags internal;
  static const fmtflags left;
  static const fmtflags oct;
  static const fmtflags right;
  static const fmtflags scientific;
  static const fmtflags showbase;
  static const fmtflags showpoint;
  static const fmtflags showpos;
  static const fmtflags skipws;
  static const fmtflags unitbuf;
  static const fmtflags uppercase;
  static const fmtflags adjustfield;
  static const fmtflags basefield;
  static const fmtflags floatfield;

  typedef T2 iostate;
  static const iostate badbit;
  static const iostate eofbit;
  static const iostate failbit;
  static const iostate goodbit;

  typedef T3 openmode;
  static const openmode app;
  static const openmode ate;
  static const openmode binary;
  static const openmode in;
  static const openmode out;
  static const openmode trunc;

  typedef T4 seekdir;
  static const seekdir beg;
  static const seekdir cur;
  static const seekdir end;

  class Init;

  // 27.5.2.2 fmtflags state:
  fmtflags flags() const;
  fmtflags flags(fmtflags fmtfl);
  fmtflags setf(fmtflags fmtfl);
  fmtflags setf(fmtflags fmtfl, fmtflags mask);
  void unsetf(fmtflags mask);

  streamsize precision() const;
  streamsize precision(streamsize prec);
  streamsize width() const;
  streamsize width(streamsize wide);

  // 27.5.2.3 locales:
  locale imbue(const locale& loc);
  locale getloc() const;

  // 27.5.2.5 storage:
  static int xalloc();
  long& iword(int index);
  void*& pword(int index);

  // destructor
  virtual ~ios_base();

  // 27.5.2.6 callbacks;
  enum event { erase_event, imbue_event, copyfmt_event };
  typedef void (*event_callback)(event, ios_base&, int index);
  void register_callback(event_callback fn, int index);

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

  static bool sync_with_stdio(bool sync = true);

 protected:
  ios_base();
 };

 template <class charT, class traits = char_traits<charT> >
 class basic_ios
  : public ios_base
 {
 public:
  // types:
  typedef charT char_type;
  typedef typename traits::int_type int_type;
  typedef typename traits::pos_type pos_type;
  typedef typename traits::off_type off_type;
  typedef traits traits_type;

  operator unspecified-bool-type() const;
  bool operator!() const;
  iostate rdstate() const;
  void clear(iostate state = goodbit);
  void setstate(iostate state);
  bool good() const;
  bool eof() const;
  bool fail() const;
  bool bad() const;

  iostate exceptions() const;
  void exceptions(iostate except);

  // 27.5.4.1 Constructor/destructor:
  explicit basic_ios(basic_streambuf<charT,traits>* sb);
  virtual ~basic_ios();

  // 27.5.4.2 Members:
  basic_ostream<charT,traits>* tie() const;
  basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr);

  basic_streambuf<charT,traits>* rdbuf() const;
  basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);

  basic_ios& copyfmt(const basic_ios& rhs);

  char_type fill() const;
  char_type fill(char_type ch);

  locale imbue(const locale& loc);

  char narrow(char_type c, char dfault) const;
  char_type widen(char c) const;

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

 protected:
  basic_ios();
  void init(basic_streambuf<charT,traits>* sb);
  void move(basic_ios& rhs);
  void swap(basic_ios& rhs);
  void set_rdbuf(basic_streambuf<charT, traits>* sb);
 };

 // 27.5.5, manipulators:
 ios_base& boolalpha (ios_base& str);
 ios_base& noboolalpha(ios_base& str);
 ios_base& showbase (ios_base& str);
 ios_base& noshowbase (ios_base& str);
 ios_base& showpoint (ios_base& str);
 ios_base& noshowpoint(ios_base& str);
 ios_base& showpos (ios_base& str);
 ios_base& noshowpos (ios_base& str);
 ios_base& skipws (ios_base& str);
 ios_base& noskipws (ios_base& str);
 ios_base& uppercase (ios_base& str);
 ios_base& nouppercase(ios_base& str);
 ios_base& unitbuf (ios_base& str);
 ios_base& nounitbuf (ios_base& str);

 // 27.5.5.2 adjustfield:
 ios_base& internal (ios_base& str);
 ios_base& left (ios_base& str);
 ios_base& right (ios_base& str);

 // 27.5.5.3 basefield:
 ios_base& dec (ios_base& str);
 ios_base& hex (ios_base& str);
 ios_base& oct (ios_base& str);

 // 27.5.5.4 floatfield:
 ios_base& fixed (ios_base& str);
 ios_base& scientific (ios_base& str);
 ios_base& hexfloat (ios_base& str);
 ios_base& defaultfloat(ios_base& str);

 // 27.5.5.5 error reporting:
 enum class io_errc
 {
  stream = 1
 };

 concept_map ErrorCodeEnum<io_errc> { };
 error_code make_error_code(io_errc e);
 error_condition make_error_condition(io_errc e);
 storage-class-specifier const error_category& iostream_category;

 } // std

 */

 #include <__config>
 #include <iosfwd>
 #include <__locale>
 #include <system_error>

 #pragma GCC system_header

 _LIBCPP_BEGIN_NAMESPACE_STD

 typedef ptrdiff_t streamsize;

 class ios_base
 {
 public:
  class failure;

  typedef unsigned int fmtflags;
  static const fmtflags boolalpha = 0x0001;
  static const fmtflags dec = 0x0002;
  static const fmtflags fixed = 0x0004;
  static const fmtflags hex = 0x0008;
  static const fmtflags internal = 0x0010;
  static const fmtflags left = 0x0020;
  static const fmtflags oct = 0x0040;
  static const fmtflags right = 0x0080;
  static const fmtflags scientific = 0x0100;
  static const fmtflags showbase = 0x0200;
  static const fmtflags showpoint = 0x0400;
  static const fmtflags showpos = 0x0800;
  static const fmtflags skipws = 0x1000;
  static const fmtflags unitbuf = 0x2000;
  static const fmtflags uppercase = 0x4000;
  static const fmtflags adjustfield = left | right | internal;
  static const fmtflags basefield = dec | oct | hex;
  static const fmtflags floatfield = scientific | fixed;

  typedef unsigned int iostate;
  typedef iostate io_state;
  static const iostate badbit = 0x1;
  static const iostate eofbit = 0x2;
  static const iostate failbit = 0x4;
  static const iostate goodbit = 0x0;

  typedef unsigned int openmode;
  typedef openmode open_mode;
  static const openmode app = 0x01;
  static const openmode ate = 0x02;
  static const openmode binary = 0x04;
  static const openmode in = 0x08;
  static const openmode out = 0x10;
  static const openmode trunc = 0x20;

  enum seekdir {beg, cur, end};
  typedef seekdir seek_dir;

  typedef _STD::streamoff streamoff;
  typedef _STD::streampos streampos;

  class Init;

  // 27.5.2.2 fmtflags state:
  fmtflags flags() const;
  fmtflags flags(fmtflags __fmtfl);
  fmtflags setf(fmtflags __fmtfl);
  fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
  void unsetf(fmtflags __mask);

  streamsize precision() const;
  streamsize precision(streamsize __prec);
  streamsize width() const;
  streamsize width(streamsize __wide);

  // 27.5.2.3 locales:
  locale imbue(const locale& __loc);
  locale getloc() const;

  // 27.5.2.5 storage:
  static int xalloc();
  long& iword(int __index);
  void*& pword(int __index);

  // destructor
  virtual ~ios_base();

  // 27.5.2.6 callbacks;
  enum event { erase_event, imbue_event, copyfmt_event };
  typedef void (*event_callback)(event, ios_base&, int __index);
  void register_callback(event_callback __fn, int __index);

 private:
  ios_base(const ios_base&); // = delete;
  ios_base& operator=(const ios_base&); // = delete;

 public:
  static bool sync_with_stdio(bool __sync = true);

  iostate rdstate() const;
  void clear(iostate __state = goodbit);
  void setstate(iostate __state);

  bool good() const;
  bool eof() const;
  bool fail() const;
  bool bad() const;

  iostate exceptions() const;
  void exceptions(iostate __except);

  void __set_badbit_and_consider_rethrow();
  void __set_failbit_and_consider_rethrow();

 protected:
  ios_base() {// purposefully does no initialization
  }

  void init(void* __sb);
  _LIBCPP_ALWAYS_INLINE void* rdbuf() const {return __rdbuf_;}

  _LIBCPP_ALWAYS_INLINE
  void rdbuf(void* __sb)
  {
  __rdbuf_ = __sb;
  clear();
  }

  void __call_callbacks(event);
  void copyfmt(const ios_base&);
  void move(ios_base&);
  void swap(ios_base&);

  _LIBCPP_ALWAYS_INLINE
  void set_rdbuf(void* __sb)
  {
  __rdbuf_ = __sb;
  }

 private:
  // All data members must be scalars
  fmtflags __fmtflags_;
  streamsize __precision_;
  streamsize __width_;
  iostate __rdstate_;
  iostate __exceptions_;
  void* __rdbuf_;
  void* __loc_;
  event_callback* __fn_;
  int* __index_;
  size_t __event_size_;
  size_t __event_cap_;
  static int __xindex_;
  long* __iarray_;
  size_t __iarray_size_;
  size_t __iarray_cap_;
  void** __parray_;
  size_t __parray_size_;
  size_t __parray_cap_;
 };

 //enum class io_errc
 struct io_errc
 {
 enum _ {
  stream = 1
 };
  _ __v_;

  _LIBCPP_ALWAYS_INLINE io_errc(_ __v) : __v_(__v) {}
  _LIBCPP_ALWAYS_INLINE operator int() const {return __v_;}
 };

 template <> struct is_error_code_enum<io_errc> : public true_type { };
 template <> struct is_error_code_enum<io_errc::_> : public true_type { };

 const error_category& iostream_category();

 inline _LIBCPP_INLINE_VISIBILITY
 error_code
 make_error_code(io_errc __e)
 {
  return error_code(static_cast<int>(__e), iostream_category());
 }

 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
 make_error_condition(io_errc __e)
 {
  return error_condition(static_cast<int>(__e), iostream_category());
 }

 class ios_base::failure
  : public system_error
 {
 public:
  explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
  explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
  virtual ~failure() throw();
 };

 class ios_base::Init
 {
 public:
  Init();
  ~Init();
 };

 // fmtflags

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::fmtflags
 ios_base::flags() const
 {
  return __fmtflags_;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::fmtflags
 ios_base::flags(fmtflags __fmtfl)
 {
  fmtflags __r = __fmtflags_;
  __fmtflags_ = __fmtfl;
  return __r;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::fmtflags
 ios_base::setf(fmtflags __fmtfl)
 {
  fmtflags __r = __fmtflags_;
  __fmtflags_ |= __fmtfl;
  return __r;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 void
 ios_base::unsetf(fmtflags __mask)
 {
  __fmtflags_ &= ~__mask;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::fmtflags
 ios_base::setf(fmtflags __fmtfl, fmtflags __mask)
 {
  fmtflags __r = __fmtflags_;
  unsetf(__mask);
  __fmtflags_ |= __fmtfl & __mask;
  return __r;
 }

 // precision

 inline _LIBCPP_INLINE_VISIBILITY
 streamsize
 ios_base::precision() const
 {
  return __precision_;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 streamsize
 ios_base::precision(streamsize __prec)
 {
  streamsize __r = __precision_;
  __precision_ = __prec;
  return __r;
 }

 // width

 inline _LIBCPP_INLINE_VISIBILITY
 streamsize
 ios_base::width() const
 {
  return __width_;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 streamsize
 ios_base::width(streamsize __wide)
 {
  streamsize __r = __width_;
  __width_ = __wide;
  return __r;
 }

 // iostate

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::iostate
 ios_base::rdstate() const
 {
  return __rdstate_;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 void
 ios_base::setstate(iostate __state)
 {
  clear(__rdstate_ | __state);
 }

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::good() const
 {
  return __rdstate_ == 0;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::eof() const
 {
  return __rdstate_ & eofbit;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::fail() const
 {
  return __rdstate_ & (failbit | badbit);
 }

 inline _LIBCPP_INLINE_VISIBILITY
 bool
 ios_base::bad() const
 {
  return __rdstate_ & badbit;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base::iostate
 ios_base::exceptions() const
 {
  return __exceptions_;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 void
 ios_base::exceptions(iostate __except)
 {
  __exceptions_ = __except;
  clear(__rdstate_);
 }

 template <class _CharT, class _Traits>
 class basic_ios
  : public ios_base
 {
 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;

  _LIBCPP_ALWAYS_INLINE // explicit
  operator bool() const {return !fail();}
  _LIBCPP_ALWAYS_INLINE bool operator!() const {return fail();}
  _LIBCPP_ALWAYS_INLINE iostate rdstate() const {return ios_base::rdstate();}
  _LIBCPP_ALWAYS_INLINE void clear(iostate __state = goodbit) {ios_base::clear(__state);}
  _LIBCPP_ALWAYS_INLINE void setstate(iostate __state) {ios_base::setstate(__state);}
  _LIBCPP_ALWAYS_INLINE bool good() const {return ios_base::good();}
  _LIBCPP_ALWAYS_INLINE bool eof() const {return ios_base::eof();}
  _LIBCPP_ALWAYS_INLINE bool fail() const {return ios_base::fail();}
  _LIBCPP_ALWAYS_INLINE bool bad() const {return ios_base::bad();}

  _LIBCPP_ALWAYS_INLINE iostate exceptions() const {return ios_base::exceptions();}
  _LIBCPP_ALWAYS_INLINE void exceptions(iostate __except) {ios_base::exceptions(__except);}

  // 27.5.4.1 Constructor/destructor:
  explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb);
  virtual ~basic_ios();

  // 27.5.4.2 Members:
  basic_ostream<char_type, traits_type>* tie() const;
  basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);

  basic_streambuf<char_type, traits_type>* rdbuf() const;
  basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);

  basic_ios& copyfmt(const basic_ios& __rhs);

  char_type fill() const;
  char_type fill(char_type __ch);

  locale imbue(const locale& __loc);

  char narrow(char_type __c, char __dfault) const;
  char_type widen(char __c) const;

 protected:
  basic_ios() {// purposefully does no initialization
  }
  void init(basic_streambuf<char_type, traits_type>* __sb);

  void move(basic_ios& __rhs);
 #ifdef _LIBCPP_MOVE
  void move(basic_ios&& __rhs) {move(__rhs);}
 #endif
  void swap(basic_ios& __rhs);
  void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
 private:
  basic_ostream<char_type, traits_type>* __tie_;
  char_type __fill_;
 };

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type,traits_type>* __sb)
 {
  init(__sb);
 }

 template <class _CharT, class _Traits>
 basic_ios<_CharT, _Traits>::~basic_ios()
 {
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb)
 {
  ios_base::init(__sb);
  __tie_ = 0;
  __fill_ = widen(' ');
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>*
 basic_ios<_CharT, _Traits>::tie() const
 {
  return __tie_;
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostream<_CharT, _Traits>*
 basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr)
 {
  basic_ostream<char_type, traits_type>* __r = __tie_;
  __tie_ = __tiestr;
  return __r;
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_streambuf<_CharT, _Traits>*
 basic_ios<_CharT, _Traits>::rdbuf() const
 {
  return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf());
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_streambuf<_CharT, _Traits>*
 basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb)
 {
  basic_streambuf<char_type, traits_type>* __r = rdbuf();
  ios_base::rdbuf(__sb);
  return __r;
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 locale
 basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
 {
  locale __r = getloc();
  ios_base::imbue(__loc);
  if (rdbuf())
  rdbuf()->pubimbue(__loc);
  return __r;
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 char
 basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
 {
  return use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault);
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 basic_ios<_CharT, _Traits>::widen(char __c) const
 {
  return use_facet<ctype<char_type> >(getloc()).widen(__c);
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 basic_ios<_CharT, _Traits>::fill() const
 {
  return __fill_;
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 _CharT
 basic_ios<_CharT, _Traits>::fill(char_type __ch)
 {
  char_type __r = __fill_;
  __fill_ = __ch;
  return __r;
 }

 template <class _CharT, class _Traits>
 basic_ios<_CharT, _Traits>&
 basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
 {
  if (this != &__rhs)
  {
  __call_callbacks(erase_event);
  ios_base::copyfmt(__rhs);
  __tie_ = __rhs.__tie_;
  __fill_ = __rhs.__fill_;
  __call_callbacks(copyfmt_event);
  exceptions(__rhs.exceptions());
  }
  return *this;
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_ios<_CharT, _Traits>::move(basic_ios& __rhs)
 {
  ios_base::move(__rhs);
  __tie_ = __rhs.__tie_;
  __rhs.__tie_ = 0;
  __fill_ = __rhs.__fill_;
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs)
 {
  ios_base::swap(__rhs);
  _STD::swap(__tie_, __rhs.__tie_);
  _STD::swap(__fill_, __rhs.__fill_);
 }

 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb)
 {
  ios_base::set_rdbuf(__sb);
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 boolalpha(ios_base& __str)
 {
  __str.setf(ios_base::boolalpha);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noboolalpha(ios_base& __str)
 {
  __str.unsetf(ios_base::boolalpha);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 showbase(ios_base& __str)
 {
  __str.setf(ios_base::showbase);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noshowbase(ios_base& __str)
 {
  __str.unsetf(ios_base::showbase);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 showpoint(ios_base& __str)
 {
  __str.setf(ios_base::showpoint);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noshowpoint(ios_base& __str)
 {
  __str.unsetf(ios_base::showpoint);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 showpos(ios_base& __str)
 {
  __str.setf(ios_base::showpos);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noshowpos(ios_base& __str)
 {
  __str.unsetf(ios_base::showpos);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 skipws(ios_base& __str)
 {
  __str.setf(ios_base::skipws);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 noskipws(ios_base& __str)
 {
  __str.unsetf(ios_base::skipws);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 uppercase(ios_base& __str)
 {
  __str.setf(ios_base::uppercase);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 nouppercase(ios_base& __str)
 {
  __str.unsetf(ios_base::uppercase);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 unitbuf(ios_base& __str)
 {
  __str.setf(ios_base::unitbuf);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 nounitbuf(ios_base& __str)
 {
  __str.unsetf(ios_base::unitbuf);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 internal(ios_base& __str)
 {
  __str.setf(ios_base::internal, ios_base::adjustfield);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 left(ios_base& __str)
 {
  __str.setf(ios_base::left, ios_base::adjustfield);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 right(ios_base& __str)
 {
  __str.setf(ios_base::right, ios_base::adjustfield);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 dec(ios_base& __str)
 {
  __str.setf(ios_base::dec, ios_base::basefield);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 hex(ios_base& __str)
 {
  __str.setf(ios_base::hex, ios_base::basefield);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 oct(ios_base& __str)
 {
  __str.setf(ios_base::oct, ios_base::basefield);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 fixed(ios_base& __str)
 {
  __str.setf(ios_base::fixed, ios_base::floatfield);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 scientific(ios_base& __str)
 {
  __str.setf(ios_base::scientific, ios_base::floatfield);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 hexfloat(ios_base& __str)
 {
  __str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
  return __str;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 ios_base&
 defaultfloat(ios_base& __str)
 {
  __str.unsetf(ios_base::floatfield);
  return __str;
 }

 _LIBCPP_END_NAMESPACE_STD

 #endif // _LIBCPP_IOS
	// -- C++ --
	//===---------------------------- ios -------------------------------------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP_IOS
	#define _LIBCPP_IOS

	/*
	ios synopsis

	#include <iosfwd>

	namespace std
	{

	typedef OFF_T streamoff;
	typedef SZ_T streamsize;
	template <class stateT> class fpos;

	class ios_base
	{
	public:
	class failure;

	typedef T1 fmtflags;
	static const fmtflags boolalpha;
	static const fmtflags dec;
	static const fmtflags fixed;
	static const fmtflags hex;
	static const fmtflags internal;
	static const fmtflags left;
	static const fmtflags oct;
	static const fmtflags right;
	static const fmtflags scientific;
	static const fmtflags showbase;
	static const fmtflags showpoint;
	static const fmtflags showpos;
	static const fmtflags skipws;
	static const fmtflags unitbuf;
	static const fmtflags uppercase;
	static const fmtflags adjustfield;
	static const fmtflags basefield;
	static const fmtflags floatfield;

	typedef T2 iostate;
	static const iostate badbit;
	static const iostate eofbit;
	static const iostate failbit;
	static const iostate goodbit;

	typedef T3 openmode;
	static const openmode app;
	static const openmode ate;
	static const openmode binary;
	static const openmode in;
	static const openmode out;
	static const openmode trunc;

	typedef T4 seekdir;
	static const seekdir beg;
	static const seekdir cur;
	static const seekdir end;

	class Init;

	// 27.5.2.2 fmtflags state:
	fmtflags flags() const;
	fmtflags flags(fmtflags fmtfl);
	fmtflags setf(fmtflags fmtfl);
	fmtflags setf(fmtflags fmtfl, fmtflags mask);
	void unsetf(fmtflags mask);

	streamsize precision() const;
	streamsize precision(streamsize prec);
	streamsize width() const;
	streamsize width(streamsize wide);

	// 27.5.2.3 locales:
	locale imbue(const locale& loc);
	locale getloc() const;

	// 27.5.2.5 storage:
	static int xalloc();
	long& iword(int index);
	void*& pword(int index);

	// destructor
	virtual ~ios_base();

	// 27.5.2.6 callbacks;
	enum event { erase_event, imbue_event, copyfmt_event };
	typedef void (*event_callback)(event, ios_base&, int index);
	void register_callback(event_callback fn, int index);

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

	static bool sync_with_stdio(bool sync = true);

	protected:
	ios_base();
	};

	template <class charT, class traits = char_traits<charT> >
	class basic_ios
	: public ios_base
	{
	public:
	// types:
	typedef charT char_type;
	typedef typename traits::int_type int_type;
	typedef typename traits::pos_type pos_type;
	typedef typename traits::off_type off_type;
	typedef traits traits_type;

	operator unspecified-bool-type() const;
	bool operator!() const;
	iostate rdstate() const;
	void clear(iostate state = goodbit);
	void setstate(iostate state);
	bool good() const;
	bool eof() const;
	bool fail() const;
	bool bad() const;

	iostate exceptions() const;
	void exceptions(iostate except);

	// 27.5.4.1 Constructor/destructor:
	explicit basic_ios(basic_streambuf<charT,traits>* sb);
	virtual ~basic_ios();

	// 27.5.4.2 Members:
	basic_ostream<charT,traits>* tie() const;
	basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr);

	basic_streambuf<charT,traits>* rdbuf() const;
	basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* sb);

	basic_ios& copyfmt(const basic_ios& rhs);

	char_type fill() const;
	char_type fill(char_type ch);

	locale imbue(const locale& loc);

	char narrow(char_type c, char dfault) const;
	char_type widen(char c) const;

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

	protected:
	basic_ios();
	void init(basic_streambuf<charT,traits>* sb);
	void move(basic_ios& rhs);
	void swap(basic_ios& rhs);
	void set_rdbuf(basic_streambuf<charT, traits>* sb);
	};

	// 27.5.5, manipulators:
	ios_base& boolalpha (ios_base& str);
	ios_base& noboolalpha(ios_base& str);
	ios_base& showbase (ios_base& str);
	ios_base& noshowbase (ios_base& str);
	ios_base& showpoint (ios_base& str);
	ios_base& noshowpoint(ios_base& str);
	ios_base& showpos (ios_base& str);
	ios_base& noshowpos (ios_base& str);
	ios_base& skipws (ios_base& str);
	ios_base& noskipws (ios_base& str);
	ios_base& uppercase (ios_base& str);
	ios_base& nouppercase(ios_base& str);
	ios_base& unitbuf (ios_base& str);
	ios_base& nounitbuf (ios_base& str);

	// 27.5.5.2 adjustfield:
	ios_base& internal (ios_base& str);
	ios_base& left (ios_base& str);
	ios_base& right (ios_base& str);

	// 27.5.5.3 basefield:
	ios_base& dec (ios_base& str);
	ios_base& hex (ios_base& str);
	ios_base& oct (ios_base& str);

	// 27.5.5.4 floatfield:
	ios_base& fixed (ios_base& str);
	ios_base& scientific (ios_base& str);
	ios_base& hexfloat (ios_base& str);
	ios_base& defaultfloat(ios_base& str);

	// 27.5.5.5 error reporting:
	enum class io_errc
	{
	stream = 1
	};

	concept_map ErrorCodeEnum<io_errc> { };
	error_code make_error_code(io_errc e);
	error_condition make_error_condition(io_errc e);
	storage-class-specifier const error_category& iostream_category;

	} // std

	*/

	#include <__config>
	#include <iosfwd>
	#include <__locale>
	#include <system_error>

	#pragma GCC system_header

	_LIBCPP_BEGIN_NAMESPACE_STD

	typedef ptrdiff_t streamsize;

	class ios_base
	{
	public:
	class failure;

	typedef unsigned int fmtflags;
	static const fmtflags boolalpha = 0x0001;
	static const fmtflags dec = 0x0002;
	static const fmtflags fixed = 0x0004;
	static const fmtflags hex = 0x0008;
	static const fmtflags internal = 0x0010;
	static const fmtflags left = 0x0020;
	static const fmtflags oct = 0x0040;
	static const fmtflags right = 0x0080;
	static const fmtflags scientific = 0x0100;
	static const fmtflags showbase = 0x0200;
	static const fmtflags showpoint = 0x0400;
	static const fmtflags showpos = 0x0800;
	static const fmtflags skipws = 0x1000;
	static const fmtflags unitbuf = 0x2000;
	static const fmtflags uppercase = 0x4000;
	static const fmtflags adjustfield = left \| right \| internal;
	static const fmtflags basefield = dec \| oct \| hex;
	static const fmtflags floatfield = scientific \| fixed;

	typedef unsigned int iostate;
	typedef iostate io_state;
	static const iostate badbit = 0x1;
	static const iostate eofbit = 0x2;
	static const iostate failbit = 0x4;
	static const iostate goodbit = 0x0;

	typedef unsigned int openmode;
	typedef openmode open_mode;
	static const openmode app = 0x01;
	static const openmode ate = 0x02;
	static const openmode binary = 0x04;
	static const openmode in = 0x08;
	static const openmode out = 0x10;
	static const openmode trunc = 0x20;

	enum seekdir {beg, cur, end};
	typedef seekdir seek_dir;

	typedef _STD::streamoff streamoff;
	typedef _STD::streampos streampos;

	class Init;

	// 27.5.2.2 fmtflags state:
	fmtflags flags() const;
	fmtflags flags(fmtflags __fmtfl);
	fmtflags setf(fmtflags __fmtfl);
	fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
	void unsetf(fmtflags __mask);

	streamsize precision() const;
	streamsize precision(streamsize __prec);
	streamsize width() const;
	streamsize width(streamsize __wide);

	// 27.5.2.3 locales:
	locale imbue(const locale& __loc);
	locale getloc() const;

	// 27.5.2.5 storage:
	static int xalloc();
	long& iword(int __index);
	void*& pword(int __index);

	// destructor
	virtual ~ios_base();

	// 27.5.2.6 callbacks;
	enum event { erase_event, imbue_event, copyfmt_event };
	typedef void (*event_callback)(event, ios_base&, int __index);
	void register_callback(event_callback __fn, int __index);

	private:
	ios_base(const ios_base&); // = delete;
	ios_base& operator=(const ios_base&); // = delete;

	public:
	static bool sync_with_stdio(bool __sync = true);

	iostate rdstate() const;
	void clear(iostate __state = goodbit);
	void setstate(iostate __state);

	bool good() const;
	bool eof() const;
	bool fail() const;
	bool bad() const;

	iostate exceptions() const;
	void exceptions(iostate __except);

	void __set_badbit_and_consider_rethrow();
	void __set_failbit_and_consider_rethrow();

	protected:
	ios_base() {// purposefully does no initialization
	}

	void init(void* __sb);
	_LIBCPP_ALWAYS_INLINE void* rdbuf() const {return __rdbuf_;}

	_LIBCPP_ALWAYS_INLINE
	void rdbuf(void* __sb)
	{
	__rdbuf_ = __sb;
	clear();
	}

	void __call_callbacks(event);
	void copyfmt(const ios_base&);
	void move(ios_base&);
	void swap(ios_base&);

	_LIBCPP_ALWAYS_INLINE
	void set_rdbuf(void* __sb)
	{
	__rdbuf_ = __sb;
	}

	private:
	// All data members must be scalars
	fmtflags __fmtflags_;
	streamsize __precision_;
	streamsize __width_;
	iostate __rdstate_;
	iostate __exceptions_;
	void* __rdbuf_;
	void* __loc_;
	event_callback* __fn_;
	int* __index_;
	size_t __event_size_;
	size_t __event_cap_;
	static int __xindex_;
	long* __iarray_;
	size_t __iarray_size_;
	size_t __iarray_cap_;
	void** __parray_;
	size_t __parray_size_;
	size_t __parray_cap_;
	};

	//enum class io_errc
	struct io_errc
	{
	enum _ {
	stream = 1
	};
	_ __v_;

	_LIBCPP_ALWAYS_INLINE io_errc(_ __v) : __v_(__v) {}
	_LIBCPP_ALWAYS_INLINE operator int() const {return __v_;}
	};

	template <> struct is_error_code_enum<io_errc> : public true_type { };
	template <> struct is_error_code_enum<io_errc::_> : public true_type { };

	const error_category& iostream_category();

	inline _LIBCPP_INLINE_VISIBILITY
	error_code
	make_error_code(io_errc __e)
	{
	return error_code(static_cast<int>(__e), iostream_category());
	}

	inline _LIBCPP_INLINE_VISIBILITY
	error_condition
	make_error_condition(io_errc __e)
	{
	return error_condition(static_cast<int>(__e), iostream_category());
	}

	class ios_base::failure
	: public system_error
	{
	public:
	explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
	explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
	virtual ~failure() throw();
	};

	class ios_base::Init
	{
	public:
	Init();
	~Init();
	};

	// fmtflags

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::fmtflags
	ios_base::flags() const
	{
	return __fmtflags_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::fmtflags
	ios_base::flags(fmtflags __fmtfl)
	{
	fmtflags __r = __fmtflags_;
	__fmtflags_ = __fmtfl;
	return __r;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::fmtflags
	ios_base::setf(fmtflags __fmtfl)
	{
	fmtflags __r = __fmtflags_;
	__fmtflags_ \|= __fmtfl;
	return __r;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	ios_base::unsetf(fmtflags __mask)
	{
	__fmtflags_ &= ~__mask;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::fmtflags
	ios_base::setf(fmtflags __fmtfl, fmtflags __mask)
	{
	fmtflags __r = __fmtflags_;
	unsetf(__mask);
	__fmtflags_ \|= __fmtfl & __mask;
	return __r;
	}

	// precision

	inline _LIBCPP_INLINE_VISIBILITY
	streamsize
	ios_base::precision() const
	{
	return __precision_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	streamsize
	ios_base::precision(streamsize __prec)
	{
	streamsize __r = __precision_;
	__precision_ = __prec;
	return __r;
	}

	// width

	inline _LIBCPP_INLINE_VISIBILITY
	streamsize
	ios_base::width() const
	{
	return __width_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	streamsize
	ios_base::width(streamsize __wide)
	{
	streamsize __r = __width_;
	__width_ = __wide;
	return __r;
	}

	// iostate

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::iostate
	ios_base::rdstate() const
	{
	return __rdstate_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	ios_base::setstate(iostate __state)
	{
	clear(__rdstate_ \| __state);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	ios_base::good() const
	{
	return __rdstate_ == 0;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	ios_base::eof() const
	{
	return __rdstate_ & eofbit;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	ios_base::fail() const
	{
	return __rdstate_ & (failbit \| badbit);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	bool
	ios_base::bad() const
	{
	return __rdstate_ & badbit;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base::iostate
	ios_base::exceptions() const
	{
	return __exceptions_;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	void
	ios_base::exceptions(iostate __except)
	{
	__exceptions_ = __except;
	clear(__rdstate_);
	}

	template <class _CharT, class _Traits>
	class basic_ios
	: public ios_base
	{
	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;

	_LIBCPP_ALWAYS_INLINE // explicit
	operator bool() const {return !fail();}
	_LIBCPP_ALWAYS_INLINE bool operator!() const {return fail();}
	_LIBCPP_ALWAYS_INLINE iostate rdstate() const {return ios_base::rdstate();}
	_LIBCPP_ALWAYS_INLINE void clear(iostate __state = goodbit) {ios_base::clear(__state);}
	_LIBCPP_ALWAYS_INLINE void setstate(iostate __state) {ios_base::setstate(__state);}
	_LIBCPP_ALWAYS_INLINE bool good() const {return ios_base::good();}
	_LIBCPP_ALWAYS_INLINE bool eof() const {return ios_base::eof();}
	_LIBCPP_ALWAYS_INLINE bool fail() const {return ios_base::fail();}
	_LIBCPP_ALWAYS_INLINE bool bad() const {return ios_base::bad();}

	_LIBCPP_ALWAYS_INLINE iostate exceptions() const {return ios_base::exceptions();}
	_LIBCPP_ALWAYS_INLINE void exceptions(iostate __except) {ios_base::exceptions(__except);}

	// 27.5.4.1 Constructor/destructor:
	explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb);
	virtual ~basic_ios();

	// 27.5.4.2 Members:
	basic_ostream<char_type, traits_type>* tie() const;
	basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);

	basic_streambuf<char_type, traits_type>* rdbuf() const;
	basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);

	basic_ios& copyfmt(const basic_ios& __rhs);

	char_type fill() const;
	char_type fill(char_type __ch);

	locale imbue(const locale& __loc);

	char narrow(char_type __c, char __dfault) const;
	char_type widen(char __c) const;

	protected:
	basic_ios() {// purposefully does no initialization
	}
	void init(basic_streambuf<char_type, traits_type>* __sb);

	void move(basic_ios& __rhs);
	#ifdef _LIBCPP_MOVE
	void move(basic_ios&& __rhs) {move(__rhs);}
	#endif
	void swap(basic_ios& __rhs);
	void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
	private:
	basic_ostream<char_type, traits_type>* __tie_;
	char_type __fill_;
	};

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type,traits_type>* __sb)
	{
	init(__sb);
	}

	template <class _CharT, class _Traits>
	basic_ios<_CharT, _Traits>::~basic_ios()
	{
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb)
	{
	ios_base::init(__sb);
	__tie_ = 0;
	__fill_ = widen(' ');
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>*
	basic_ios<_CharT, _Traits>::tie() const
	{
	return __tie_;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_ostream<_CharT, _Traits>*
	basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr)
	{
	basic_ostream<char_type, traits_type>* __r = __tie_;
	__tie_ = __tiestr;
	return __r;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_streambuf<_CharT, _Traits>*
	basic_ios<_CharT, _Traits>::rdbuf() const
	{
	return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf());
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	basic_streambuf<_CharT, _Traits>*
	basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb)
	{
	basic_streambuf<char_type, traits_type>* __r = rdbuf();
	ios_base::rdbuf(__sb);
	return __r;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	locale
	basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
	{
	locale __r = getloc();
	ios_base::imbue(__loc);
	if (rdbuf())
	rdbuf()->pubimbue(__loc);
	return __r;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	char
	basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
	{
	return use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	_CharT
	basic_ios<_CharT, _Traits>::widen(char __c) const
	{
	return use_facet<ctype<char_type> >(getloc()).widen(__c);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	_CharT
	basic_ios<_CharT, _Traits>::fill() const
	{
	return __fill_;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	_CharT
	basic_ios<_CharT, _Traits>::fill(char_type __ch)
	{
	char_type __r = __fill_;
	__fill_ = __ch;
	return __r;
	}

	template <class _CharT, class _Traits>
	basic_ios<_CharT, _Traits>&
	basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
	{
	if (this != &__rhs)
	{
	__call_callbacks(erase_event);
	ios_base::copyfmt(__rhs);
	__tie_ = __rhs.__tie_;
	__fill_ = __rhs.__fill_;
	__call_callbacks(copyfmt_event);
	exceptions(__rhs.exceptions());
	}
	return *this;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_ios<_CharT, _Traits>::move(basic_ios& __rhs)
	{
	ios_base::move(__rhs);
	__tie_ = __rhs.__tie_;
	__rhs.__tie_ = 0;
	__fill_ = __rhs.__fill_;
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs)
	{
	ios_base::swap(__rhs);
	_STD::swap(__tie_, __rhs.__tie_);
	_STD::swap(__fill_, __rhs.__fill_);
	}

	template <class _CharT, class _Traits>
	inline _LIBCPP_INLINE_VISIBILITY
	void
	basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb)
	{
	ios_base::set_rdbuf(__sb);
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	boolalpha(ios_base& __str)
	{
	__str.setf(ios_base::boolalpha);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noboolalpha(ios_base& __str)
	{
	__str.unsetf(ios_base::boolalpha);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	showbase(ios_base& __str)
	{
	__str.setf(ios_base::showbase);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noshowbase(ios_base& __str)
	{
	__str.unsetf(ios_base::showbase);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	showpoint(ios_base& __str)
	{
	__str.setf(ios_base::showpoint);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noshowpoint(ios_base& __str)
	{
	__str.unsetf(ios_base::showpoint);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	showpos(ios_base& __str)
	{
	__str.setf(ios_base::showpos);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noshowpos(ios_base& __str)
	{
	__str.unsetf(ios_base::showpos);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	skipws(ios_base& __str)
	{
	__str.setf(ios_base::skipws);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	noskipws(ios_base& __str)
	{
	__str.unsetf(ios_base::skipws);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	uppercase(ios_base& __str)
	{
	__str.setf(ios_base::uppercase);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	nouppercase(ios_base& __str)
	{
	__str.unsetf(ios_base::uppercase);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	unitbuf(ios_base& __str)
	{
	__str.setf(ios_base::unitbuf);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	nounitbuf(ios_base& __str)
	{
	__str.unsetf(ios_base::unitbuf);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	internal(ios_base& __str)
	{
	__str.setf(ios_base::internal, ios_base::adjustfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	left(ios_base& __str)
	{
	__str.setf(ios_base::left, ios_base::adjustfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	right(ios_base& __str)
	{
	__str.setf(ios_base::right, ios_base::adjustfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	dec(ios_base& __str)
	{
	__str.setf(ios_base::dec, ios_base::basefield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	hex(ios_base& __str)
	{
	__str.setf(ios_base::hex, ios_base::basefield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	oct(ios_base& __str)
	{
	__str.setf(ios_base::oct, ios_base::basefield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	fixed(ios_base& __str)
	{
	__str.setf(ios_base::fixed, ios_base::floatfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	scientific(ios_base& __str)
	{
	__str.setf(ios_base::scientific, ios_base::floatfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	hexfloat(ios_base& __str)
	{
	__str.setf(ios_base::fixed \| ios_base::scientific, ios_base::floatfield);
	return __str;
	}

	inline _LIBCPP_INLINE_VISIBILITY
	ios_base&
	defaultfloat(ios_base& __str)
	{
	__str.unsetf(ios_base::floatfield);
	return __str;
	}

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_IOS