1 “driver.cpp”

1 ""

1 “/usr/include/stdc-predef.h” 1 3 4

1 "" 2

1 “driver.cpp”

1 “/usr/include/c++/5/iostream” 1 3

36 “/usr/include/c++/5/iostream” 3

37 “/usr/include/c++/5/iostream” 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 1 3

194 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 3

namespace std { typedef long unsigned int size_t; typedef long int ptrdiff_t;

}

216 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 3

namespace std { inline namespace __cxx11 attribute((abi_tag (“cxx11”))) { } } namespace __gnu_cxx { inline namespace __cxx11 attribute((abi_tag (“cxx11”))) { } }

482 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/os_defines.h” 1 3

39 “/usr/include/x86_64-linux-gnu/c++/5/bits/os_defines.h” 3

1 “/usr/include/features.h” 1 3 4

367 “/usr/include/features.h” 3 4

1 “/usr/include/x86_64-linux-gnu/sys/cdefs.h” 1 3 4

410 “/usr/include/x86_64-linux-gnu/sys/cdefs.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/wordsize.h” 1 3 4

411 “/usr/include/x86_64-linux-gnu/sys/cdefs.h” 2 3 4

368 “/usr/include/features.h” 2 3 4

391 “/usr/include/features.h” 3 4

1 “/usr/include/x86_64-linux-gnu/gnu/stubs.h” 1 3 4

10 “/usr/include/x86_64-linux-gnu/gnu/stubs.h” 3 4

1 “/usr/include/x86_64-linux-gnu/gnu/stubs-64.h” 1 3 4

11 “/usr/include/x86_64-linux-gnu/gnu/stubs.h” 2 3 4

392 “/usr/include/features.h” 2 3 4

40 “/usr/include/x86_64-linux-gnu/c++/5/bits/os_defines.h” 2 3

483 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 2 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/cpu_defines.h” 1 3

486 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 2 3

39 “/usr/include/c++/5/iostream” 2 3

1 “/usr/include/c++/5/ostream” 1 3

36 “/usr/include/c++/5/ostream” 3

37 “/usr/include/c++/5/ostream” 3

1 “/usr/include/c++/5/ios” 1 3

36 “/usr/include/c++/5/ios” 3

37 “/usr/include/c++/5/ios” 3

1 “/usr/include/c++/5/iosfwd” 1 3

36 “/usr/include/c++/5/iosfwd” 3

37 “/usr/include/c++/5/iosfwd” 3

1 “/usr/include/c++/5/bits/stringfwd.h” 1 3

37 “/usr/include/c++/5/bits/stringfwd.h” 3

38 “/usr/include/c++/5/bits/stringfwd.h” 3

1 “/usr/include/c++/5/bits/memoryfwd.h” 1 3

46 “/usr/include/c++/5/bits/memoryfwd.h” 3

47 “/usr/include/c++/5/bits/memoryfwd.h” 3

namespace std attribute ((visibility (“default”))) {

63 “/usr/include/c++/5/bits/memoryfwd.h” 3

template class allocator;

template<> class allocator;

template<typename, typename> struct uses_allocator;

}

41 “/usr/include/c++/5/bits/stringfwd.h” 2 3

namespace std attribute ((visibility (“default”))) {

template struct char_traits;

template<> struct char_traits;

template<> struct char_traits<wchar_t>;

67 “/usr/include/c++/5/bits/stringfwd.h” 3

namespace __cxx11 {

template<typename _CharT, typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > class basic_string;

typedef basic_string string;

typedef basic_string<wchar_t> wstring;

90 “/usr/include/c++/5/bits/stringfwd.h” 3

}

40 “/usr/include/c++/5/iosfwd” 2 3

1 “/usr/include/c++/5/bits/postypes.h” 1 3

38 “/usr/include/c++/5/bits/postypes.h” 3

39 “/usr/include/c++/5/bits/postypes.h” 3

1 “/usr/include/c++/5/cwchar” 1 3

39 “/usr/include/c++/5/cwchar” 3

40 “/usr/include/c++/5/cwchar” 3

1 “/usr/include/wchar.h” 1 3 4

36 “/usr/include/wchar.h” 3 4

1 “/usr/include/stdio.h” 1 3 4

44 “/usr/include/stdio.h” 3 4

struct _IO_FILE;

typedef struct _IO_FILE FILE;

64 “/usr/include/stdio.h” 3 4

typedef struct _IO_FILE __FILE;

37 “/usr/include/wchar.h” 2 3 4

1 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stdarg.h” 1 3 4

40 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stdarg.h” 3 4

typedef __builtin_va_list __gnuc_va_list;

40 “/usr/include/wchar.h” 2 3 4

1 “/usr/include/x86_64-linux-gnu/bits/wchar.h” 1 3 4

42 “/usr/include/wchar.h” 2 3 4

51 “/usr/include/wchar.h” 3 4

1 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h” 1 3 4

216 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h” 3 4

typedef long unsigned int size_t;

357 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h” 3 4

typedef unsigned int wint_t;

52 “/usr/include/wchar.h” 2 3 4

82 “/usr/include/wchar.h” 3 4

typedef struct { int __count; union {

unsigned int __wch;



char __wchb[4];

} __value; } __mbstate_t;

104 “/usr/include/wchar.h” 3 4

typedef __mbstate_t mbstate_t;

132 “/usr/include/wchar.h” 3 4

extern “C” {

struct tm;

extern wchar_t *wcscpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () attribute ((nonnull (1, 2)));

extern wchar_t *wcsncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () attribute ((nonnull (1, 2)));

extern wchar_t *wcscat (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw () attribute ((nonnull (1, 2)));

extern wchar_t *wcsncat (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw () attribute ((nonnull (1, 2)));

extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) throw () attribute ((pure)) attribute ((nonnull (1, 2)));

extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) throw () attribute ((pure)) attribute ((nonnull (1, 2)));

extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();

extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) throw ();

1 “/usr/include/xlocale.h” 1 3 4

27 “/usr/include/xlocale.h” 3 4

typedef struct __locale_struct {

struct __locale_data *__locales[13];

const unsigned short int *__ctype_b; const int *__ctype_tolower; const int *__ctype_toupper;

const char *__names[13]; } *__locale_t;

typedef __locale_t locale_t;

184 “/usr/include/wchar.h” 2 3 4

extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, __locale_t __loc) throw ();

extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, size_t __n, __locale_t __loc) throw ();

extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();

extern size_t wcsxfrm (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw ();

extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, __locale_t __loc) throw ();

extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, size_t __n, __locale_t __loc) throw ();

extern wchar_t *wcsdup (const wchar_t *__s) throw () attribute ((malloc));

extern “C++” wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc) throw () __asm (“wcschr”) attribute ((pure)); extern “C++” const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) throw () __asm (“wcschr”) attribute ((pure));

extern “C++” wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc) throw () __asm (“wcsrchr”) attribute ((pure)); extern “C++” const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) throw () __asm (“wcsrchr”) attribute ((pure));

extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) throw () attribute ((pure));

extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) throw () attribute ((pure));

extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) throw () attribute ((pure));

extern “C++” wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept) throw () __asm (“wcspbrk”) attribute ((pure)); extern “C++” const wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) throw () __asm (“wcspbrk”) attribute ((pure));

extern “C++” wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle) throw () __asm (“wcsstr”) attribute ((pure)); extern “C++” const wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) throw () __asm (“wcsstr”) attribute ((pure));

extern wchar_t *wcstok (wchar_t *__restrict __s, const wchar_t *__restrict __delim, wchar_t **__restrict __ptr) throw ();

extern size_t wcslen (const wchar_t *__s) throw () attribute ((pure));

extern “C++” wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle) throw () __asm (“wcswcs”) attribute ((pure)); extern “C++” const wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) throw () __asm (“wcswcs”) attribute ((pure));

309 “/usr/include/wchar.h” 3 4

extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) throw () attribute ((pure));

extern “C++” wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n) throw () __asm (“wmemchr”) attribute ((pure)); extern “C++” const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) throw () __asm (“wmemchr”) attribute ((pure));

extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) throw () attribute ((pure));

extern wchar_t *wmemcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw ();

extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) throw ();

extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();

extern wchar_t *wmempcpy (wchar_t *__restrict __s1, const wchar_t *__restrict __s2, size_t __n) throw ();

extern wint_t btowc (int __c) throw ();

extern int wctob (wint_t __c) throw ();

extern int mbsinit (const mbstate_t *__ps) throw () attribute ((pure));

extern size_t mbrtowc (wchar_t *__restrict __pwc, const char *__restrict __s, size_t __n, mbstate_t *__restrict __p) throw ();

extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, mbstate_t *__restrict __ps) throw ();

extern size_t __mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw (); extern size_t mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ();

408 “/usr/include/wchar.h” 3 4

extern size_t mbsrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ();

extern size_t wcsrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ();

extern size_t mbsnrtowcs (wchar_t *__restrict __dst, const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw ();

extern size_t wcsnrtombs (char *__restrict __dst, const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw ();

extern int wcwidth (wchar_t __c) throw ();

extern int wcswidth (const wchar_t *__s, size_t __n) throw ();

extern double wcstod (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw ();

extern float wcstof (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw (); extern long double wcstold (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr) throw ();

extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();

extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();

extension extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();

extension extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();

extension extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();

extension extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) throw ();

533 “/usr/include/wchar.h” 3 4

extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, __locale_t __loc) throw ();

extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, __locale_t __loc) throw ();

extension extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, __locale_t __loc) throw ();

extension extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, __locale_t __loc) throw ();

extern double wcstod_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, __locale_t __loc) throw ();

extern float wcstof_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, __locale_t __loc) throw ();

extern long double wcstold_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, __locale_t __loc) throw ();

extern wchar_t *wcpcpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src) throw ();

extern wchar_t *wcpncpy (wchar_t *__restrict __dest, const wchar_t *__restrict __src, size_t __n) throw ();

extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();

extern int fwide (__FILE *__fp, int __mode) throw ();

extern int fwprintf (__FILE *__restrict __stream, const wchar_t *__restrict __format, …) ;

extern int wprintf (const wchar_t *__restrict __format, …) ;

extern int swprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __format, …) throw () ;

extern int vfwprintf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) ;

extern int vwprintf (const wchar_t *__restrict __format, __gnuc_va_list __arg) ;

extern int vswprintf (wchar_t *__restrict __s, size_t __n, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () ;

extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, …) ;

extern int wscanf (const wchar_t *__restrict __format, …) ;

extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, …) throw () ;

683 “/usr/include/wchar.h” 3 4

extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) ;

extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) ;

extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) throw () ;

739 “/usr/include/wchar.h” 3 4

extern wint_t fgetwc (__FILE *__stream); extern wint_t getwc (__FILE *__stream);

extern wint_t getwchar (void);

extern wint_t fputwc (wchar_t __wc, __FILE *__stream); extern wint_t putwc (wchar_t __wc, __FILE *__stream);

extern wint_t putwchar (wchar_t __wc);

extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, __FILE *__restrict __stream);

extern int fputws (const wchar_t *__restrict __ws, __FILE *__restrict __stream);

extern wint_t ungetwc (wint_t __wc, __FILE *__stream);

804 “/usr/include/wchar.h” 3 4

extern wint_t getwc_unlocked (__FILE *__stream); extern wint_t getwchar_unlocked (void);

extern wint_t fgetwc_unlocked (__FILE *__stream);

extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);

830 “/usr/include/wchar.h” 3 4

extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); extern wint_t putwchar_unlocked (wchar_t __wc);

840 “/usr/include/wchar.h” 3 4

extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, __FILE *__restrict __stream);

extern int fputws_unlocked (const wchar_t *__restrict __ws, __FILE *__restrict __stream);

extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, const wchar_t *__restrict __format, const struct tm *__restrict __tp) throw ();

extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, const wchar_t *__restrict __format, const struct tm *__restrict __tp, __locale_t __loc) throw ();

894 “/usr/include/wchar.h” 3 4

}

45 “/usr/include/c++/5/cwchar” 2 3

62 “/usr/include/c++/5/cwchar” 3

namespace std { using ::mbstate_t; }

135 “/usr/include/c++/5/cwchar” 3

namespace std attribute ((visibility (“default”))) {

using ::wint_t;

using ::btowc; using ::fgetwc; using ::fgetws; using ::fputwc; using ::fputws; using ::fwide; using ::fwprintf; using ::fwscanf; using ::getwc; using ::getwchar; using ::mbrlen; using ::mbrtowc; using ::mbsinit; using ::mbsrtowcs; using ::putwc; using ::putwchar;

using ::swprintf;

using ::swscanf; using ::ungetwc; using ::vfwprintf;

using ::vfwscanf;

using ::vswprintf;

using ::vswscanf;

using ::vwprintf;

using ::vwscanf;

using ::wcrtomb; using ::wcscat; using ::wcscmp; using ::wcscoll; using ::wcscpy; using ::wcscspn; using ::wcsftime; using ::wcslen; using ::wcsncat; using ::wcsncmp; using ::wcsncpy; using ::wcsrtombs; using ::wcsspn; using ::wcstod;

using ::wcstof;

using ::wcstok; using ::wcstol; using ::wcstoul; using ::wcsxfrm; using ::wctob; using ::wmemcmp; using ::wmemcpy; using ::wmemmove; using ::wmemset; using ::wprintf; using ::wscanf; using ::wcschr; using ::wcspbrk; using ::wcsrchr; using ::wcsstr; using ::wmemchr;

232 “/usr/include/c++/5/cwchar” 3

}

namespace __gnu_cxx {

using ::wcstold;

257 “/usr/include/c++/5/cwchar” 3

using ::wcstoll; using ::wcstoull;

}

namespace std { using ::__gnu_cxx::wcstold; using ::__gnu_cxx::wcstoll; using ::__gnu_cxx::wcstoull; }

41 “/usr/include/c++/5/bits/postypes.h” 2 3

68 “/usr/include/c++/5/bits/postypes.h” 3

namespace std attribute ((visibility (“default”))) {

88 “/usr/include/c++/5/bits/postypes.h” 3

typedef long streamoff;

98 “/usr/include/c++/5/bits/postypes.h” 3

typedef ptrdiff_t streamsize;

111 “/usr/include/c++/5/bits/postypes.h” 3

template class fpos { private: streamoff _M_off; _StateT _M_state;

public:




  fpos()
  : _M_off(0), _M_state() { }

133 “/usr/include/c++/5/bits/postypes.h” 3

  fpos(streamoff __off)
  : _M_off(__off), _M_state() { }


  operator streamoff() const { return _M_off; }


  void
  state(_StateT __st)
  { _M_state = __st; }


  _StateT
  state() const
  { return _M_state; }





  fpos&
  operator+=(streamoff __off)
  {

_M_off += __off; return *this; }

  fpos&
  operator-=(streamoff __off)
  {

_M_off -= __off; return *this; }

  fpos
  operator+(streamoff __off) const
  {

fpos __pos(*this); __pos += __off; return __pos; }

  fpos
  operator-(streamoff __off) const
  {

fpos __pos(*this); __pos -= __off; return __pos; }

  streamoff
  operator-(const fpos& __other) const
  { return _M_off - __other._M_off; }
};

template inline bool operator(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) { return streamoff(__lhs) streamoff(__rhs); }

template inline bool operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) { return streamoff(__lhs) != streamoff(__rhs); }

typedef fpos<mbstate_t> streampos;

typedef fpos<mbstate_t> wstreampos;

239 “/usr/include/c++/5/bits/postypes.h” 3

}

41 “/usr/include/c++/5/iosfwd” 2 3

namespace std attribute ((visibility (“default”))) {

74 “/usr/include/c++/5/iosfwd” 3

class ios_base;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_ios;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_streambuf;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_istream;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_ostream;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_iostream;

namespace __cxx11 {

template<typename _CharT, typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > class basic_stringbuf;

template<typename _CharT, typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > class basic_istringstream;

template<typename _CharT, typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > class basic_ostringstream;

template<typename _CharT, typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > class basic_stringstream;

}

template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_filebuf;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_ifstream;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_ofstream;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class basic_fstream;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class istreambuf_iterator;

template<typename _CharT, typename _Traits = char_traits<_CharT> > class ostreambuf_iterator;

typedef basic_ios ios;

typedef basic_streambuf streambuf;

typedef basic_istream istream;

typedef basic_ostream ostream;

typedef basic_iostream iostream;

typedef basic_stringbuf stringbuf;

typedef basic_istringstream istringstream;

typedef basic_ostringstream ostringstream;

typedef basic_stringstream stringstream;

typedef basic_filebuf filebuf;

typedef basic_ifstream ifstream;

typedef basic_ofstream ofstream;

typedef basic_fstream fstream;

typedef basic_ios<wchar_t> wios;

typedef basic_streambuf<wchar_t> wstreambuf;

typedef basic_istream<wchar_t> wistream;

typedef basic_ostream<wchar_t> wostream;

typedef basic_iostream<wchar_t> wiostream;

typedef basic_stringbuf<wchar_t> wstringbuf;

typedef basic_istringstream<wchar_t> wistringstream;

typedef basic_ostringstream<wchar_t> wostringstream;

typedef basic_stringstream<wchar_t> wstringstream;

typedef basic_filebuf<wchar_t> wfilebuf;

typedef basic_ifstream<wchar_t> wifstream;

typedef basic_ofstream<wchar_t> wofstream;

typedef basic_fstream<wchar_t> wfstream;

}

39 “/usr/include/c++/5/ios” 2 3

1 “/usr/include/c++/5/exception” 1 3

33 “/usr/include/c++/5/exception” 3

34 “/usr/include/c++/5/exception” 3

pragma GCC visibility push(default)

1 “/usr/include/c++/5/bits/atomic_lockfree_defines.h” 1 3

33 “/usr/include/c++/5/bits/atomic_lockfree_defines.h” 3

34 “/usr/include/c++/5/bits/atomic_lockfree_defines.h” 3

39 “/usr/include/c++/5/exception” 2 3

extern “C++” {

namespace std {

60 “/usr/include/c++/5/exception” 3

class exception { public: exception() throw() { } virtual ~exception() throw();

virtual const char* what() const throw();

};

class bad_exception : public exception { public: bad_exception() throw() { }

virtual ~bad_exception() throw();


virtual const char* what() const throw();

};

typedef void (*terminate_handler) ();

typedef void (*unexpected_handler) ();

terminate_handler set_terminate(terminate_handler) throw();

102 “/usr/include/c++/5/exception” 3

void terminate() throw() attribute ((noreturn));

unexpected_handler set_unexpected(unexpected_handler) throw();

114 “/usr/include/c++/5/exception” 3

void unexpected() attribute ((noreturn));

127 “/usr/include/c++/5/exception” 3

bool uncaught_exception() throw() attribute ((pure));

}

namespace __gnu_cxx {

152 “/usr/include/c++/5/exception” 3

void __verbose_terminate_handler();

}

pragma GCC visibility pop

40 “/usr/include/c++/5/ios” 2 3

1 “/usr/include/c++/5/bits/char_traits.h” 1 3

37 “/usr/include/c++/5/bits/char_traits.h” 3

38 “/usr/include/c++/5/bits/char_traits.h” 3

1 “/usr/include/c++/5/bits/stl_algobase.h” 1 3

60 “/usr/include/c++/5/bits/stl_algobase.h” 3

1 “/usr/include/c++/5/bits/functexcept.h” 1 3

40 “/usr/include/c++/5/bits/functexcept.h” 3

1 “/usr/include/c++/5/bits/exception_defines.h” 1 3

41 “/usr/include/c++/5/bits/functexcept.h” 2 3

namespace std attribute ((visibility (“default”))) {

void __throw_bad_exception(void) attribute((noreturn));

void __throw_bad_alloc(void) attribute((noreturn));

void __throw_bad_cast(void) attribute((noreturn));

void __throw_bad_typeid(void) attribute((noreturn));

void __throw_logic_error(const char*) attribute((noreturn));

void __throw_domain_error(const char*) attribute((noreturn));

void __throw_invalid_argument(const char*) attribute((noreturn));

void __throw_length_error(const char*) attribute((noreturn));

void __throw_out_of_range(const char*) attribute((noreturn));

void __throw_out_of_range_fmt(const char*, …) attribute((noreturn)) attribute((format(gnu_printf, 1, 2)));

void __throw_runtime_error(const char*) attribute((noreturn));

void __throw_range_error(const char*) attribute((noreturn));

void __throw_overflow_error(const char*) attribute((noreturn));

void __throw_underflow_error(const char*) attribute((noreturn));

void __throw_ios_failure(const char*) attribute((noreturn));

void __throw_system_error(int) attribute((noreturn));

void __throw_future_error(int) attribute((noreturn));

void __throw_bad_function_call() attribute((noreturn));

}

61 “/usr/include/c++/5/bits/stl_algobase.h” 2 3

1 “/usr/include/c++/5/bits/cpp_type_traits.h” 1 3

35 “/usr/include/c++/5/bits/cpp_type_traits.h” 3

36 “/usr/include/c++/5/bits/cpp_type_traits.h” 3

68 “/usr/include/c++/5/bits/cpp_type_traits.h” 3

namespace __gnu_cxx attribute ((visibility (“default”))) {

template<typename _Iterator, typename _Container> class __normal_iterator;

}

namespace std attribute ((visibility (“default”))) {

struct __true_type { }; struct __false_type { };

template struct __truth_type { typedef __false_type __type; };

template<> struct __truth_type { typedef __true_type __type; };

template<class _Sp, class _Tp> struct __traitor { enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; typedef typename __truth_type<__value>::__type __type; };

template<typename, typename> struct __are_same { enum { __value = 0 }; typedef __false_type __type; };

template struct __are_same<_Tp, _Tp> { enum { __value = 1 }; typedef __true_type __type; };

template struct __is_void { enum { __value = 0 }; typedef __false_type __type; };

template<> struct __is_void { enum { __value = 1 }; typedef __true_type __type; };

template struct __is_integer { enum { __value = 0 }; typedef __false_type __type; };

template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; };

template<> struct __is_integer<wchar_t> { enum { __value = 1 }; typedef __true_type __type; };

199 “/usr/include/c++/5/bits/cpp_type_traits.h” 3

template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; };

270 “/usr/include/c++/5/bits/cpp_type_traits.h” 3

template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer { enum { __value = 1 }; typedef __true_type __type; };

287 “/usr/include/c++/5/bits/cpp_type_traits.h” 3

template struct __is_floating { enum { __value = 0 }; typedef __false_type __type; };

template<> struct __is_floating { enum { __value = 1 }; typedef __true_type __type; };

template struct __is_pointer { enum { __value = 0 }; typedef __false_type __type; };

template struct __is_pointer<_Tp*> { enum { __value = 1 }; typedef __true_type __type; };

template struct __is_normal_iterator { enum { __value = 0 }; typedef __false_type __type; };

template<typename _Iterator, typename _Container> struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator, _Container> > { enum { __value = 1 }; typedef __true_type __type; };

template struct __is_arithmetic : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > { };

template struct __is_scalar : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > { };

template struct __is_char { enum { __value = 0 }; typedef __false_type __type; };

template<> struct __is_char { enum { __value = 1 }; typedef __true_type __type; };

template<> struct __is_char<wchar_t> { enum { __value = 1 }; typedef __true_type __type; };

template struct __is_byte { enum { __value = 0 }; typedef __false_type __type; };

template<> struct __is_byte { enum { __value = 1 }; typedef __true_type __type; };

template struct __is_move_iterator { enum { __value = 0 }; typedef __false_type __type; };

443 “/usr/include/c++/5/bits/cpp_type_traits.h” 3

}

62 “/usr/include/c++/5/bits/stl_algobase.h” 2 3

1 “/usr/include/c++/5/ext/type_traits.h” 1 3

32 “/usr/include/c++/5/ext/type_traits.h” 3

33 “/usr/include/c++/5/ext/type_traits.h” 3

namespace __gnu_cxx attribute ((visibility (“default”))) {

template<bool, typename> struct __enable_if { };

template struct __enable_if<true, _Tp> { typedef _Tp __type; };

template<bool _Cond, typename _Iftrue, typename _Iffalse> struct __conditional_type { typedef _Iftrue __type; };

template<typename _Iftrue, typename _Iffalse> struct __conditional_type<false, _Iftrue, _Iffalse> { typedef _Iffalse __type; };

template struct __add_unsigned { private: typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

public:
  typedef typename __if_type::__type __type;
};

template<> struct __add_unsigned { typedef unsigned char __type; };

template<> struct __add_unsigned { typedef unsigned short __type; };

template<> struct __add_unsigned { typedef unsigned int __type; };

template<> struct __add_unsigned { typedef unsigned long __type; };

template<> struct __add_unsigned { typedef unsigned long long __type; };

template<> struct __add_unsigned;

template<> struct __add_unsigned<wchar_t>;

template struct __remove_unsigned { private: typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;

public:
  typedef typename __if_type::__type __type;
};

template<> struct __remove_unsigned { typedef signed char __type; };

template<> struct __remove_unsigned { typedef short __type; };

template<> struct __remove_unsigned { typedef int __type; };

template<> struct __remove_unsigned { typedef long __type; };

template<> struct __remove_unsigned { typedef long long __type; };

template<> struct __remove_unsigned;

template<> struct __remove_unsigned<wchar_t>;

template inline bool __is_null_pointer(_Type* __ptr) { return __ptr == 0; }

template inline bool __is_null_pointer(_Type) { return false; }

165 “/usr/include/c++/5/ext/type_traits.h” 3

template<typename _Tp, bool = std::__is_integer<_Tp>::__value> struct __promote { typedef double __type; };

template struct __promote<_Tp, false> { };

template<> struct __promote { typedef long double __type; };

template<> struct __promote { typedef double __type; };

template<> struct __promote { typedef float __type; };

template<typename _Tp, typename _Up, typename _Tp2 = typename __promote<_Tp>::__type, typename _Up2 = typename __promote<_Up>::__type> struct __promote_2 { typedef typeof(_Tp2() + _Up2()) __type; };

template<typename _Tp, typename _Up, typename _Vp, typename _Tp2 = typename __promote<_Tp>::__type, typename _Up2 = typename __promote<_Up>::__type, typename _Vp2 = typename __promote<_Vp>::__type> struct __promote_3 { typedef typeof(_Tp2() + _Up2() + _Vp2()) __type; };

template<typename _Tp, typename _Up, typename _Vp, typename _Wp, typename _Tp2 = typename __promote<_Tp>::__type, typename _Up2 = typename __promote<_Up>::__type, typename _Vp2 = typename __promote<_Vp>::__type, typename _Wp2 = typename __promote<_Wp>::__type> struct __promote_4 { typedef typeof(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type; };

}

63 “/usr/include/c++/5/bits/stl_algobase.h” 2 3

1 “/usr/include/c++/5/ext/numeric_traits.h” 1 3

32 “/usr/include/c++/5/ext/numeric_traits.h” 3

33 “/usr/include/c++/5/ext/numeric_traits.h” 3

namespace __gnu_cxx attribute ((visibility (“default”))) {

54 “/usr/include/c++/5/ext/numeric_traits.h” 3

template struct __numeric_traits_integer {

  static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
  static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);



  static const bool __is_signed = ((_Value)(-1) < 0);
  static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
};

template const _Value __numeric_traits_integer<_Value>::__min;

template const _Value __numeric_traits_integer<_Value>::__max;

template const bool __numeric_traits_integer<_Value>::__is_signed;

template const int __numeric_traits_integer<_Value>::__digits;

99 “/usr/include/c++/5/ext/numeric_traits.h” 3

template struct __numeric_traits_floating {

  static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);


  static const bool __is_signed = true;
  static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
  static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
};

template const int __numeric_traits_floating<_Value>::__max_digits10;

template const bool __numeric_traits_floating<_Value>::__is_signed;

template const int __numeric_traits_floating<_Value>::__digits10;

template const int __numeric_traits_floating<_Value>::__max_exponent10;

template struct __numeric_traits : public __conditional_type<std::__is_integer<_Value>::__value, __numeric_traits_integer<_Value>, __numeric_traits_floating<_Value> >::__type { };

}

64 “/usr/include/c++/5/bits/stl_algobase.h” 2 3

1 “/usr/include/c++/5/bits/stl_pair.h” 1 3

59 “/usr/include/c++/5/bits/stl_pair.h” 3

1 “/usr/include/c++/5/bits/move.h” 1 3

34 “/usr/include/c++/5/bits/move.h” 3

1 “/usr/include/c++/5/bits/concept_check.h” 1 3

33 “/usr/include/c++/5/bits/concept_check.h” 3

34 “/usr/include/c++/5/bits/concept_check.h” 3

35 “/usr/include/c++/5/bits/move.h” 2 3

namespace std attribute ((visibility (“default”))) {

template inline _Tp* __addressof(_Tp& __r) { return reinterpret_cast<_Tp*> (&const_cast<char&>(reinterpret_cast<const volatile char&>(__r))); }

}

159 “/usr/include/c++/5/bits/move.h” 3

namespace std attribute ((visibility (“default”))) {

174 “/usr/include/c++/5/bits/move.h” 3

template inline void swap(_Tp& __a, _Tp& __b)

{

 

  _Tp __tmp = (__a);
  __a = (__b);
  __b = (__tmp);
}

template<typename _Tp, size_t _Nm> inline void swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])

{
  for (size_t __n = 0; __n < _Nm; ++__n)

swap(__a[__n], __b[__n]); }

}

60 “/usr/include/c++/5/bits/stl_pair.h” 2 3

namespace std attribute ((visibility (“default”))) {

95 “/usr/include/c++/5/bits/stl_pair.h” 3

template<class _T1, class _T2> struct pair { typedef _T1 first_type; typedef _T2 second_type;

  _T1 first;
  _T2 second;





  pair()
  : first(), second() { }


  pair(const _T1& __a, const _T2& __b)
  : first(__a), second(__b) { }



  template<class _U1, class _U2>

pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) { }

209 “/usr/include/c++/5/bits/stl_pair.h” 3

};

template<class _T1, class _T2> inline bool operator(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return __x.first __y.first && __x.second == __y.second; }

template<class _T1, class _T2> inline bool operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second); }

template<class _T1, class _T2> inline bool operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return !(__x == __y); }

template<class _T1, class _T2> inline bool operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return __y < __x; }

template<class _T1, class _T2> inline bool operator⇐(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return !(__y < __x); }

template<class _T1, class _T2> inline bool operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) { return !(__x < __y); }

284 “/usr/include/c++/5/bits/stl_pair.h” 3

template<class _T1, class _T2> inline pair<_T1, _T2> make_pair(_T1 __x, _T2 __y) { return pair<_T1, _T2>(__x, __y); }

}

65 “/usr/include/c++/5/bits/stl_algobase.h” 2 3

1 “/usr/include/c++/5/bits/stl_iterator_base_types.h” 1 3

62 “/usr/include/c++/5/bits/stl_iterator_base_types.h” 3

63 “/usr/include/c++/5/bits/stl_iterator_base_types.h” 3

namespace std attribute ((visibility (“default”))) {

89 “/usr/include/c++/5/bits/stl_iterator_base_types.h” 3

struct input_iterator_tag { };

struct output_iterator_tag { };

struct forward_iterator_tag : public input_iterator_tag { };

struct bidirectional_iterator_tag : public forward_iterator_tag { };

struct random_access_iterator_tag : public bidirectional_iterator_tag { };

116 “/usr/include/c++/5/bits/stl_iterator_base_types.h” 3

template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t, typename _Pointer = _Tp*, typename _Reference = _Tp&> struct iterator {

  typedef _Category iterator_category;

  typedef _Tp value_type;

  typedef _Distance difference_type;

  typedef _Pointer pointer;

  typedef _Reference reference;
};

165 “/usr/include/c++/5/bits/stl_iterator_base_types.h” 3

template struct iterator_traits { typedef typename _Iterator::iterator_category iterator_category; typedef typename _Iterator::value_type value_type; typedef typename _Iterator::difference_type difference_type; typedef typename _Iterator::pointer pointer; typedef typename _Iterator::reference reference; };

template struct iterator_traits<_Tp*> { typedef random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef ptrdiff_t difference_type; typedef _Tp* pointer; typedef _Tp& reference; };

template struct iterator_traits<const _Tp*> { typedef random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef ptrdiff_t difference_type; typedef const _Tp* pointer; typedef const _Tp& reference; };

template inline typename iterator_traits<_Iter>::iterator_category __iterator_category(const _Iter&) { return typename iterator_traits<_Iter>::iterator_category(); }

template<typename _Iterator, bool _HasBase> struct _Iter_base { typedef _Iterator iterator_type; static iterator_type _S_base(_Iterator __it) { return __it; } };

template struct _Iter_base<_Iterator, true> { typedef typename _Iterator::iterator_type iterator_type; static iterator_type _S_base(_Iterator __it) { return __it.base(); } };

235 “/usr/include/c++/5/bits/stl_iterator_base_types.h” 3

}

66 “/usr/include/c++/5/bits/stl_algobase.h” 2 3

1 “/usr/include/c++/5/bits/stl_iterator_base_funcs.h” 1 3

62 “/usr/include/c++/5/bits/stl_iterator_base_funcs.h” 3

63 “/usr/include/c++/5/bits/stl_iterator_base_funcs.h” 3

1 “/usr/include/c++/5/debug/debug.h” 1 3

46 “/usr/include/c++/5/debug/debug.h” 3

namespace std { namespace __debug { } }

namespace __gnu_debug { using namespace std::__debug; }

66 “/usr/include/c++/5/bits/stl_iterator_base_funcs.h” 2 3

namespace std attribute ((visibility (“default”))) {

template inline typename iterator_traits<_InputIterator>::difference_type __distance(_InputIterator __first, _InputIterator __last, input_iterator_tag) {

  typename iterator_traits<_InputIterator>::difference_type __n = 0;
  while (__first != __last)

{ ++__first; ++__n; } return __n; }

template inline typename iterator_traits<_RandomAccessIterator>::difference_type __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) {

  return __last - __first;
}

112 “/usr/include/c++/5/bits/stl_iterator_base_funcs.h” 3

template inline typename iterator_traits<_InputIterator>::difference_type distance(_InputIterator __first, _InputIterator __last) {

  return std::__distance(__first, __last,
    std::__iterator_category(__first));
}

template<typename _InputIterator, typename _Distance> inline void __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) {

  ;
  while (__n--)

++__i; }

template<typename _BidirectionalIterator, typename _Distance> inline void __advance(_BidirectionalIterator& __i, _Distance __n, bidirectional_iterator_tag) {

  if (__n > 0)
    while (__n--)

++__i; else while (__n++) —__i; }

template<typename _RandomAccessIterator, typename _Distance> inline void __advance(_RandomAccessIterator& __i, _Distance __n, random_access_iterator_tag) {

  __i += __n;
}

171 “/usr/include/c++/5/bits/stl_iterator_base_funcs.h” 3

template<typename _InputIterator, typename _Distance> inline void advance(_InputIterator& __i, _Distance __n) {

  typename iterator_traits<_InputIterator>::difference_type __d = __n;
  std::__advance(__i, __d, std::__iterator_category(__i));
}

202 “/usr/include/c++/5/bits/stl_iterator_base_funcs.h” 3

}

67 “/usr/include/c++/5/bits/stl_algobase.h” 2 3

1 “/usr/include/c++/5/bits/stl_iterator.h” 1 3

66 “/usr/include/c++/5/bits/stl_iterator.h” 3

1 “/usr/include/c++/5/bits/ptr_traits.h” 1 3

67 “/usr/include/c++/5/bits/stl_iterator.h” 2 3

namespace std attribute ((visibility (“default”))) {

96 “/usr/include/c++/5/bits/stl_iterator.h” 3

template class reverse_iterator : public iterator<typename iterator_traits<_Iterator>::iterator_category, typename iterator_traits<_Iterator>::value_type, typename iterator_traits<_Iterator>::difference_type, typename iterator_traits<_Iterator>::pointer, typename iterator_traits<_Iterator>::reference> { protected: _Iterator current;

  typedef iterator_traits<_Iterator> __traits_type;

public:
  typedef _Iterator iterator_type;
  typedef typename __traits_type::difference_type difference_type;
  typedef typename __traits_type::pointer pointer;
  typedef typename __traits_type::reference reference;







  reverse_iterator() : current() { }




  explicit
  reverse_iterator(iterator_type __x) : current(__x) { }




  reverse_iterator(const reverse_iterator& __x)
  : current(__x.current) { }





  template<typename _Iter>
    reverse_iterator(const reverse_iterator<_Iter>& __x)

: current(__x.base()) { }

  iterator_type
  base() const
  { return current; }

160 “/usr/include/c++/5/bits/stl_iterator.h” 3

  reference
  operator*() const
  {

_Iterator __tmp = current; return *—__tmp; }

  pointer
  operator->() const
  { return &(operator*()); }






  reverse_iterator&
  operator++()
  {

—current; return *this; }

  reverse_iterator
  operator++(int)
  {

reverse_iterator __tmp = *this; —current; return __tmp; }

  reverse_iterator&
  operator--()
  {

++current; return *this; }

  reverse_iterator
  operator--(int)
  {

reverse_iterator __tmp = *this; ++current; return __tmp; }

  reverse_iterator
  operator+(difference_type __n) const
  { return reverse_iterator(current - __n); }







  reverse_iterator&
  operator+=(difference_type __n)
  {

current -= __n; return *this; }

  reverse_iterator
  operator-(difference_type __n) const
  { return reverse_iterator(current + __n); }







  reverse_iterator&
  operator-=(difference_type __n)
  {

current += __n; return *this; }

  reference
  operator[](difference_type __n) const
  { return *(*this + __n); }
};

290 “/usr/include/c++/5/bits/stl_iterator.h” 3

template inline bool operator(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __x.base() __y.base(); }

template inline bool operator<(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __y.base() < __x.base(); }

template inline bool operator!=(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return !(__x == __y); }

template inline bool operator>(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __y < __x; }

template inline bool operator⇐(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return !(__y < __x); }

template inline bool operator>=(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return !(__x < __y); }

template inline typename reverse_iterator<_Iterator>::difference_type operator-(const reverse_iterator<_Iterator>& __x, const reverse_iterator<_Iterator>& __y) { return __y.base() - __x.base(); }

template inline reverse_iterator<_Iterator> operator+(typename reverse_iterator<_Iterator>::difference_type __n, const reverse_iterator<_Iterator>& __x) { return reverse_iterator<_Iterator>(__x.base() - __n); }

template<typename _IteratorL, typename _IteratorR> inline bool operator(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __x.base() __y.base(); }

template<typename _IteratorL, typename _IteratorR> inline bool operator<(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __y.base() < __x.base(); }

template<typename _IteratorL, typename _IteratorR> inline bool operator!=(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return !(__x == __y); }

template<typename _IteratorL, typename _IteratorR> inline bool operator>(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return __y < __x; }

template<typename _IteratorL, typename _IteratorR> inline bool operator⇐(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return !(__y < __x); }

template<typename _IteratorL, typename _IteratorR> inline bool operator>=(const reverse_iterator<_IteratorL>& __x, const reverse_iterator<_IteratorR>& __y) { return !(__x < __y); }

template<typename _IteratorL, typename _IteratorR>

inline typename reverse_iterator<_IteratorL>::difference_type
operator-(const reverse_iterator<_IteratorL>& __x,
   const reverse_iterator<_IteratorR>& __y)

{ return __y.base() - __x.base(); }

414 “/usr/include/c++/5/bits/stl_iterator.h” 3

template class back_insert_iterator : public iterator<output_iterator_tag, void, void, void, void> { protected: _Container* container;

public:

  typedef _Container container_type;


  explicit
  back_insert_iterator(_Container& __x) : container(&__x) { }

441 “/usr/include/c++/5/bits/stl_iterator.h” 3

  back_insert_iterator&
  operator=(typename _Container::const_reference __value)
  {

container→push_back(__value); return *this; }

464 “/usr/include/c++/5/bits/stl_iterator.h” 3

  back_insert_iterator&
  operator*()
  { return *this; }


  back_insert_iterator&
  operator++()
  { return *this; }


  back_insert_iterator
  operator++(int)
  { return *this; }
};

490 “/usr/include/c++/5/bits/stl_iterator.h” 3

template inline back_insert_iterator<_Container> back_inserter(_Container& __x) { return back_insert_iterator<_Container>(__x); }

505 “/usr/include/c++/5/bits/stl_iterator.h” 3

template class front_insert_iterator : public iterator<output_iterator_tag, void, void, void, void> { protected: _Container* container;

public:

  typedef _Container container_type;


  explicit front_insert_iterator(_Container& __x) : container(&__x) { }

531 “/usr/include/c++/5/bits/stl_iterator.h” 3

  front_insert_iterator&
  operator=(typename _Container::const_reference __value)
  {

container→push_front(__value); return *this; }

554 “/usr/include/c++/5/bits/stl_iterator.h” 3

  front_insert_iterator&
  operator*()
  { return *this; }


  front_insert_iterator&
  operator++()
  { return *this; }


  front_insert_iterator
  operator++(int)
  { return *this; }
};

580 “/usr/include/c++/5/bits/stl_iterator.h” 3

template inline front_insert_iterator<_Container> front_inserter(_Container& __x) { return front_insert_iterator<_Container>(__x); }

599 “/usr/include/c++/5/bits/stl_iterator.h” 3

template class insert_iterator : public iterator<output_iterator_tag, void, void, void, void> { protected: _Container* container; typename _Container::iterator iter;

public:

  typedef _Container container_type;





  insert_iterator(_Container& __x, typename _Container::iterator __i)
  : container(&__x), iter(__i) {}

642 “/usr/include/c++/5/bits/stl_iterator.h” 3

  insert_iterator&
  operator=(typename _Container::const_reference __value)
  {

iter = container→insert(iter, __value); ++iter; return *this; }

668 “/usr/include/c++/5/bits/stl_iterator.h” 3

  insert_iterator&
  operator*()
  { return *this; }


  insert_iterator&
  operator++()
  { return *this; }


  insert_iterator&
  operator++(int)
  { return *this; }
};

694 “/usr/include/c++/5/bits/stl_iterator.h” 3

template<typename _Container, typename _Iterator> inline insert_iterator<_Container> inserter(_Container& __x, _Iterator __i) { return insert_iterator<_Container>(__x, typename _Container::iterator(__i)); }

}

namespace __gnu_cxx attribute ((visibility (“default”))) {

718 “/usr/include/c++/5/bits/stl_iterator.h” 3

using std::iterator_traits; using std::iterator; template<typename _Iterator, typename _Container> class __normal_iterator { protected: _Iterator _M_current;

  typedef iterator_traits<_Iterator> __traits_type;

public:
  typedef _Iterator iterator_type;
  typedef typename __traits_type::iterator_category iterator_category;
  typedef typename __traits_type::value_type value_type;
  typedef typename __traits_type::difference_type difference_type;
  typedef typename __traits_type::reference reference;
  typedef typename __traits_type::pointer pointer;

  __normal_iterator()
  : _M_current(_Iterator()) { }

  explicit
  __normal_iterator(const _Iterator& __i)
  : _M_current(__i) { }


  template<typename _Iter>
    __normal_iterator(const __normal_iterator<_Iter,
 typename __enable_if<
          (std::__are_same<_Iter, typename _Container::pointer>::__value),
    _Container>::__type>& __i)
    : _M_current(__i.base()) { }


  reference
  operator*() const
  { return *_M_current; }

  pointer
  operator->() const
  { return _M_current; }

  __normal_iterator&
  operator++()
  {

++_M_current; return *this; }

  __normal_iterator
  operator++(int)
  { return __normal_iterator(_M_current++); }


  __normal_iterator&
  operator--()
  {

—_M_current; return *this; }

  __normal_iterator
  operator--(int)
  { return __normal_iterator(_M_current--); }


  reference
  operator[](difference_type __n) const
  { return _M_current[__n]; }

  __normal_iterator&
  operator+=(difference_type __n)
  { _M_current += __n; return *this; }

  __normal_iterator
  operator+(difference_type __n) const
  { return __normal_iterator(_M_current + __n); }

  __normal_iterator&
  operator-=(difference_type __n)
  { _M_current -= __n; return *this; }

  __normal_iterator
  operator-(difference_type __n) const
  { return __normal_iterator(_M_current - __n); }

  const _Iterator&
  base() const
  { return _M_current; }
};

818 “/usr/include/c++/5/bits/stl_iterator.h” 3

template<typename _IteratorL, typename _IteratorR, typename _Container> inline bool operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs)

{ return __lhs.base() == __rhs.base(); }

template<typename _Iterator, typename _Container> inline bool operator==(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs)

{ return __lhs.base() == __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container> inline bool operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs)

{ return __lhs.base() != __rhs.base(); }

template<typename _Iterator, typename _Container> inline bool operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs)

{ return __lhs.base() != __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container> inline bool operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs)

{ return __lhs.base() < __rhs.base(); }

template<typename _Iterator, typename _Container> inline bool operator<(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs)

{ return __lhs.base() < __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container> inline bool operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs)

{ return __lhs.base() > __rhs.base(); }

template<typename _Iterator, typename _Container> inline bool operator>(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs)

{ return __lhs.base() > __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container> inline bool operator⇐(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs)

{ return __lhs.base() <= __rhs.base(); }

template<typename _Iterator, typename _Container> inline bool operator⇐(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs)

{ return __lhs.base() <= __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container> inline bool operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, const __normal_iterator<_IteratorR, _Container>& __rhs)

{ return __lhs.base() >= __rhs.base(); }

template<typename _Iterator, typename _Container> inline bool operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs)

{ return __lhs.base() >= __rhs.base(); }

template<typename _IteratorL, typename _IteratorR, typename _Container>

inline typename __normal_iterator<_IteratorL, _Container>::difference_type
operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
   const __normal_iterator<_IteratorR, _Container>& __rhs)

{ return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container> inline typename __normal_iterator<_Iterator, _Container>::difference_type operator-(const __normal_iterator<_Iterator, _Container>& __lhs, const __normal_iterator<_Iterator, _Container>& __rhs)

{ return __lhs.base() - __rhs.base(); }

template<typename _Iterator, typename _Container> inline __normal_iterator<_Iterator, _Container> operator+(typename __normal_iterator<_Iterator, _Container>::difference_type __n, const __normal_iterator<_Iterator, _Container>& __i)

{ return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }

}

68 “/usr/include/c++/5/bits/stl_algobase.h” 2 3

1 “/usr/include/c++/5/bits/predefined_ops.h” 1 3

33 “/usr/include/c++/5/bits/predefined_ops.h” 3

namespace __gnu_cxx { namespace __ops { struct _Iter_less_iter { template<typename _Iterator1, typename _Iterator2>

  bool
  operator()(_Iterator1 __it1, _Iterator2 __it2) const
  { return *__it1 < *__it2; }

};

inline _Iter_less_iter __iter_less_iter() { return _Iter_less_iter(); }

struct _Iter_less_val { template<typename _Iterator, typename _Value> bool operator()(_Iterator __it, _Value& __val) const { return *__it < __val; } };

inline _Iter_less_val __iter_less_val() { return _Iter_less_val(); }

inline _Iter_less_val __iter_comp_val(_Iter_less_iter) { return _Iter_less_val(); }

struct _Val_less_iter { template<typename _Value, typename _Iterator> bool operator()(_Value& __val, _Iterator __it) const { return __val < *__it; } };

inline _Val_less_iter __val_less_iter() { return _Val_less_iter(); }

inline _Val_less_iter __val_comp_iter(_Iter_less_iter) { return _Val_less_iter(); }

struct _Iter_equal_to_iter { template<typename _Iterator1, typename _Iterator2> bool operator()(_Iterator1 __it1, _Iterator2 __it2) const { return *__it1 == *__it2; } };

inline _Iter_equal_to_iter __iter_equal_to_iter() { return _Iter_equal_to_iter(); }

struct _Iter_equal_to_val { template<typename _Iterator, typename _Value> bool operator()(_Iterator __it, _Value& __val) const { return *__it == __val; } };

inline _Iter_equal_to_val __iter_equal_to_val() { return _Iter_equal_to_val(); }

inline _Iter_equal_to_val __iter_comp_val(_Iter_equal_to_iter) { return _Iter_equal_to_val(); }

template struct _Iter_comp_iter { _Compare _M_comp;

  _Iter_comp_iter(_Compare __comp)

: _M_comp(__comp) { }

  template<typename _Iterator1, typename _Iterator2>
   
    bool
    operator()(_Iterator1 __it1, _Iterator2 __it2)
    { return bool(_M_comp(*__it1, *__it2)); }
};

template

inline _Iter_comp_iter<_Compare>
__iter_comp_iter(_Compare __comp)
{ return _Iter_comp_iter<_Compare>(__comp); }

template struct _Iter_comp_val { _Compare _M_comp;

  _Iter_comp_val(_Compare __comp)

: _M_comp(__comp) { }

  template<typename _Iterator, typename _Value>

bool operator()(_Iterator __it, _Value& __val) { return bool(_M_comp(*__it, __val)); } };

template inline _Iter_comp_val<_Compare> __iter_comp_val(_Compare __comp) { return _Iter_comp_val<_Compare>(__comp); }

template inline _Iter_comp_val<_Compare> __iter_comp_val(_Iter_comp_iter<_Compare> __comp) { return _Iter_comp_val<_Compare>(__comp._M_comp); }

template struct _Val_comp_iter { _Compare _M_comp;

  _Val_comp_iter(_Compare __comp)

: _M_comp(__comp) { }

  template<typename _Value, typename _Iterator>

bool operator()(_Value& __val, _Iterator __it) { return bool(_M_comp(__val, *__it)); } };

template inline _Val_comp_iter<_Compare> __val_comp_iter(_Compare __comp) { return _Val_comp_iter<_Compare>(__comp); }

template inline _Val_comp_iter<_Compare> __val_comp_iter(_Iter_comp_iter<_Compare> __comp) { return _Val_comp_iter<_Compare>(__comp._M_comp); }

template struct _Iter_equals_val { _Value& _M_value;

  _Iter_equals_val(_Value& __value)

: _M_value(__value) { }

  template<typename _Iterator>

bool operator()(_Iterator __it) { return *__it == _M_value; } };

template inline _Iter_equals_val<_Value> __iter_equals_val(_Value& __val) { return _Iter_equals_val<_Value>(__val); }

template struct _Iter_equals_iter { typename std::iterator_traits<_Iterator1>::reference _M_ref;

  _Iter_equals_iter(_Iterator1 __it1)

: _M_ref(*__it1) { }

  template<typename _Iterator2>

bool operator()(_Iterator2 __it2) { return *__it2 == _M_ref; } };

template inline _Iter_equals_iter<_Iterator> __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) { return _Iter_equals_iter<_Iterator>(__it); }

template struct _Iter_pred { _Predicate _M_pred;

  _Iter_pred(_Predicate __pred)

: _M_pred(__pred) { }

  template<typename _Iterator>

bool operator()(_Iterator __it) { return bool(_M_pred(*__it)); } };

template inline _Iter_pred<_Predicate> __pred_iter(_Predicate __pred) { return _Iter_pred<_Predicate>(__pred); }

template<typename _Compare, typename _Value> struct _Iter_comp_to_val { _Compare _M_comp; _Value& _M_value;

  _Iter_comp_to_val(_Compare __comp, _Value& __value)

: _M_comp(__comp), _M_value(__value) { }

  template<typename _Iterator>

bool operator()(_Iterator __it) { return bool(_M_comp(*__it, _M_value)); } };

template<typename _Compare, typename _Value> _Iter_comp_to_val<_Compare, _Value> __iter_comp_val(_Compare __comp, _Value &__val) { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); }

template<typename _Compare, typename _Iterator1> struct _Iter_comp_to_iter { _Compare _M_comp; typename std::iterator_traits<_Iterator1>::reference _M_ref;

  _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)

: _M_comp(__comp), _M_ref(*__it1) { }

  template<typename _Iterator2>

bool operator()(_Iterator2 __it2) { return bool(_M_comp(*__it2, _M_ref)); } };

template<typename _Compare, typename _Iterator> inline _Iter_comp_to_iter<_Compare, _Iterator> __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) { return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); }

template struct _Iter_negate { _Predicate _M_pred;

  _Iter_negate(_Predicate __pred)

: _M_pred(__pred) { }

  template<typename _Iterator>

bool operator()(_Iterator __it) { return !bool(_M_pred(*__it)); } };

template inline _Iter_negate<_Predicate> __negate(_Iter_pred<_Predicate> __pred) { return _Iter_negate<_Predicate>(__pred._M_pred); }

} }

72 “/usr/include/c++/5/bits/stl_algobase.h” 2 3

namespace std attribute ((visibility (“default”))) {

template struct __iter_swap { template<typename _ForwardIterator1, typename _ForwardIterator2> static void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) { typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType1; _ValueType1 __tmp = (*__a); __a = (__b); *__b = (__tmp); } };

template<> struct __iter_swap { template<typename _ForwardIterator1, typename _ForwardIterator2> static void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) { swap(*__a, *__b); } };

118 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _ForwardIterator1, typename _ForwardIterator2> inline void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) {

  typedef typename iterator_traits<_ForwardIterator1>::value_type

_ValueType1; typedef typename iterator_traits<_ForwardIterator2>::value_type _ValueType2;

  typedef typename iterator_traits<_ForwardIterator1>::reference

_ReferenceType1; typedef typename iterator_traits<_ForwardIterator2>::reference _ReferenceType2; std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value && __are_same<_ValueType1&, _ReferenceType1>::__value && __are_same<_ValueType2&, _ReferenceType2>::__value>:: iter_swap(__a, __b);

164 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _ForwardIterator1, typename _ForwardIterator2> _ForwardIterator2 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {

  ;

  for (; __first1 != __last1; ++__first1, ++__first2)

std::iter_swap(__first1, __first2); return __first2; }

192 “/usr/include/c++/5/bits/stl_algobase.h” 3

template

inline const _Tp&
min(const _Tp& __a, const _Tp& __b)
{

 

  if (__b < __a)

return __b; return __a; }

216 “/usr/include/c++/5/bits/stl_algobase.h” 3

template

inline const _Tp&
max(const _Tp& __a, const _Tp& __b)
{

 

  if (__a < __b)

return __b; return __a; }

240 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _Tp, typename _Compare>

inline const _Tp&
min(const _Tp& __a, const _Tp& __b, _Compare __comp)
{

  if (__comp(__b, __a))

return __b; return __a; }

262 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _Tp, typename _Compare>

inline const _Tp&
max(const _Tp& __a, const _Tp& __b, _Compare __comp)
{

  if (__comp(__a, __b))

return __b; return __a; }

template struct _Niter_base : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value> { };

template inline typename _Niter_base<_Iterator>::iterator_type __niter_base(_Iterator __it) { return std::_Niter_base<_Iterator>::_S_base(__it); }

template struct _Miter_base : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value> { };

template inline typename _Miter_base<_Iterator>::iterator_type __miter_base(_Iterator __it) { return std::_Miter_base<_Iterator>::_S_base(__it); }

template<bool, bool, typename> struct __copy_move { template<typename _II, typename _OI> static _OI __copy_m(_II __first, _II __last, _OI __result) { for (; __first != __last; ++__result, ++__first) *__result = *__first; return __result; } };

330 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<> struct __copy_move<false, false, random_access_iterator_tag> { template<typename _II, typename _OI> static _OI __copy_m(_II __first, _II __last, _OI __result) { typedef typename iterator_traits<_II>::difference_type _Distance; for(_Distance __n = __last - __first; __n > 0; —__n) { *__result = *__first; ++__first; ++__result; } return __result; } };

368 “/usr/include/c++/5/bits/stl_algobase.h” 3

template struct __copy_move<_IsMove, true, random_access_iterator_tag> { template static _Tp* __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) {

const ptrdiff_t _Num = __last - __first; if (_Num) __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); return __result + _Num; } };

template<bool _IsMove, typename _II, typename _OI> inline _OI __copy_move_a(_II __first, _II __last, _OI __result) { typedef typename iterator_traits<_II>::value_type _ValueTypeI; typedef typename iterator_traits<_OI>::value_type _ValueTypeO; typedef typename iterator_traits<_II>::iterator_category _Category; const bool __simple = (__is_trivial(_ValueTypeI) && __is_pointer<_II>::__value && __is_pointer<_OI>::__value && __are_same<_ValueTypeI, _ValueTypeO>::__value);

  return std::__copy_move<_IsMove, __simple,
                   _Category>::__copy_m(__first, __last, __result);
}

template struct char_traits;

template<typename _CharT, typename _Traits> class istreambuf_iterator;

template<typename _CharT, typename _Traits> class ostreambuf_iterator;

template<bool _IsMove, typename _CharT> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type __copy_move_a2(_CharT*, _CharT*, ostreambuf_iterator<_CharT, char_traits<_CharT> >);

template<bool _IsMove, typename _CharT> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type __copy_move_a2(const _CharT*, const _CharT*, ostreambuf_iterator<_CharT, char_traits<_CharT> >);

template<bool _IsMove, typename _II, typename _OI> inline _OI __copy_move_a2(_II __first, _II __last, _OI __result) { return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); }

460 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _II, typename _OI> inline _OI copy(_II __first, _II __last, _OI __result) {

  ;

  return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
   (std::__miter_base(__first), std::__miter_base(__last),
    __result));
}

512 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<bool, bool, typename> struct __copy_move_backward { template<typename _BI1, typename _BI2> static _BI2 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) { while (__first != __last) *—__result = *—__last; return __result; } };

540 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<> struct __copy_move_backward<false, false, random_access_iterator_tag> { template<typename _BI1, typename _BI2> static _BI2 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) { typename iterator_traits<_BI1>::difference_type __n; for (__n = __last - __first; __n > 0; —__n) *—__result = *—__last; return __result; } };

570 “/usr/include/c++/5/bits/stl_algobase.h” 3

template struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> { template static _Tp* __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result) {

const ptrdiff_t _Num = __last - __first; if (_Num) __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); return __result - _Num; } };

template<bool _IsMove, typename _BI1, typename _BI2> inline _BI2 __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result) { typedef typename iterator_traits<_BI1>::value_type _ValueType1; typedef typename iterator_traits<_BI2>::value_type _ValueType2; typedef typename iterator_traits<_BI1>::iterator_category _Category; const bool __simple = (__is_trivial(_ValueType1) && __is_pointer<_BI1>::__value && __is_pointer<_BI2>::__value && __are_same<_ValueType1, _ValueType2>::__value);

  return std::__copy_move_backward<_IsMove, __simple,
                            _Category>::__copy_move_b(__first,
     __last,
     __result);
}

template<bool _IsMove, typename _BI1, typename _BI2> inline _BI2 __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) { return _BI2(std::__copy_move_backward_a<_IsMove> (std::__niter_base(__first), std::__niter_base(__last), std::__niter_base(__result))); }

636 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _BI1, typename _BI2> inline _BI2 copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) {

  ;

  return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
   (std::__miter_base(__first), std::__miter_base(__last),
    __result));
}

694 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _ForwardIterator, typename _Tp> inline typename __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type __fill_a(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { for (; __first != __last; ++__first) *__first = __value; }

template<typename _ForwardIterator, typename _Tp> inline typename __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type __fill_a(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) { const _Tp __tmp = __value; for (; __first != __last; ++__first) *__first = __tmp; }

template inline typename __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c) { const _Tp __tmp = __c; if (const size_t __len = __last - __first) __builtin_memset(__first, static_cast(__tmp), __len); }

738 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _ForwardIterator, typename _Tp> inline void fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {

  ;

  std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
  __value);
}

template<typename _OutputIterator, typename _Size, typename _Tp> inline typename __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) { for (__decltype(__n + 0) __niter = __n; __niter > 0; —__niter, ++__first) *__first = __value; return __first; }

template<typename _OutputIterator, typename _Size, typename _Tp> inline typename __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) { const _Tp __tmp = __value; for (__decltype(__n + 0) __niter = __n; __niter > 0; —__niter, ++__first) *__first = __tmp; return __first; }

template<typename _Size, typename _Tp> inline typename __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c) { std::__fill_a(__first, __first + __n, __c); return __first + __n; }

798 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _OI, typename _Size, typename _Tp> inline _OI fill_n(_OI __first, _Size __n, const _Tp& __value) {

  return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
}

template struct __equal { template<typename _II1, typename _II2> static bool equal(_II1 __first1, _II1 __last1, _II2 __first2) { for (; __first1 != __last1; ++__first1, ++__first2) if (!(*__first1 == *__first2)) return false; return true; } };

template<> struct __equal { template static bool equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) { if (const size_t __len = (__last1 - __first1)) return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) * __len); return true; } };

template<typename _II1, typename _II2> inline bool __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) { typedef typename iterator_traits<_II1>::value_type _ValueType1; typedef typename iterator_traits<_II2>::value_type _ValueType2; const bool __simple = ((__is_integer<_ValueType1>::__value || __is_pointer<_ValueType1>::__value) && __is_pointer<_II1>::__value && __is_pointer<_II2>::__value && __are_same<_ValueType1, _ValueType2>::__value);

  return std::__equal<__simple>::equal(__first1, __last1, __first2);
}

template<typename, typename> struct __lc_rai { template<typename _II1, typename _II2> static _II1 __newlast1(_II1, _II1 __last1, _II2, _II2) { return __last1; }

  template<typename _II>
    static bool
    __cnd2(_II __first, _II __last)
    { return __first != __last; }
};

template<> struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag> { template<typename _RAI1, typename _RAI2> static _RAI1 __newlast1(_RAI1 __first1, _RAI1 __last1, _RAI2 __first2, _RAI2 __last2) { const typename iterator_traits<_RAI1>::difference_type __diff1 = __last1 - __first1; const typename iterator_traits<_RAI2>::difference_type __diff2 = __last2 - __first2; return __diff2 < __diff1 ? __first1 + __diff2 : __last1; }

  template<typename _RAI>
    static bool
    __cnd2(_RAI, _RAI)
    { return true; }
};

template<typename _II1, typename _II2, typename _Compare> bool __lexicographical_compare_impl(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp) { typedef typename iterator_traits<_II1>::iterator_category _Category1; typedef typename iterator_traits<_II2>::iterator_category _Category2; typedef std::__lc_rai<_Category1, _Category2> __rai_type;

  __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
  for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
++__first1, ++__first2)

{ if (__comp(__first1, __first2)) return true; if (__comp(__first2, __first1)) return false; } return __first1 == __last1 && __first2 != __last2; }

template struct __lexicographical_compare { template<typename _II1, typename _II2> static bool __lc(_II1, _II1, _II2, _II2); };

template template<typename _II1, typename _II2> bool __lexicographical_compare<_BoolType>:: __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { return std::__lexicographical_compare_impl(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_less_iter()); }

template<> struct __lexicographical_compare { template<typename _Tp, typename _Up> static bool __lc(const _Tp* __first1, const _Tp* __last1, const _Up* __first2, const _Up* __last2) { const size_t __len1 = __last1 - __first1; const size_t __len2 = __last2 - __first2; if (const size_t __len = std::min(__len1, __len2)) if (int __result = __builtin_memcmp(__first1, __first2, __len)) return __result < 0; return __len1 < __len2; } };

template<typename _II1, typename _II2> inline bool __lexicographical_compare_aux(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) { typedef typename iterator_traits<_II1>::value_type _ValueType1; typedef typename iterator_traits<_II2>::value_type _ValueType2; const bool __simple = (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed && __is_pointer<_II1>::__value && __is_pointer<_II2>::__value);

  return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
       __first2, __last2);
}

template<typename _ForwardIterator, typename _Tp, typename _Compare> _ForwardIterator __lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val, _Compare __comp) { typedef typename iterator_traits<_ForwardIterator>::difference_type _DistanceType;

  _DistanceType __len = std::distance(__first, __last);

  while (__len > 0)

{ _DistanceType __half = __len >> 1; _ForwardIterator __middle = __first; std::advance(__middle, __half); if (__comp(__middle, __val)) { __first = __middle; ++__first; __len = __len - __half - 1; } else __len = __half; } return __first; }

998 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _ForwardIterator, typename _Tp> inline _ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __val) {

  ;

  return std::__lower_bound(__first, __last, __val,
__gnu_cxx::__ops::__iter_less_val());
}

inline int __lg(int __n) { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }

inline unsigned __lg(unsigned __n) { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }

inline long __lg(long __n) { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }

inline unsigned long __lg(unsigned long __n) { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }

inline long long __lg(long long __n) { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }

inline unsigned long long __lg(unsigned long long __n) { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }

1055 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _II1, typename _II2> inline bool equal(_II1 __first1, _II1 __last1, _II2 __first2) {

  ;

  return std::__equal_aux(std::__niter_base(__first1),
     std::__niter_base(__last1),
     std::__niter_base(__first2));
}

1087 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> inline bool equal(_IIter1 __first1, _IIter1 __last1, _IIter2 __first2, _BinaryPredicate __binary_pred) {

  ;

  for (; __first1 != __last1; ++__first1, ++__first2)

if (!bool(__binary_pred(*__first1, *__first2))) return false; return true; }

1215 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _II1, typename _II2> inline bool lexicographical_compare(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) {

  ;
  ;

  return std::__lexicographical_compare_aux(std::__niter_base(__first1),
  std::__niter_base(__last1),
  std::__niter_base(__first2),
  std::__niter_base(__last2));
}

1251 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _II1, typename _II2, typename _Compare> inline bool lexicographical_compare(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, _Compare __comp) {

  ;
  ;

  return std::__lexicographical_compare_impl

(__first1, __last1, __first2, __last2, __gnu_cxx::__ops::__iter_comp_iter(__comp)); }

template<typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate> pair<_InputIterator1, _InputIterator2> __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred) { while (__first1 != __last1 && __binary_pred(__first1, __first2)) { ++__first1; ++__first2; } return pair<_InputIterator1, _InputIterator2>(__first1, __first2); }

1294 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _InputIterator1, typename _InputIterator2> inline pair<_InputIterator1, _InputIterator2> mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) {

  ;

  return std::__mismatch(__first1, __last1, __first2,
    __gnu_cxx::__ops::__iter_equal_to_iter());
}

1327 “/usr/include/c++/5/bits/stl_algobase.h” 3

template<typename _InputIterator1, typename _InputIterator2, typename _BinaryPredicate> inline pair<_InputIterator1, _InputIterator2> mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __binary_pred) {

  ;

  return std::__mismatch(__first1, __last1, __first2,

__gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); }

1427 “/usr/include/c++/5/bits/stl_algobase.h” 3

}

40 “/usr/include/c++/5/bits/char_traits.h” 2 3

1 “/usr/include/c++/5/cwchar” 1 3

39 “/usr/include/c++/5/cwchar” 3

40 “/usr/include/c++/5/cwchar” 3

1 “/usr/include/wchar.h” 1 3 4

45 “/usr/include/c++/5/cwchar” 2 3

42 “/usr/include/c++/5/bits/char_traits.h” 2 3

namespace __gnu_cxx attribute ((visibility (“default”))) {

57 “/usr/include/c++/5/bits/char_traits.h” 3

template struct _Char_types { typedef unsigned long int_type; typedef std::streampos pos_type; typedef std::streamoff off_type; typedef std::mbstate_t state_type; };

82 “/usr/include/c++/5/bits/char_traits.h” 3

template struct char_traits { typedef _CharT char_type; typedef typename _Char_types<_CharT>::int_type int_type; typedef typename _Char_types<_CharT>::pos_type pos_type; typedef typename _Char_types<_CharT>::off_type off_type; typedef typename _Char_types<_CharT>::state_type state_type;

  static void
  assign(char_type& __c1, const char_type& __c2)
  { __c1 = __c2; }

  static bool
  eq(const char_type& __c1, const char_type& __c2)
  { return __c1 == __c2; }

  static bool
  lt(const char_type& __c1, const char_type& __c2)
  { return __c1 < __c2; }

  static int
  compare(const char_type* __s1, const char_type* __s2, std::size_t __n);

  static std::size_t
  length(const char_type* __s);

  static const char_type*
  find(const char_type* __s, std::size_t __n, const char_type& __a);

  static char_type*
  move(char_type* __s1, const char_type* __s2, std::size_t __n);

  static char_type*
  copy(char_type* __s1, const char_type* __s2, std::size_t __n);

  static char_type*
  assign(char_type* __s, std::size_t __n, char_type __a);

  static char_type
  to_char_type(const int_type& __c)
  { return static_cast<char_type>(__c); }

  static int_type
  to_int_type(const char_type& __c)
  { return static_cast<int_type>(__c); }

  static bool
  eq_int_type(const int_type& __c1, const int_type& __c2)
  { return __c1 == __c2; }

  static int_type
  eof()
  { return static_cast<int_type>(-1); }

  static int_type
  not_eof(const int_type& __c)
  { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
};

template int char_traits<_CharT>:: compare(const char_type* __s1, const char_type* __s2, std::size_t __n) { for (std::size_t __i = 0; __i < __n; ++__i) if (lt(__s1[__i], __s2[__i])) return -1; else if (lt(__s2[__i], __s1[__i])) return 1; return 0; }

template std::size_t char_traits<_CharT>:: length(const char_type* __p) { std::size_t __i = 0; while (!eq(__p[__i], char_type())) ++__i; return __i; }

template const typename char_traits<_CharT>::char_type* char_traits<_CharT>:: find(const char_type* __s, std::size_t __n, const char_type& __a) { for (std::size_t __i = 0; __i < __n; ++__i) if (eq(__s[__i], __a)) return __s + __i; return 0; }

template typename char_traits<_CharT>::char_type* char_traits<_CharT>:: move(char_type* __s1, const char_type* __s2, std::size_t __n) { return static_cast<_CharT*>(__builtin_memmove(__s1, __s2, __n * sizeof(char_type))); }

template typename char_traits<_CharT>::char_type* char_traits<_CharT>:: copy(char_type* __s1, const char_type* __s2, std::size_t __n) {

  std::copy(__s2, __s2 + __n, __s1);
  return __s1;
}

template typename char_traits<_CharT>::char_type* char_traits<_CharT>:: assign(char_type* __s, std::size_t __n, char_type __a) {

  std::fill_n(__s, __n, __a);
  return __s;
}

}

namespace std attribute ((visibility (“default”))) {

226 “/usr/include/c++/5/bits/char_traits.h” 3

template struct char_traits : public __gnu_cxx::char_traits<_CharT> { };

template<> struct char_traits { typedef char char_type; typedef int int_type; typedef streampos pos_type; typedef streamoff off_type; typedef mbstate_t state_type;

  static void
  assign(char_type& __c1, const char_type& __c2)
  { __c1 = __c2; }

  static bool
  eq(const char_type& __c1, const char_type& __c2)
  { return __c1 == __c2; }

  static bool
  lt(const char_type& __c1, const char_type& __c2)
  {

return (static_cast(__c1) < static_cast(__c2)); }

  static int
  compare(const char_type* __s1, const char_type* __s2, size_t __n)
  {

if (__n == 0) return 0; return __builtin_memcmp(__s1, __s2, __n); }

  static size_t
  length(const char_type* __s)
  { return __builtin_strlen(__s); }

  static const char_type*
  find(const char_type* __s, size_t __n, const char_type& __a)
  {

if (__n == 0) return 0; return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }

  static char_type*
  move(char_type* __s1, const char_type* __s2, size_t __n)
  {

if (__n == 0) return __s1; return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }

  static char_type*
  copy(char_type* __s1, const char_type* __s2, size_t __n)
  {

if (__n == 0) return __s1; return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }

  static char_type*
  assign(char_type* __s, size_t __n, char_type __a)
  {

if (__n == 0) return __s; return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }

  static char_type
  to_char_type(const int_type& __c)
  { return static_cast<char_type>(__c); }



  static int_type
  to_int_type(const char_type& __c)
  { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

  static bool
  eq_int_type(const int_type& __c1, const int_type& __c2)
  { return __c1 == __c2; }

  static int_type
  eof()
  { return static_cast<int_type>(-1); }

  static int_type
  not_eof(const int_type& __c)
  { return (__c == eof()) ? 0 : __c; }

};

template<> struct char_traits<wchar_t> { typedef wchar_t char_type; typedef wint_t int_type; typedef streamoff off_type; typedef wstreampos pos_type; typedef mbstate_t state_type;

  static void
  assign(char_type& __c1, const char_type& __c2)
  { __c1 = __c2; }

  static bool
  eq(const char_type& __c1, const char_type& __c2)
  { return __c1 == __c2; }

  static bool
  lt(const char_type& __c1, const char_type& __c2)
  { return __c1 < __c2; }

  static int
  compare(const char_type* __s1, const char_type* __s2, size_t __n)
  {

if (__n == 0) return 0; return wmemcmp(__s1, __s2, __n); }

  static size_t
  length(const char_type* __s)
  { return wcslen(__s); }

  static const char_type*
  find(const char_type* __s, size_t __n, const char_type& __a)
  {

if (__n == 0) return 0; return wmemchr(__s, __a, __n); }

  static char_type*
  move(char_type* __s1, const char_type* __s2, size_t __n)
  {

if (__n == 0) return __s1; return wmemmove(__s1, __s2, __n); }

  static char_type*
  copy(char_type* __s1, const char_type* __s2, size_t __n)
  {

if (__n == 0) return __s1; return wmemcpy(__s1, __s2, __n); }

  static char_type*
  assign(char_type* __s, size_t __n, char_type __a)
  {

if (__n == 0) return __s; return wmemset(__s, __a, __n); }

  static char_type
  to_char_type(const int_type& __c)
  { return char_type(__c); }

  static int_type
  to_int_type(const char_type& __c)
  { return int_type(__c); }

  static bool
  eq_int_type(const int_type& __c1, const int_type& __c2)
  { return __c1 == __c2; }

  static int_type
  eof()
  { return static_cast<int_type>((0xffffffffu)); }

  static int_type
  not_eof(const int_type& __c)
  { return eq_int_type(__c, eof()) ? 0 : __c; }

};

}

41 “/usr/include/c++/5/ios” 2 3

1 “/usr/include/c++/5/bits/localefwd.h” 1 3

37 “/usr/include/c++/5/bits/localefwd.h” 3

38 “/usr/include/c++/5/bits/localefwd.h” 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++locale.h” 1 3

39 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++locale.h” 3

40 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++locale.h” 3

1 “/usr/include/c++/5/clocale” 1 3

39 “/usr/include/c++/5/clocale” 3

40 “/usr/include/c++/5/clocale” 3

1 “/usr/include/locale.h” 1 3 4

28 “/usr/include/locale.h” 3 4

1 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h” 1 3 4

29 “/usr/include/locale.h” 2 3 4

1 “/usr/include/x86_64-linux-gnu/bits/locale.h” 1 3 4

30 “/usr/include/locale.h” 2 3 4

extern “C” {

50 “/usr/include/locale.h” 3 4

struct lconv {

char *decimal_point; char *thousands_sep;

char *grouping;

char *int_curr_symbol; char *currency_symbol; char *mon_decimal_point; char *mon_thousands_sep; char *mon_grouping; char *positive_sign; char *negative_sign; char int_frac_digits; char frac_digits;

char p_cs_precedes;

char p_sep_by_space;

char n_cs_precedes;

char n_sep_by_space;

char p_sign_posn; char n_sign_posn;

char int_p_cs_precedes;

char int_p_sep_by_space;

char int_n_cs_precedes;

char int_n_sep_by_space;

char int_p_sign_posn; char int_n_sign_posn;

120 “/usr/include/locale.h” 3 4

};

extern char *setlocale (int __category, const char *__locale) throw ();

extern struct lconv *localeconv (void) throw ();

151 “/usr/include/locale.h” 3 4

extern __locale_t newlocale (int __category_mask, const char *__locale, __locale_t __base) throw ();

186 “/usr/include/locale.h” 3 4

extern __locale_t duplocale (__locale_t __dataset) throw ();

extern void freelocale (__locale_t __dataset) throw ();

extern __locale_t uselocale (__locale_t __dataset) throw ();

}

43 “/usr/include/c++/5/clocale” 2 3

51 “/usr/include/c++/5/clocale” 3

namespace std { using ::lconv; using ::setlocale; using ::localeconv; }

42 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++locale.h” 2 3

namespace __gnu_cxx attribute ((visibility (“default”))) {

extern “C” __typeof(uselocale) __uselocale;

}

namespace std attribute ((visibility (“default”))) {

typedef __locale_t __c_locale;

inline int __convert_from_v(const __c_locale& __cloc attribute ((unused)), char* __out, const int __size attribute ((unused)), const char* __fmt, …) {

__c_locale __old = __gnu_cxx::__uselocale(__cloc);

88 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++locale.h” 3

__builtin_va_list __args;
__builtin_va_start(__args, __fmt);


const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);




__builtin_va_end(__args);


__gnu_cxx::__uselocale(__old);







return __ret;

}

41 “/usr/include/c++/5/bits/localefwd.h” 2 3

1 “/usr/include/c++/5/cctype” 1 3

39 “/usr/include/c++/5/cctype” 3

40 “/usr/include/c++/5/cctype” 3

1 “/usr/include/ctype.h” 1 3 4

26 “/usr/include/ctype.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/types.h” 1 3 4

27 “/usr/include/x86_64-linux-gnu/bits/types.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/wordsize.h” 1 3 4

28 “/usr/include/x86_64-linux-gnu/bits/types.h” 2 3 4

typedef unsigned char __u_char; typedef unsigned short int __u_short; typedef unsigned int __u_int; typedef unsigned long int __u_long;

typedef signed char __int8_t; typedef unsigned char __uint8_t; typedef signed short int __int16_t; typedef unsigned short int __uint16_t; typedef signed int __int32_t; typedef unsigned int __uint32_t;

typedef signed long int __int64_t; typedef unsigned long int __uint64_t;

typedef long int __quad_t; typedef unsigned long int __u_quad_t;

121 “/usr/include/x86_64-linux-gnu/bits/types.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/typesizes.h” 1 3 4

122 “/usr/include/x86_64-linux-gnu/bits/types.h” 2 3 4

typedef unsigned long int __dev_t; typedef unsigned int __uid_t; typedef unsigned int __gid_t; typedef unsigned long int __ino_t; typedef unsigned long int __ino64_t; typedef unsigned int __mode_t; typedef unsigned long int __nlink_t; typedef long int __off_t; typedef long int __off64_t; typedef int __pid_t; typedef struct { int __val[2]; } __fsid_t; typedef long int __clock_t; typedef unsigned long int __rlim_t; typedef unsigned long int __rlim64_t; typedef unsigned int __id_t; typedef long int __time_t; typedef unsigned int __useconds_t; typedef long int __suseconds_t;

typedef int __daddr_t; typedef int __key_t;

typedef int __clockid_t;

typedef void * __timer_t;

typedef long int __blksize_t;

typedef long int __blkcnt_t; typedef long int __blkcnt64_t;

typedef unsigned long int __fsblkcnt_t; typedef unsigned long int __fsblkcnt64_t;

typedef unsigned long int __fsfilcnt_t; typedef unsigned long int __fsfilcnt64_t;

typedef long int __fsword_t;

typedef long int __ssize_t;

typedef long int __syscall_slong_t;

typedef unsigned long int __syscall_ulong_t;

typedef __off64_t __loff_t; typedef __quad_t *__qaddr_t; typedef char *__caddr_t;

typedef long int __intptr_t;

typedef unsigned int __socklen_t;

27 “/usr/include/ctype.h” 2 3 4

extern “C” {

39 “/usr/include/ctype.h” 3 4

1 “/usr/include/endian.h” 1 3 4

36 “/usr/include/endian.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/endian.h” 1 3 4

37 “/usr/include/endian.h” 2 3 4

60 “/usr/include/endian.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/byteswap.h” 1 3 4

28 “/usr/include/x86_64-linux-gnu/bits/byteswap.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/wordsize.h” 1 3 4

29 “/usr/include/x86_64-linux-gnu/bits/byteswap.h” 2 3 4

1 “/usr/include/x86_64-linux-gnu/bits/byteswap-16.h” 1 3 4

36 “/usr/include/x86_64-linux-gnu/bits/byteswap.h” 2 3 4

44 “/usr/include/x86_64-linux-gnu/bits/byteswap.h” 3 4

static __inline unsigned int __bswap_32 (unsigned int __bsx) { return __builtin_bswap32 (__bsx); }

108 “/usr/include/x86_64-linux-gnu/bits/byteswap.h” 3 4

static __inline __uint64_t __bswap_64 (__uint64_t __bsx) { return __builtin_bswap64 (__bsx); }

61 “/usr/include/endian.h” 2 3 4

40 “/usr/include/ctype.h” 2 3 4

enum { _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) };

79 “/usr/include/ctype.h” 3 4

extern const unsigned short int **__ctype_b_loc (void) throw () attribute ((const)); extern const __int32_t **__ctype_tolower_loc (void) throw () attribute ((const)); extern const __int32_t **__ctype_toupper_loc (void) throw () attribute ((const));

104 “/usr/include/ctype.h” 3 4

extern int isalnum (int) throw (); extern int isalpha (int) throw (); extern int iscntrl (int) throw (); extern int isdigit (int) throw (); extern int islower (int) throw (); extern int isgraph (int) throw (); extern int isprint (int) throw (); extern int ispunct (int) throw (); extern int isspace (int) throw (); extern int isupper (int) throw (); extern int isxdigit (int) throw ();

extern int tolower (int __c) throw ();

extern int toupper (int __c) throw ();

extern int isblank (int) throw ();

extern int isctype (int __c, int __mask) throw ();

extern int isascii (int __c) throw ();

extern int toascii (int __c) throw ();

extern int _toupper (int) throw (); extern int _tolower (int) throw ();

271 “/usr/include/ctype.h” 3 4

extern int isalnum_l (int, __locale_t) throw (); extern int isalpha_l (int, __locale_t) throw (); extern int iscntrl_l (int, __locale_t) throw (); extern int isdigit_l (int, __locale_t) throw (); extern int islower_l (int, __locale_t) throw (); extern int isgraph_l (int, __locale_t) throw (); extern int isprint_l (int, __locale_t) throw (); extern int ispunct_l (int, __locale_t) throw (); extern int isspace_l (int, __locale_t) throw (); extern int isupper_l (int, __locale_t) throw (); extern int isxdigit_l (int, __locale_t) throw ();

extern int isblank_l (int, __locale_t) throw ();

extern int __tolower_l (int __c, __locale_t __l) throw (); extern int tolower_l (int __c, __locale_t __l) throw ();

extern int __toupper_l (int __c, __locale_t __l) throw (); extern int toupper_l (int __c, __locale_t __l) throw ();

347 “/usr/include/ctype.h” 3 4

}

43 “/usr/include/c++/5/cctype” 2 3

62 “/usr/include/c++/5/cctype” 3

namespace std { using ::isalnum; using ::isalpha; using ::iscntrl; using ::isdigit; using ::isgraph; using ::islower; using ::isprint; using ::ispunct; using ::isspace; using ::isupper; using ::isxdigit; using ::tolower; using ::toupper; }

43 “/usr/include/c++/5/bits/localefwd.h” 2 3

namespace std attribute ((visibility (“default”))) {

55 “/usr/include/c++/5/bits/localefwd.h” 3

class locale;

template bool has_facet(const locale&) throw();

template const _Facet& use_facet(const locale&);

template bool isspace(_CharT, const locale&);

template bool isprint(_CharT, const locale&);

template bool iscntrl(_CharT, const locale&);

template bool isupper(_CharT, const locale&);

template bool islower(_CharT, const locale&);

template bool isalpha(_CharT, const locale&);

template bool isdigit(_CharT, const locale&);

template bool ispunct(_CharT, const locale&);

template bool isxdigit(_CharT, const locale&);

template bool isalnum(_CharT, const locale&);

template bool isgraph(_CharT, const locale&);

template _CharT toupper(_CharT, const locale&);

template _CharT tolower(_CharT, const locale&);

class ctype_base; template class ctype; template<> class ctype;

template<> class ctype<wchar_t>;

template class ctype_byname;

class codecvt_base; template<typename _InternT, typename _ExternT, typename _StateT> class codecvt; template<> class codecvt<char, char, mbstate_t>;

template<> class codecvt<wchar_t, char, mbstate_t>;

template<typename _InternT, typename _ExternT, typename _StateT> class codecvt_byname;

template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > class num_get; template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > class num_put;

namespace __cxx11 { template class numpunct; template class numpunct_byname; }

namespace __cxx11 {

template class collate; template class collate_byname; }

class time_base; namespace __cxx11 { template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > class time_get; template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > class time_get_byname; } template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > class time_put; template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > class time_put_byname;

class money_base; namespace __cxx11 { template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > class money_get; template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > class money_put; } namespace __cxx11 { template<typename _CharT, bool _Intl = false> class moneypunct; template<typename _CharT, bool _Intl = false> class moneypunct_byname; }

class messages_base; namespace __cxx11 { template class messages; template class messages_byname; }

}

42 “/usr/include/c++/5/ios” 2 3

1 “/usr/include/c++/5/bits/ios_base.h” 1 3

37 “/usr/include/c++/5/bits/ios_base.h” 3

38 “/usr/include/c++/5/bits/ios_base.h” 3

1 “/usr/include/c++/5/ext/atomicity.h” 1 3

32 “/usr/include/c++/5/ext/atomicity.h” 3

33 “/usr/include/c++/5/ext/atomicity.h” 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr.h” 1 3

30 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr.h” 3

pragma GCC visibility push(default)

148 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr.h” 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 1 3

35 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 3

1 “/usr/include/pthread.h” 1 3 4

23 “/usr/include/pthread.h” 3 4

1 “/usr/include/sched.h” 1 3 4

28 “/usr/include/sched.h” 3 4

1 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h” 1 3 4

29 “/usr/include/sched.h” 2 3 4

1 “/usr/include/time.h” 1 3 4

73 “/usr/include/time.h” 3 4

typedef __time_t time_t;

120 “/usr/include/time.h” 3 4

struct timespec { __time_t tv_sec; __syscall_slong_t tv_nsec; };

35 “/usr/include/sched.h” 2 3 4

typedef __pid_t pid_t;

1 “/usr/include/x86_64-linux-gnu/bits/sched.h” 1 3 4

72 “/usr/include/x86_64-linux-gnu/bits/sched.h” 3 4

struct sched_param { int __sched_priority; };

extern “C” {

extern int clone (int (*__fn) (void *__arg), void *__child_stack, int __flags, void *__arg, …) throw ();

extern int unshare (int __flags) throw ();

extern int sched_getcpu (void) throw ();

extern int setns (int __fd, int __nstype) throw ();

}

struct __sched_param { int __sched_priority; };

118 “/usr/include/x86_64-linux-gnu/bits/sched.h” 3 4

typedef unsigned long int __cpu_mask;

typedef struct { __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; } cpu_set_t;

201 “/usr/include/x86_64-linux-gnu/bits/sched.h” 3 4

extern “C” {

extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) throw (); extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ; extern void __sched_cpufree (cpu_set_t *__set) throw ();

}

44 “/usr/include/sched.h” 2 3 4

extern “C” {

extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) throw ();

extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();

extern int sched_setscheduler (__pid_t __pid, int __policy, const struct sched_param *__param) throw ();

extern int sched_getscheduler (__pid_t __pid) throw ();

extern int sched_yield (void) throw ();

extern int sched_get_priority_max (int __algorithm) throw ();

extern int sched_get_priority_min (int __algorithm) throw ();

extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();

118 “/usr/include/sched.h” 3 4

extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, const cpu_set_t *__cpuset) throw ();

extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, cpu_set_t *__cpuset) throw ();

}

24 “/usr/include/pthread.h” 2 3 4

1 “/usr/include/time.h” 1 3 4

29 “/usr/include/time.h” 3 4

extern “C” {

1 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h” 1 3 4

38 “/usr/include/time.h” 2 3 4

1 “/usr/include/x86_64-linux-gnu/bits/time.h” 1 3 4

30 “/usr/include/x86_64-linux-gnu/bits/time.h” 3 4

struct timeval { __time_t tv_sec; __suseconds_t tv_usec; };

88 “/usr/include/x86_64-linux-gnu/bits/time.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/timex.h” 1 3 4

25 “/usr/include/x86_64-linux-gnu/bits/timex.h” 3 4

struct timex { unsigned int modes; __syscall_slong_t offset; __syscall_slong_t freq; __syscall_slong_t maxerror; __syscall_slong_t esterror; int status; __syscall_slong_t constant; __syscall_slong_t precision; __syscall_slong_t tolerance; struct timeval time; __syscall_slong_t tick; __syscall_slong_t ppsfreq; __syscall_slong_t jitter; int shift; __syscall_slong_t stabil; __syscall_slong_t jitcnt; __syscall_slong_t calcnt; __syscall_slong_t errcnt; __syscall_slong_t stbcnt;

int tai;

int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; int :32; };

89 “/usr/include/x86_64-linux-gnu/bits/time.h” 2 3 4

extern “C” {

extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();

}

42 “/usr/include/time.h” 2 3 4

57 “/usr/include/time.h” 3 4

typedef __clock_t clock_t;

91 “/usr/include/time.h” 3 4

typedef __clockid_t clockid_t;

103 “/usr/include/time.h” 3 4

typedef __timer_t timer_t;

131 “/usr/include/time.h” 3 4

struct tm { int tm_sec; int tm_min; int tm_hour; int tm_mday; int tm_mon; int tm_year; int tm_wday; int tm_yday; int tm_isdst;

long int tm_gmtoff; const char *tm_zone;

};

struct itimerspec { struct timespec it_interval; struct timespec it_value; };

struct sigevent;

186 “/usr/include/time.h” 3 4

extern clock_t clock (void) throw ();

extern time_t time (time_t *__timer) throw ();

extern double difftime (time_t __time1, time_t __time0) throw () attribute ((const));

extern time_t mktime (struct tm *__tp) throw ();

extern size_t strftime (char *__restrict __s, size_t __maxsize, const char *__restrict __format, const struct tm *__restrict __tp) throw ();

extern char *strptime (const char *__restrict __s, const char *__restrict __fmt, struct tm *__tp) throw ();

extern size_t strftime_l (char *__restrict __s, size_t __maxsize, const char *__restrict __format, const struct tm *__restrict __tp, __locale_t __loc) throw ();

extern char *strptime_l (const char *__restrict __s, const char *__restrict __fmt, struct tm *__tp, __locale_t __loc) throw ();

extern struct tm *gmtime (const time_t *__timer) throw ();

extern struct tm *localtime (const time_t *__timer) throw ();

extern struct tm *gmtime_r (const time_t *__restrict __timer, struct tm *__restrict __tp) throw ();

extern struct tm *localtime_r (const time_t *__restrict __timer, struct tm *__restrict __tp) throw ();

extern char *asctime (const struct tm *__tp) throw ();

extern char *ctime (const time_t *__timer) throw ();

extern char *asctime_r (const struct tm *__restrict __tp, char *__restrict __buf) throw ();

extern char *ctime_r (const time_t *__restrict __timer, char *__restrict __buf) throw ();

extern char *__tzname[2]; extern int __daylight; extern long int __timezone;

extern char *tzname[2];

extern void tzset (void) throw ();

extern int daylight; extern long int timezone;

extern int stime (const time_t *__when) throw ();

319 “/usr/include/time.h” 3 4

extern time_t timegm (struct tm *__tp) throw ();

extern time_t timelocal (struct tm *__tp) throw ();

extern int dysize (int __year) throw () attribute ((const));

334 “/usr/include/time.h” 3 4

extern int nanosleep (const struct timespec *__requested_time, struct timespec *__remaining);

extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();

extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();

extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) throw ();

extern int clock_nanosleep (clockid_t __clock_id, int __flags, const struct timespec *__req, struct timespec *__rem);

extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();

extern int timer_create (clockid_t __clock_id, struct sigevent *__restrict __evp, timer_t *__restrict __timerid) throw ();

extern int timer_delete (timer_t __timerid) throw ();

extern int timer_settime (timer_t __timerid, int __flags, const struct itimerspec *__restrict __value, struct itimerspec *__restrict __ovalue) throw ();

extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) throw ();

extern int timer_getoverrun (timer_t __timerid) throw ();

extern int timespec_get (struct timespec *__ts, int __base) throw () attribute ((nonnull (1)));

403 “/usr/include/time.h” 3 4

extern int getdate_err;

412 “/usr/include/time.h” 3 4

extern struct tm *getdate (const char *__string);

426 “/usr/include/time.h” 3 4

extern int getdate_r (const char *__restrict __string, struct tm *__restrict __resbufp);

}

25 “/usr/include/pthread.h” 2 3 4

1 “/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h” 1 3 4

21 “/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/wordsize.h” 1 3 4

22 “/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h” 2 3 4

60 “/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h” 3 4

typedef unsigned long int pthread_t;

union pthread_attr_t { char __size[56]; long int __align; };

typedef union pthread_attr_t pthread_attr_t;

typedef struct __pthread_internal_list { struct __pthread_internal_list *__prev; struct __pthread_internal_list *__next; } __pthread_list_t;

90 “/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h” 3 4

typedef union { struct __pthread_mutex_s { int __lock; unsigned int __count; int __owner;

unsigned int __nusers;



int __kind;

short __spins;
short __elision;
__pthread_list_t __list;

125 “/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h” 3 4

} __data; char __size[40]; long int __align; } pthread_mutex_t;

typedef union { char __size[4]; int __align; } pthread_mutexattr_t;

typedef union { struct { int __lock; unsigned int __futex; extension unsigned long long int __total_seq; extension unsigned long long int __wakeup_seq; extension unsigned long long int __woken_seq; void *__mutex; unsigned int __nwaiters; unsigned int __broadcast_seq; } __data; char __size[48]; extension long long int __align; } pthread_cond_t;

typedef union { char __size[4]; int __align; } pthread_condattr_t;

typedef unsigned int pthread_key_t;

typedef int pthread_once_t;

typedef union {

struct { int __lock; unsigned int __nr_readers; unsigned int __readers_wakeup; unsigned int __writer_wakeup; unsigned int __nr_readers_queued; unsigned int __nr_writers_queued; int __writer; int __shared; signed char __rwelision;

unsigned char __pad1[7];


unsigned long int __pad2;


unsigned int __flags;

} __data;

220 “/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h” 3 4

char __size[56]; long int __align; } pthread_rwlock_t;

typedef union { char __size[8]; long int __align; } pthread_rwlockattr_t;

typedef volatile int pthread_spinlock_t;

typedef union { char __size[32]; long int __align; } pthread_barrier_t;

typedef union { char __size[4]; int __align; } pthread_barrierattr_t;

27 “/usr/include/pthread.h” 2 3 4

1 “/usr/include/x86_64-linux-gnu/bits/setjmp.h” 1 3 4

26 “/usr/include/x86_64-linux-gnu/bits/setjmp.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/wordsize.h” 1 3 4

27 “/usr/include/x86_64-linux-gnu/bits/setjmp.h” 2 3 4

typedef long int __jmp_buf[8];

28 “/usr/include/pthread.h” 2 3 4

1 “/usr/include/x86_64-linux-gnu/bits/wordsize.h” 1 3 4

29 “/usr/include/pthread.h” 2 3 4

enum { PTHREAD_CREATE_JOINABLE,

PTHREAD_CREATE_DETACHED

};

enum { PTHREAD_MUTEX_TIMED_NP, PTHREAD_MUTEX_RECURSIVE_NP, PTHREAD_MUTEX_ERRORCHECK_NP, PTHREAD_MUTEX_ADAPTIVE_NP

, PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL

, PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP

};

enum { PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, PTHREAD_MUTEX_ROBUST, PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST };

enum { PTHREAD_PRIO_NONE, PTHREAD_PRIO_INHERIT, PTHREAD_PRIO_PROTECT };

114 “/usr/include/pthread.h” 3 4

enum { PTHREAD_RWLOCK_PREFER_READER_NP, PTHREAD_RWLOCK_PREFER_WRITER_NP, PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP };

155 “/usr/include/pthread.h” 3 4

enum { PTHREAD_INHERIT_SCHED,

PTHREAD_EXPLICIT_SCHED

};

enum { PTHREAD_SCOPE_SYSTEM,

PTHREAD_SCOPE_PROCESS

};

enum { PTHREAD_PROCESS_PRIVATE,

PTHREAD_PROCESS_SHARED

};

190 “/usr/include/pthread.h” 3 4

struct _pthread_cleanup_buffer { void (*__routine) (void *); void *__arg; int __canceltype; struct _pthread_cleanup_buffer *__prev; };

enum { PTHREAD_CANCEL_ENABLE,

PTHREAD_CANCEL_DISABLE

}; enum { PTHREAD_CANCEL_DEFERRED,

PTHREAD_CANCEL_ASYNCHRONOUS

};

228 “/usr/include/pthread.h” 3 4

extern “C” {

extern int pthread_create (pthread_t *__restrict __newthread, const pthread_attr_t *__restrict __attr, void (__start_routine) (void *), void *__restrict __arg) throw () attribute ((nonnull (1, 3)));

extern void pthread_exit (void *__retval) attribute ((noreturn));

extern int pthread_join (pthread_t __th, void **__thread_return);

extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();

extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, const struct timespec *__abstime);

extern int pthread_detach (pthread_t __th) throw ();

extern pthread_t pthread_self (void) throw () attribute ((const));

extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw () attribute ((const));

extern int pthread_attr_init (pthread_attr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_attr_destroy (pthread_attr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, int *__detachstate) throw () attribute ((nonnull (1, 2)));

extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, int __detachstate) throw () attribute ((nonnull (1)));

extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, size_t *__guardsize) throw () attribute ((nonnull (1, 2)));

extern int pthread_attr_setguardsize (pthread_attr_t *__attr, size_t __guardsize) throw () attribute ((nonnull (1)));

extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, struct sched_param *__restrict __param) throw () attribute ((nonnull (1, 2)));

extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, const struct sched_param *__restrict __param) throw () attribute ((nonnull (1, 2)));

extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict __attr, int *__restrict __policy) throw () attribute ((nonnull (1, 2)));

extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) throw () attribute ((nonnull (1)));

extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict __attr, int *__restrict __inherit) throw () attribute ((nonnull (1, 2)));

extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, int __inherit) throw () attribute ((nonnull (1)));

extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, int *__restrict __scope) throw () attribute ((nonnull (1, 2)));

extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) throw () attribute ((nonnull (1)));

extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict __attr, void **__restrict __stackaddr) throw () attribute ((nonnull (1, 2))) attribute ((deprecated));

extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, void *__stackaddr) throw () attribute ((nonnull (1))) attribute ((deprecated));

extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict __attr, size_t *__restrict __stacksize) throw () attribute ((nonnull (1, 2)));

extern int pthread_attr_setstacksize (pthread_attr_t *__attr, size_t __stacksize) throw () attribute ((nonnull (1)));

extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, void **__restrict __stackaddr, size_t *__restrict __stacksize) throw () attribute ((nonnull (1, 2, 3)));

extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, size_t __stacksize) throw () attribute ((nonnull (1)));

extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, size_t __cpusetsize, const cpu_set_t *__cpuset) throw () attribute ((nonnull (1, 3)));

extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, size_t __cpusetsize, cpu_set_t *__cpuset) throw () attribute ((nonnull (1, 3)));

extern int pthread_getattr_default_np (pthread_attr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_setattr_default_np (const pthread_attr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) throw () attribute ((nonnull (2)));

extern int pthread_setschedparam (pthread_t __target_thread, int __policy, const struct sched_param *__param) throw () attribute ((nonnull (3)));

extern int pthread_getschedparam (pthread_t __target_thread, int *__restrict __policy, struct sched_param *__restrict __param) throw () attribute ((nonnull (2, 3)));

extern int pthread_setschedprio (pthread_t __target_thread, int __prio) throw ();

extern int pthread_getname_np (pthread_t __target_thread, char *__buf, size_t __buflen) throw () attribute ((nonnull (2)));

extern int pthread_setname_np (pthread_t __target_thread, const char *__name) throw () attribute ((nonnull (2)));

extern int pthread_getconcurrency (void) throw ();

extern int pthread_setconcurrency (int __level) throw ();

extern int pthread_yield (void) throw ();

extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, const cpu_set_t *__cpuset) throw () attribute ((nonnull (3)));

extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, cpu_set_t *__cpuset) throw () attribute ((nonnull (3)));

494 “/usr/include/pthread.h” 3 4

extern int pthread_once (pthread_once_t __once_control, void (__init_routine) (void)) attribute ((nonnull (1, 2)));

506 “/usr/include/pthread.h” 3 4

extern int pthread_setcancelstate (int __state, int *__oldstate);

extern int pthread_setcanceltype (int __type, int *__oldtype);

extern int pthread_cancel (pthread_t __th);

extern void pthread_testcancel (void);

typedef struct { struct { __jmp_buf __cancel_jmp_buf; int __mask_was_saved; } __cancel_jmp_buf[1]; void *__pad[4]; } __pthread_unwind_buf_t attribute ((aligned));

540 “/usr/include/pthread.h” 3 4

struct __pthread_cleanup_frame { void (*__cancel_routine) (void *); void *__cancel_arg; int __do_it; int __cancel_type; };

class __pthread_cleanup_class { void (*__cancel_routine) (void *); void *__cancel_arg; int __do_it; int __cancel_type;

public: __pthread_cleanup_class (void (*__fct) (void *), void *__arg) : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } void __setdoit (int __newval) { __do_it = __newval; } void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, &__cancel_type); } void __restore () const { pthread_setcanceltype (__cancel_type, 0); } };

742 “/usr/include/pthread.h” 3 4

struct __jmp_buf_tag; extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();

extern int pthread_mutex_init (pthread_mutex_t *__mutex, const pthread_mutexattr_t *__mutexattr) throw () attribute ((nonnull (1)));

extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) throw () attribute ((nonnull (1)));

extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) throw () attribute ((nonnull (1)));

extern int pthread_mutex_lock (pthread_mutex_t *__mutex) throw () attribute ((nonnull (1)));

extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, const struct timespec *__restrict __abstime) throw () attribute ((nonnull (1, 2)));

extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) throw () attribute ((nonnull (1)));

extern int pthread_mutex_getprioceiling (const pthread_mutex_t * __restrict __mutex, int *__restrict __prioceiling) throw () attribute ((nonnull (1, 2)));

extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, int __prioceiling, int *__restrict __old_ceiling) throw () attribute ((nonnull (1, 3)));

extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) throw () attribute ((nonnull (1)));

extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex) throw () attribute ((nonnull (1)));

806 “/usr/include/pthread.h” 3 4

extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * __restrict __attr, int *__restrict __pshared) throw () attribute ((nonnull (1, 2)));

extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, int __pshared) throw () attribute ((nonnull (1)));

extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict __attr, int *__restrict __kind) throw () attribute ((nonnull (1, 2)));

extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) throw () attribute ((nonnull (1)));

extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * __restrict __attr, int *__restrict __protocol) throw () attribute ((nonnull (1, 2)));

extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, int __protocol) throw () attribute ((nonnull (1)));

extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * __restrict __attr, int *__restrict __prioceiling) throw () attribute ((nonnull (1, 2)));

extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, int __prioceiling) throw () attribute ((nonnull (1)));

extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, int *__robustness) throw () attribute ((nonnull (1, 2)));

extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr, int *__robustness) throw () attribute ((nonnull (1, 2)));

extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, int __robustness) throw () attribute ((nonnull (1)));

extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr, int __robustness) throw () attribute ((nonnull (1)));

888 “/usr/include/pthread.h” 3 4

extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, const pthread_rwlockattr_t *__restrict __attr) throw () attribute ((nonnull (1)));

extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) throw () attribute ((nonnull (1)));

extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) throw () attribute ((nonnull (1)));

extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) throw () attribute ((nonnull (1)));

extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, const struct timespec *__restrict __abstime) throw () attribute ((nonnull (1, 2)));

extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) throw () attribute ((nonnull (1)));

extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) throw () attribute ((nonnull (1)));

extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, const struct timespec *__restrict __abstime) throw () attribute ((nonnull (1, 2)));

extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) throw () attribute ((nonnull (1)));

extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * __restrict __attr, int *__restrict __pshared) throw () attribute ((nonnull (1, 2)));

extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, int __pshared) throw () attribute ((nonnull (1)));

extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * __restrict __attr, int *__restrict __pref) throw () attribute ((nonnull (1, 2)));

extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, int __pref) throw () attribute ((nonnull (1)));

extern int pthread_cond_init (pthread_cond_t *__restrict __cond, const pthread_condattr_t *__restrict __cond_attr) throw () attribute ((nonnull (1)));

extern int pthread_cond_destroy (pthread_cond_t *__cond) throw () attribute ((nonnull (1)));

extern int pthread_cond_signal (pthread_cond_t *__cond) throw () attribute ((nonnull (1)));

extern int pthread_cond_broadcast (pthread_cond_t *__cond) throw () attribute ((nonnull (1)));

extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, pthread_mutex_t *__restrict __mutex) attribute ((nonnull (1, 2)));

1000 “/usr/include/pthread.h” 3 4

extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, pthread_mutex_t *__restrict __mutex, const struct timespec *__restrict __abstime) attribute ((nonnull (1, 2, 3)));

extern int pthread_condattr_init (pthread_condattr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_condattr_destroy (pthread_condattr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_condattr_getpshared (const pthread_condattr_t * __restrict __attr, int *__restrict __pshared) throw () attribute ((nonnull (1, 2)));

extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, int __pshared) throw () attribute ((nonnull (1)));

extern int pthread_condattr_getclock (const pthread_condattr_t * __restrict __attr, __clockid_t *__restrict __clock_id) throw () attribute ((nonnull (1, 2)));

extern int pthread_condattr_setclock (pthread_condattr_t *__attr, __clockid_t __clock_id) throw () attribute ((nonnull (1)));

1044 “/usr/include/pthread.h” 3 4

extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) throw () attribute ((nonnull (1)));

extern int pthread_spin_destroy (pthread_spinlock_t *__lock) throw () attribute ((nonnull (1)));

extern int pthread_spin_lock (pthread_spinlock_t *__lock) throw () attribute ((nonnull (1)));

extern int pthread_spin_trylock (pthread_spinlock_t *__lock) throw () attribute ((nonnull (1)));

extern int pthread_spin_unlock (pthread_spinlock_t *__lock) throw () attribute ((nonnull (1)));

extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, const pthread_barrierattr_t *__restrict __attr, unsigned int __count) throw () attribute ((nonnull (1)));

extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) throw () attribute ((nonnull (1)));

extern int pthread_barrier_wait (pthread_barrier_t *__barrier) throw () attribute ((nonnull (1)));

extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) throw () attribute ((nonnull (1)));

extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * __restrict __attr, int *__restrict __pshared) throw () attribute ((nonnull (1, 2)));

extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, int __pshared) throw () attribute ((nonnull (1)));

1111 “/usr/include/pthread.h” 3 4

extern int pthread_key_create (pthread_key_t __key, void (__destr_function) (void *)) throw () attribute ((nonnull (1)));

extern int pthread_key_delete (pthread_key_t __key) throw ();

extern void *pthread_getspecific (pthread_key_t __key) throw ();

extern int pthread_setspecific (pthread_key_t __key, const void *__pointer) throw () ;

extern int pthread_getcpuclockid (pthread_t __thread_id, __clockid_t *__clock_id) throw () attribute ((nonnull (2)));

1145 “/usr/include/pthread.h” 3 4

extern int pthread_atfork (void (__prepare) (void), void (__parent) (void), void (*__child) (void)) throw ();

1159 “/usr/include/pthread.h” 3 4

}

36 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 2 3

47 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 3

typedef pthread_t __gthread_t; typedef pthread_key_t __gthread_key_t; typedef pthread_once_t __gthread_once_t; typedef pthread_mutex_t __gthread_mutex_t; typedef pthread_mutex_t __gthread_recursive_mutex_t; typedef pthread_cond_t __gthread_cond_t; typedef struct timespec __gthread_time_t;

101 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 3

static __typeof(pthread_once) __gthrw_pthread_once attribute ((weakref(“pthread_once”))); static __typeof(pthread_getspecific) __gthrw_pthread_getspecific attribute ((weakref(“pthread_getspecific”))); static __typeof(pthread_setspecific) __gthrw_pthread_setspecific attribute ((weakref(“pthread_setspecific”)));

static __typeof(pthread_create) __gthrw_pthread_create attribute ((weakref(“pthread_create”))); static __typeof(pthread_join) __gthrw_pthread_join attribute ((weakref(“pthread_join”))); static __typeof(pthread_equal) __gthrw_pthread_equal attribute ((weakref(“pthread_equal”))); static __typeof(pthread_self) __gthrw_pthread_self attribute ((weakref(“pthread_self”))); static __typeof(pthread_detach) __gthrw_pthread_detach attribute ((weakref(“pthread_detach”)));

static __typeof(pthread_cancel) __gthrw_pthread_cancel attribute ((weakref(“pthread_cancel”)));

static __typeof(sched_yield) __gthrw_sched_yield attribute ((weakref(“sched_yield”)));

static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock attribute ((weakref(“pthread_mutex_lock”))); static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock attribute ((weakref(“pthread_mutex_trylock”)));

static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock attribute ((weakref(“pthread_mutex_timedlock”)));

static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock attribute ((weakref(“pthread_mutex_unlock”))); static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init attribute ((weakref(“pthread_mutex_init”))); static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy attribute ((weakref(“pthread_mutex_destroy”)));

static __typeof(pthread_cond_init) __gthrw_pthread_cond_init attribute ((weakref(“pthread_cond_init”))); static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast attribute ((weakref(“pthread_cond_broadcast”))); static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal attribute ((weakref(“pthread_cond_signal”))); static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait attribute ((weakref(“pthread_cond_wait”))); static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait attribute ((weakref(“pthread_cond_timedwait”))); static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy attribute ((weakref(“pthread_cond_destroy”)));

static __typeof(pthread_key_create) __gthrw_pthread_key_create attribute ((weakref(“pthread_key_create”))); static __typeof(pthread_key_delete) __gthrw_pthread_key_delete attribute ((weakref(“pthread_key_delete”))); static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init attribute ((weakref(“pthread_mutexattr_init”))); static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype attribute ((weakref(“pthread_mutexattr_settype”))); static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy attribute ((weakref(“pthread_mutexattr_destroy”)));

236 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 3

static __typeof(pthread_key_create) __gthrw___pthread_key_create attribute ((weakref(“__pthread_key_create”)));

246 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 3

static inline int __gthread_active_p (void) { static void *const __gthread_active_ptr = extension (void *) &__gthrw___pthread_key_create; return __gthread_active_ptr != 0; }

658 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 3

static inline int __gthread_create (__gthread_t __threadid, void (__func) (void), void *__args) { return __gthrw_pthread_create (__threadid, __null, __func, __args); }

static inline int __gthread_join (__gthread_t __threadid, void **__value_ptr) { return __gthrw_pthread_join (__threadid, __value_ptr); }

static inline int __gthread_detach (__gthread_t __threadid) { return __gthrw_pthread_detach (__threadid); }

static inline int __gthread_equal (__gthread_t __t1, __gthread_t __t2) { return __gthrw_pthread_equal (__t1, __t2); }

static inline __gthread_t __gthread_self (void) { return __gthrw_pthread_self (); }

static inline int __gthread_yield (void) { return __gthrw_sched_yield (); }

static inline int __gthread_once (__gthread_once_t __once, void (__func) (void)) { if (__gthread_active_p ()) return __gthrw_pthread_once (__once, __func); else return -1; }

static inline int __gthread_key_create (__gthread_key_t __key, void (__dtor) (void *)) { return __gthrw_pthread_key_create (__key, __dtor); }

static inline int __gthread_key_delete (__gthread_key_t __key) { return __gthrw_pthread_key_delete (__key); }

static inline void * __gthread_getspecific (__gthread_key_t __key) { return __gthrw_pthread_getspecific (__key); }

static inline int __gthread_setspecific (__gthread_key_t __key, const void *__ptr) { return __gthrw_pthread_setspecific (__key, __ptr); }

static inline void __gthread_mutex_init_function (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) __gthrw_pthread_mutex_init (__mutex, __null); }

static inline int __gthread_mutex_destroy (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_destroy (__mutex); else return 0; }

static inline int __gthread_mutex_lock (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_lock (__mutex); else return 0; }

static inline int __gthread_mutex_trylock (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_trylock (__mutex); else return 0; }

static inline int __gthread_mutex_timedlock (__gthread_mutex_t *__mutex, const __gthread_time_t *__abs_timeout) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout); else return 0; }

static inline int __gthread_mutex_unlock (__gthread_mutex_t *__mutex) { if (__gthread_active_p ()) return __gthrw_pthread_mutex_unlock (__mutex); else return 0; }

807 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 3

static inline int __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_lock (__mutex); }

static inline int __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_trylock (__mutex); }

static inline int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, const __gthread_time_t *__abs_timeout) { return __gthread_mutex_timedlock (__mutex, __abs_timeout); }

static inline int __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_unlock (__mutex); }

static inline int __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) { return __gthread_mutex_destroy (__mutex); }

849 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr-default.h” 3

static inline int __gthread_cond_broadcast (__gthread_cond_t *__cond) { return __gthrw_pthread_cond_broadcast (__cond); }

static inline int __gthread_cond_signal (__gthread_cond_t *__cond) { return __gthrw_pthread_cond_signal (__cond); }

static inline int __gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) { return __gthrw_pthread_cond_wait (__cond, __mutex); }

static inline int __gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, const __gthread_time_t *__abs_timeout) { return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout); }

static inline int __gthread_cond_wait_recursive (__gthread_cond_t *__cond, __gthread_recursive_mutex_t *__mutex) { return __gthread_cond_wait (__cond, __mutex); }

static inline int __gthread_cond_destroy (__gthread_cond_t* __cond) { return __gthrw_pthread_cond_destroy (__cond); }

149 “/usr/include/x86_64-linux-gnu/c++/5/bits/gthr.h” 2 3

pragma GCC visibility pop

36 “/usr/include/c++/5/ext/atomicity.h” 2 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/atomic_word.h” 1 3

32 “/usr/include/x86_64-linux-gnu/c++/5/bits/atomic_word.h” 3

typedef int _Atomic_word;

37 “/usr/include/c++/5/ext/atomicity.h” 2 3

namespace __gnu_cxx attribute ((visibility (“default”))) {

static inline _Atomic_word __exchange_and_add(volatile _Atomic_word* __mem, int __val) { return __atomic_fetch_add(__mem, __val, 4); }

static inline void __atomic_add(volatile _Atomic_word* __mem, int __val) { __atomic_fetch_add(__mem, __val, 4); }

64 “/usr/include/c++/5/ext/atomicity.h” 3

static inline _Atomic_word __exchange_and_add_single(_Atomic_word* __mem, int __val) { _Atomic_word __result = *__mem; *__mem += __val; return __result; }

static inline void __atomic_add_single(_Atomic_word* __mem, int __val) { *__mem += __val; }

static inline _Atomic_word attribute ((unused)) __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) {

if (__gthread_active_p())
  return __exchange_and_add(__mem, __val);
else
  return __exchange_and_add_single(__mem, __val);

}

static inline void attribute ((unused)) __atomic_add_dispatch(_Atomic_word* __mem, int __val) {

if (__gthread_active_p())
  __atomic_add(__mem, __val);
else
  __atomic_add_single(__mem, __val);

}

40 “/usr/include/c++/5/bits/ios_base.h” 2 3

1 “/usr/include/c++/5/bits/locale_classes.h” 1 3

37 “/usr/include/c++/5/bits/locale_classes.h” 3

38 “/usr/include/c++/5/bits/locale_classes.h” 3

1 “/usr/include/c++/5/string” 1 3

36 “/usr/include/c++/5/string” 3

37 “/usr/include/c++/5/string” 3

1 “/usr/include/c++/5/bits/allocator.h” 1 3

46 “/usr/include/c++/5/bits/allocator.h” 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++allocator.h” 1 3

33 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++allocator.h” 3

1 “/usr/include/c++/5/ext/new_allocator.h” 1 3

33 “/usr/include/c++/5/ext/new_allocator.h” 3

1 “/usr/include/c++/5/new” 1 3

37 “/usr/include/c++/5/new” 3

38 “/usr/include/c++/5/new” 3

pragma GCC visibility push(default)

extern “C++” {

namespace std {

class bad_alloc : public exception { public: bad_alloc() throw() { }

virtual ~bad_alloc() throw();


virtual const char* what() const throw();

};

82 “/usr/include/c++/5/new” 3

struct nothrow_t { };

extern const nothrow_t nothrow;

typedef void (*new_handler)();

new_handler set_new_handler(new_handler) throw();

}

111 “/usr/include/c++/5/new” 3

void* operator new(std::size_t) throw(std::bad_alloc) attribute((externally_visible)); void* operator new throw(std::bad_alloc) attribute((externally_visible)); void operator delete(void*) throw() attribute((externally_visible)); void operator delete throw() attribute((externally_visible)); void* operator new(std::size_t, const std::nothrow_t&) throw() attribute((externally_visible)); void* operator new[](std::size_t, const std::nothrow_t&) throw() attribute((externally_visible)); void operator delete(void*, const std::nothrow_t&) throw() attribute((externally_visible)); void operator delete[](void*, const std::nothrow_t&) throw() attribute((externally_visible));

inline void* operator new(std::size_t, void* __p) throw() { return __p; } inline void* operator new[](std::size_t, void* __p) throw() { return __p; }

inline void operator delete (void*, void*) throw() { } inline void operator delete[](void*, void*) throw() { }

}

pragma GCC visibility pop

34 “/usr/include/c++/5/ext/new_allocator.h” 2 3

namespace __gnu_cxx attribute ((visibility (“default”))) {

using std::size_t; using std::ptrdiff_t;

57 “/usr/include/c++/5/ext/new_allocator.h” 3

template class new_allocator { public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Tp* pointer; typedef const _Tp* const_pointer; typedef _Tp& reference; typedef const _Tp& const_reference; typedef _Tp value_type;

  template<typename _Tp1>
    struct rebind
    { typedef new_allocator<_Tp1> other; };







  new_allocator() throw() { }

  new_allocator(const new_allocator&) throw() { }

  template<typename _Tp1>
    new_allocator(const new_allocator<_Tp1>&) throw() { }

  ~new_allocator() throw() { }

  pointer
  address(reference __x) const
  { return std::__addressof(__x); }

  const_pointer
  address(const_reference __x) const
  { return std::__addressof(__x); }



  pointer
  allocate(size_type __n, const void* = 0)
  {

if (__n > this→max_size()) std::__throw_bad_alloc();

return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); }

  void
  deallocate(pointer __p, size_type)
  { ::operator delete(__p); }

  size_type
  max_size() const throw()
  { return size_t(-1) / sizeof(_Tp); }

128 “/usr/include/c++/5/ext/new_allocator.h” 3

  void
  construct(pointer __p, const _Tp& __val)
  { ::new((void *)__p) _Tp(__val); }

  void
  destroy(pointer __p) { __p->~_Tp(); }

};

template inline bool operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&) { return true; }

template inline bool operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&) { return false; }

}

34 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++allocator.h” 2 3

47 “/usr/include/c++/5/bits/allocator.h” 2 3

namespace std attribute ((visibility (“default”))) {

template<> class allocator { public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef void* pointer; typedef const void* const_pointer; typedef void value_type;

  template<typename _Tp1>
    struct rebind
    { typedef allocator<_Tp1> other; };






};

91 “/usr/include/c++/5/bits/allocator.h” 3

template class allocator: public __gnu_cxx::new_allocator<_Tp> { public: typedef size_t size_type; typedef ptrdiff_t difference_type; typedef _Tp* pointer; typedef const _Tp* const_pointer; typedef _Tp& reference; typedef const _Tp& const_reference; typedef _Tp value_type;

  template<typename _Tp1>
    struct rebind
    { typedef allocator<_Tp1> other; };







  allocator() throw() { }

  allocator(const allocator& __a) throw()
  : __gnu_cxx::new_allocator<_Tp>(__a) { }

  template<typename _Tp1>
    allocator(const allocator<_Tp1>&) throw() { }

  ~allocator() throw() { }


};

template<typename _T1, typename _T2> inline bool operator==(const allocator<_T1>&, const allocator<_T2>&) throw() { return true; }

template inline bool operator==(const allocator<_Tp>&, const allocator<_Tp>&) throw() { return true; }

template<typename _T1, typename _T2> inline bool operator!=(const allocator<_T1>&, const allocator<_T2>&) throw() { return false; }

template inline bool operator!=(const allocator<_Tp>&, const allocator<_Tp>&) throw() { return false; }

extern template class allocator; extern template class allocator<wchar_t>;

template<typename _Alloc, bool = __is_empty(_Alloc)> struct __alloc_swap { static void _S_do_it(_Alloc&, _Alloc&) { } };

template struct __alloc_swap<_Alloc, false> { static void _S_do_it(_Alloc& __one, _Alloc& __two) {

if (__one != __two) swap(__one, __two); } };

template<typename _Alloc, bool = __is_empty(_Alloc)> struct __alloc_neq { static bool _S_do_it(const _Alloc&, const _Alloc&) { return false; } };

template struct __alloc_neq<_Alloc, false> { static bool _S_do_it(const _Alloc& __one, const _Alloc& __two) { return __one != __two; } };

226 “/usr/include/c++/5/bits/allocator.h” 3

}

42 “/usr/include/c++/5/string” 2 3

1 “/usr/include/c++/5/bits/ostream_insert.h” 1 3

33 “/usr/include/c++/5/bits/ostream_insert.h” 3

34 “/usr/include/c++/5/bits/ostream_insert.h” 3

1 “/usr/include/c++/5/bits/cxxabi_forced.h” 1 3

34 “/usr/include/c++/5/bits/cxxabi_forced.h” 3

35 “/usr/include/c++/5/bits/cxxabi_forced.h” 3

pragma GCC visibility push(default)

namespace __cxxabiv1 {

class __forced_unwind { virtual ~__forced_unwind() throw();

virtual void __pure_dummy() = 0;

}; }

pragma GCC visibility pop

37 “/usr/include/c++/5/bits/ostream_insert.h” 2 3

namespace std attribute ((visibility (“default”))) {

template<typename _CharT, typename _Traits> inline void __ostream_write(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s, streamsize __n) { typedef basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base;

  const streamsize __put = __out.rdbuf()->sputn(__s, __n);
  if (__put != __n)

__out.setstate(__ios_base::badbit); }

template<typename _CharT, typename _Traits> inline void __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n) { typedef basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base;

  const _CharT __c = __out.fill();
  for (; __n > 0; --__n)

{ const typename _Traits::int_type __put = __out.rdbuf()→sputc(__c); if (_Traits::eq_int_type(__put, _Traits::eof())) { __out.setstate(__ios_base::badbit); break; } } }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& __ostream_insert(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s, streamsize __n) { typedef basic_ostream<_CharT, _Traits> __ostream_type; typedef typename __ostream_type::ios_base __ios_base;

  typename __ostream_type::sentry __cerb(__out);
  if (__cerb)

{ try { const streamsize __w = __out.width(); if (__w > __n) { const bool __left = ((__out.flags() & __ios_base::adjustfield) == __ios_base::left); if (!__left) __ostream_fill(__out, __w - __n); if (__out.good()) __ostream_write(__out, __s, __n); if (__left && __out.good()) __ostream_fill(__out, __w - __n); } else __ostream_write(__out, __s, __n); __out.width(0); } catch(__cxxabiv1::__forced_unwind&) { __out._M_setstate(__ios_base::badbit); throw; } catch(…) { __out._M_setstate(__ios_base::badbit); } } return __out; }

extern template ostream& __ostream_insert(ostream&, const char*, streamsize);

extern template wostream& __ostream_insert(wostream&, const wchar_t*, streamsize);

}

45 “/usr/include/c++/5/string” 2 3

1 “/usr/include/c++/5/bits/stl_function.h” 1 3

63 “/usr/include/c++/5/bits/stl_function.h” 3

namespace std attribute ((visibility (“default”))) {

104 “/usr/include/c++/5/bits/stl_function.h” 3

template<typename _Arg, typename _Result> struct unary_function {

  typedef _Arg argument_type;


  typedef _Result result_type;
};

template<typename _Arg1, typename _Arg2, typename _Result> struct binary_function {

  typedef _Arg1 first_argument_type;


  typedef _Arg2 second_argument_type;


  typedef _Result result_type;
};

166 “/usr/include/c++/5/bits/stl_function.h” 3

template struct plus : public binary_function<_Tp, _Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x + __y; }
};

template struct minus : public binary_function<_Tp, _Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x - __y; }
};

template struct multiplies : public binary_function<_Tp, _Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x * __y; }
};

template struct divides : public binary_function<_Tp, _Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x / __y; }
};

template struct modulus : public binary_function<_Tp, _Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x % __y; }
};

template struct negate : public unary_function<_Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x) const
  { return -__x; }
};

351 “/usr/include/c++/5/bits/stl_function.h” 3

template struct equal_to : public binary_function<_Tp, _Tp, bool> {

  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x == __y; }
};

template struct not_equal_to : public binary_function<_Tp, _Tp, bool> {

  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x != __y; }
};

template struct greater : public binary_function<_Tp, _Tp, bool> {

  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x > __y; }
};

template struct less : public binary_function<_Tp, _Tp, bool> {

  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x < __y; }
};

template struct greater_equal : public binary_function<_Tp, _Tp, bool> {

  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x >= __y; }
};

template struct less_equal : public binary_function<_Tp, _Tp, bool> {

  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x <= __y; }
};

524 “/usr/include/c++/5/bits/stl_function.h” 3

template struct logical_and : public binary_function<_Tp, _Tp, bool> {

  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x && __y; }
};

template struct logical_or : public binary_function<_Tp, _Tp, bool> {

  bool
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x || __y; }
};

template struct logical_not : public unary_function<_Tp, bool> {

  bool
  operator()(const _Tp& __x) const
  { return !__x; }
};

617 “/usr/include/c++/5/bits/stl_function.h” 3

template struct bit_and : public binary_function<_Tp, _Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x & __y; }
};

template struct bit_or : public binary_function<_Tp, _Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x | __y; }
};

template struct bit_xor : public binary_function<_Tp, _Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x, const _Tp& __y) const
  { return __x ^ __y; }
};

template struct bit_not : public unary_function<_Tp, _Tp> {

  _Tp
  operator()(const _Tp& __x) const
  { return ~__x; }
};

741 “/usr/include/c++/5/bits/stl_function.h” 3

template class unary_negate : public unary_function<typename _Predicate::argument_type, bool> { protected: _Predicate _M_pred;

public:
 
  explicit
  unary_negate(const _Predicate& __x) : _M_pred(__x) { }

 
  bool
  operator()(const typename _Predicate::argument_type& __x) const
  { return !_M_pred(__x); }
};

template

inline unary_negate<_Predicate>
not1(const _Predicate& __pred)
{ return unary_negate<_Predicate>(__pred); }

template class binary_negate : public binary_function<typename _Predicate::first_argument_type, typename _Predicate::second_argument_type, bool> { protected: _Predicate _M_pred;

public:
 
  explicit
  binary_negate(const _Predicate& __x) : _M_pred(__x) { }

 
  bool
  operator()(const typename _Predicate::first_argument_type& __x,

const typename _Predicate::second_argument_type& __y) const { return !_M_pred(__x, __y); } };

template

inline binary_negate<_Predicate>
not2(const _Predicate& __pred)
{ return binary_negate<_Predicate>(__pred); }

818 “/usr/include/c++/5/bits/stl_function.h” 3

template<typename _Arg, typename _Result> class pointer_to_unary_function : public unary_function<_Arg, _Result> { protected: _Result (*_M_ptr)(_Arg);

public:
  pointer_to_unary_function() { }

  explicit
  pointer_to_unary_function(_Result (*__x)(_Arg))
  : _M_ptr(__x) { }

  _Result
  operator()(_Arg __x) const
  { return _M_ptr(__x); }
};

template<typename _Arg, typename _Result> inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg)) { return pointer_to_unary_function<_Arg, _Result>(__x); }

template<typename _Arg1, typename _Arg2, typename _Result> class pointer_to_binary_function : public binary_function<_Arg1, _Arg2, _Result> { protected: _Result (*_M_ptr)(_Arg1, _Arg2);

public:
  pointer_to_binary_function() { }

  explicit
  pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
  : _M_ptr(__x) { }

  _Result
  operator()(_Arg1 __x, _Arg2 __y) const
  { return _M_ptr(__x, __y); }
};

template<typename _Arg1, typename _Arg2, typename _Result> inline pointer_to_binary_function<_Arg1, _Arg2, _Result> ptr_fun(_Result (*__x)(_Arg1, _Arg2)) { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }

template struct _Identity : public unary_function<_Tp,_Tp> { _Tp& operator()(_Tp& __x) const { return __x; }

  const _Tp&
  operator()(const _Tp& __x) const
  { return __x; }
};

template struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> { typename _Pair::first_type& operator()(_Pair& __x) const { return __x.first; }

  const typename _Pair::first_type&
  operator()(const _Pair& __x) const
  { return __x.first; }

905 “/usr/include/c++/5/bits/stl_function.h” 3

};

template struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type> { typename _Pair::second_type& operator()(_Pair& __x) const { return __x.second; }

  const typename _Pair::second_type&
  operator()(const _Pair& __x) const
  { return __x.second; }
};

938 “/usr/include/c++/5/bits/stl_function.h” 3

template<typename _Ret, typename _Tp> class mem_fun_t : public unary_function<_Tp*, _Ret> { public: explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) { }

  _Ret
  operator()(_Tp* __p) const
  { return (__p->*_M_f)(); }

private:
  _Ret (_Tp::*_M_f)();
};

template<typename _Ret, typename _Tp> class const_mem_fun_t : public unary_function<const _Tp*, _Ret> { public: explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) { }

  _Ret
  operator()(const _Tp* __p) const
  { return (__p->*_M_f)(); }

private:
  _Ret (_Tp::*_M_f)() const;
};

template<typename _Ret, typename _Tp> class mem_fun_ref_t : public unary_function<_Tp, _Ret> { public: explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) { }

  _Ret
  operator()(_Tp& __r) const
  { return (__r.*_M_f)(); }

private:
  _Ret (_Tp::*_M_f)();

};

template<typename _Ret, typename _Tp> class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> { public: explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) { }

  _Ret
  operator()(const _Tp& __r) const
  { return (__r.*_M_f)(); }

private:
  _Ret (_Tp::*_M_f)() const;
};

template<typename _Ret, typename _Tp, typename _Arg> class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> { public: explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) { }

  _Ret
  operator()(_Tp* __p, _Arg __x) const
  { return (__p->*_M_f)(__x); }

private:
  _Ret (_Tp::*_M_f)(_Arg);
};

template<typename _Ret, typename _Tp, typename _Arg> class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> { public: explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) { }

  _Ret
  operator()(const _Tp* __p, _Arg __x) const
  { return (__p->*_M_f)(__x); }

private:
  _Ret (_Tp::*_M_f)(_Arg) const;
};

template<typename _Ret, typename _Tp, typename _Arg> class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> { public: explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) { }

  _Ret
  operator()(_Tp& __r, _Arg __x) const
  { return (__r.*_M_f)(__x); }

private:
  _Ret (_Tp::*_M_f)(_Arg);
};

template<typename _Ret, typename _Tp, typename _Arg> class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> { public: explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) { }

  _Ret
  operator()(const _Tp& __r, _Arg __x) const
  { return (__r.*_M_f)(__x); }

private:
  _Ret (_Tp::*_M_f)(_Arg) const;
};

template<typename _Ret, typename _Tp> inline mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)()) { return mem_fun_t<_Ret, _Tp>(__f); }

template<typename _Ret, typename _Tp> inline const_mem_fun_t<_Ret, _Tp> mem_fun(_Ret (_Tp::*__f)() const) { return const_mem_fun_t<_Ret, _Tp>(__f); }

template<typename _Ret, typename _Tp> inline mem_fun_ref_t<_Ret, _Tp> mem_fun_ref(_Ret (_Tp::*__f)()) { return mem_fun_ref_t<_Ret, _Tp>(__f); }

template<typename _Ret, typename _Tp> inline const_mem_fun_ref_t<_Ret, _Tp> mem_fun_ref(_Ret (_Tp::*__f)() const) { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }

template<typename _Ret, typename _Tp, typename _Arg> inline mem_fun1_t<_Ret, _Tp, _Arg> mem_fun(_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

template<typename _Ret, typename _Tp, typename _Arg> inline const_mem_fun1_t<_Ret, _Tp, _Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

template<typename _Ret, typename _Tp, typename _Arg> inline mem_fun1_ref_t<_Ret, _Tp, _Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }

template<typename _Ret, typename _Tp, typename _Arg> inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }

}

1 “/usr/include/c++/5/backward/binders.h” 1 3

60 “/usr/include/c++/5/backward/binders.h” 3

pragma GCC diagnostic push #pragma GCC diagnostic ignored “-Wdeprecated-declarations”

namespace std attribute ((visibility (“default”))) {

107 “/usr/include/c++/5/backward/binders.h” 3

template class binder1st : public unary_function<typename _Operation::second_argument_type, typename _Operation::result_type> { protected: _Operation op; typename _Operation::first_argument_type value;

public:
  binder1st(const _Operation& __x,

const typename _Operation::first_argument_type& __y) : op(__x), value(__y) { }

  typename _Operation::result_type
  operator()(const typename _Operation::second_argument_type& __x) const
  { return op(value, __x); }



  typename _Operation::result_type
  operator()(typename _Operation::second_argument_type& __x) const
  { return op(value, __x); }
} ;

template<typename _Operation, typename _Tp> inline binder1st<_Operation> bind1st(const _Operation& __fn, const _Tp& __x) { typedef typename _Operation::first_argument_type _Arg1_type; return binder1st<_Operation>(__fn, _Arg1_type(__x)); }

template class binder2nd : public unary_function<typename _Operation::first_argument_type, typename _Operation::result_type> { protected: _Operation op; typename _Operation::second_argument_type value;

public:
  binder2nd(const _Operation& __x,

const typename _Operation::second_argument_type& __y) : op(__x), value(__y) { }

  typename _Operation::result_type
  operator()(const typename _Operation::first_argument_type& __x) const
  { return op(__x, value); }



  typename _Operation::result_type
  operator()(typename _Operation::first_argument_type& __x) const
  { return op(__x, value); }
} ;

template<typename _Operation, typename _Tp> inline binder2nd<_Operation> bind2nd(const _Operation& __fn, const _Tp& __x) { typedef typename _Operation::second_argument_type _Arg2_type; return binder2nd<_Operation>(__fn, _Arg2_type(__x)); }

}

pragma GCC diagnostic pop

1129 “/usr/include/c++/5/bits/stl_function.h” 2 3

49 “/usr/include/c++/5/string” 2 3

1 “/usr/include/c++/5/bits/range_access.h” 1 3

33 “/usr/include/c++/5/bits/range_access.h” 3

34 “/usr/include/c++/5/bits/range_access.h” 3

52 “/usr/include/c++/5/string” 2 3

1 “/usr/include/c++/5/bits/basic_string.h” 1 3

37 “/usr/include/c++/5/bits/basic_string.h” 3

38 “/usr/include/c++/5/bits/basic_string.h” 3

1 “/usr/include/c++/5/ext/alloc_traits.h” 1 3

32 “/usr/include/c++/5/ext/alloc_traits.h” 3

33 “/usr/include/c++/5/ext/alloc_traits.h” 3

41 “/usr/include/c++/5/ext/alloc_traits.h” 3

namespace __gnu_cxx attribute ((visibility (“default”))) {

94 “/usr/include/c++/5/ext/alloc_traits.h” 3

template struct __alloc_traits

{ typedef _Alloc allocator_type;

172 “/usr/include/c++/5/ext/alloc_traits.h” 3

typedef typename _Alloc::pointer pointer;
typedef typename _Alloc::const_pointer const_pointer;
typedef typename _Alloc::value_type value_type;
typedef typename _Alloc::reference reference;
typedef typename _Alloc::const_reference const_reference;
typedef typename _Alloc::size_type size_type;
typedef typename _Alloc::difference_type difference_type;

static pointer
allocate(_Alloc& __a, size_type __n)
{ return __a.allocate(__n); }

static void deallocate(_Alloc& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); }

template<typename _Tp>
  static void construct(_Alloc& __a, pointer __p, const _Tp& __arg)
  { __a.construct(__p, __arg); }

static void destroy(_Alloc& __a, pointer __p)
{ __a.destroy(__p); }

static size_type max_size(const _Alloc& __a)
{ return __a.max_size(); }

static const _Alloc& _S_select_on_copy(const _Alloc& __a) { return __a; }

static void _S_on_swap(_Alloc& __a, _Alloc& __b)
{


  std::__alloc_swap<_Alloc>::_S_do_it(__a, __b);
}

template<typename _Tp>
  struct rebind
  { typedef typename _Alloc::template rebind<_Tp>::other other; };

};

}

41 “/usr/include/c++/5/bits/basic_string.h” 2 3

namespace std attribute ((visibility (“default”))) {

namespace __cxx11 {

70 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> class basic_string { typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_CharT>::other _Char_alloc_type; typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;

public:
  typedef _Traits traits_type;
  typedef typename _Traits::char_type value_type;
  typedef _Char_alloc_type allocator_type;
  typedef typename _Alloc_traits::size_type size_type;
  typedef typename _Alloc_traits::difference_type difference_type;
  typedef typename _Alloc_traits::reference reference;
  typedef typename _Alloc_traits::const_reference const_reference;
  typedef typename _Alloc_traits::pointer pointer;
  typedef typename _Alloc_traits::const_pointer const_pointer;
  typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
  typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
   const_iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  typedef std::reverse_iterator<iterator> reverse_iterator;


  static const size_type npos = static_cast<size_type>(-1);

private:


  typedef iterator __const_iterator;





  struct _Alloc_hider : allocator_type
  {

_Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc()) : allocator_type(__a), _M_p(__dat) { }

pointer _M_p; };

  _Alloc_hider _M_dataplus;
  size_type _M_string_length;

  enum { _S_local_capacity = 15 / sizeof(_CharT) };

  union
  {

_CharT _M_local_buf[_S_local_capacity + 1]; size_type _M_allocated_capacity; };

  void
  _M_data(pointer __p)
  { _M_dataplus._M_p = __p; }

  void
  _M_length(size_type __length)
  { _M_string_length = __length; }

  pointer
  _M_data() const
  { return _M_dataplus._M_p; }

  pointer
  _M_local_data()
  {

return pointer(_M_local_buf);

  }

  const_pointer
  _M_local_data() const
  {

return const_pointer(_M_local_buf);

  }

  void
  _M_capacity(size_type __capacity)
  { _M_allocated_capacity = __capacity; }

  void
  _M_set_length(size_type __n)
  {

_M_length(__n); traits_type::assign(_M_data()[__n], _CharT()); }

  bool
  _M_is_local() const
  { return _M_data() == _M_local_data(); }


  pointer
  _M_create(size_type&, size_type);

  void
  _M_dispose()
  {

if (!_M_is_local()) _M_destroy(_M_allocated_capacity); }

  void
  _M_destroy(size_type __size) throw()
  { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }



  template<typename _InIterator>
    void
    _M_construct_aux(_InIterator __beg, _InIterator __end,
std::__false_type)

{ typedef typename iterator_traits<_InIterator>::iterator_category _Tag; _M_construct(__beg, __end, _Tag()); }

  template<typename _Integer>
    void
    _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)

{ _M_construct_aux_2(static_cast<size_type>(__beg), __end); }

  void
  _M_construct_aux_2(size_type __req, _CharT __c)
  { _M_construct(__req, __c); }

  template<typename _InIterator>
    void
    _M_construct(_InIterator __beg, _InIterator __end)

{ typedef typename std::__is_integer<_InIterator>::__type _Integral; _M_construct_aux(__beg, __end, _Integral()); }

  template<typename _InIterator>
    void
    _M_construct(_InIterator __beg, _InIterator __end,
   std::input_iterator_tag);



  template<typename _FwdIterator>
    void
    _M_construct(_FwdIterator __beg, _FwdIterator __end,
   std::forward_iterator_tag);

  void
  _M_construct(size_type __req, _CharT __c);

  allocator_type&
  _M_get_allocator()
  { return _M_dataplus; }

  const allocator_type&
  _M_get_allocator() const
  { return _M_dataplus; }

private:

257 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  _M_check(size_type __pos, const char* __s) const
  {

if (__pos > this→size()) __throw_out_of_range_fmt((“%s: __pos (which is %zu) > ” “this→size() (which is %zu)”) , __s, __pos, this→size()); return __pos; }

  void
  _M_check_length(size_type __n1, size_type __n2, const char* __s) const
  {

if (this→max_size() - (this→size() - __n1) < __n2) __throw_length_error((__s)); }

  size_type
  _M_limit(size_type __pos, size_type __off) const
  {

const bool __testoff = __off < this→size() - __pos; return __testoff ? __off : this→size() - __pos; }

  bool
  _M_disjunct(const _CharT* __s) const
  {

return (less<const _CharT*>()(__s, _M_data()) || less<const _CharT*>()(_M_data() + this→size(), __s)); }

  static void
  _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
  {

if (__n == 1) traits_type::assign(*__d, *__s); else traits_type::copy(__d, __s, __n); }

  static void
  _S_move(_CharT* __d, const _CharT* __s, size_type __n)
  {

if (__n == 1) traits_type::assign(*__d, *__s); else traits_type::move(__d, __s, __n); }

  static void
  _S_assign(_CharT* __d, size_type __n, _CharT __c)
  {

if (__n == 1) traits_type::assign(*__d, __c); else traits_type::assign(__d, __n, __c); }

  template<class _Iterator>
    static void
    _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
    {

for (; __k1 != __k2; ++__k1, ++__p) traits_type::assign(*__p, *__k1); }

  static void
  _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
  { _S_copy_chars(__p, __k1.base(), __k2.base()); }

  static void
  _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
 
  { _S_copy_chars(__p, __k1.base(), __k2.base()); }

  static void
  _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
  { _S_copy(__p, __k1, __k2 - __k1); }

  static void
  _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
 
  { _S_copy(__p, __k1, __k2 - __k1); }

  static int
  _S_compare(size_type __n1, size_type __n2)
  {

const difference_type __d = difference_type(__n1 - __n2);

if (__d > __gnu_cxx::__numeric_traits::__max) return __gnu_cxx::__numeric_traits::__max; else if (__d < __gnu_cxx::__numeric_traits::__min) return __gnu_cxx::__numeric_traits::__min; else return int(__d); }

  void
  _M_assign(const basic_string& __rcs);

  void
  _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,

size_type __len2);

  void
  _M_erase(size_type __pos, size_type __n);

public:







  basic_string()



  : _M_dataplus(_M_local_data())
  { _M_set_length(0); }




  explicit
  basic_string(const _Alloc& __a)
  : _M_dataplus(_M_local_data(), __a)
  { _M_set_length(0); }





  basic_string(const basic_string& __str)
  : _M_dataplus(_M_local_data(), __str._M_get_allocator())
  { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }

410 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string(const basic_string& __str, size_type __pos,
 size_type __n = npos)
  : _M_dataplus(_M_local_data())
  {

const _CharT* __start = __str._M_data()

__str._M_check(__pos, “basic_string::basic_string”); _M_construct(__start, __start + __str._M_limit(__pos, __n)); }

426 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string(const basic_string& __str, size_type __pos,
 size_type __n, const _Alloc& __a)
  : _M_dataplus(_M_local_data(), __a)
  {

const _CharT* __start = __str._M_data() + __str._M_check(__pos, “string::string”); _M_construct(__start, __start + __str._M_limit(__pos, __n)); }

444 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string(const _CharT* __s, size_type __n,
 const _Alloc& __a = _Alloc())
  : _M_dataplus(_M_local_data(), __a)
  { _M_construct(__s, __s + __n); }






  basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
  : _M_dataplus(_M_local_data(), __a)
  { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }







  basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
  : _M_dataplus(_M_local_data(), __a)
  { _M_construct(__n, __c); }

532 “/usr/include/c++/5/bits/basic_string.h” 3

  template<typename _InputIterator>

    basic_string(_InputIterator __beg, _InputIterator __end,
   const _Alloc& __a = _Alloc())

: _M_dataplus(_M_local_data(), __a) { _M_construct(__beg, __end); }

  ~basic_string()
  { _M_dispose(); }





  basic_string&
  operator=(const basic_string& __str)
  { return this->assign(__str); }





  basic_string&
  operator=(const _CharT* __s)
  { return this->assign(__s); }

568 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  operator=(_CharT __c)
  {

this→assign(1, __c); return *this; }

610 “/usr/include/c++/5/bits/basic_string.h” 3

  iterator
  begin()
  { return iterator(_M_data()); }





  const_iterator
  begin() const
  { return const_iterator(_M_data()); }





  iterator
  end()
  { return iterator(_M_data() + this->size()); }





  const_iterator
  end() const
  { return const_iterator(_M_data() + this->size()); }






  reverse_iterator
  rbegin()
  { return reverse_iterator(this->end()); }






  const_reverse_iterator
  rbegin() const
  { return const_reverse_iterator(this->end()); }






  reverse_iterator
  rend()
  { return reverse_iterator(this->begin()); }






  const_reverse_iterator
  rend() const
  { return const_reverse_iterator(this->begin()); }

710 “/usr/include/c++/5/bits/basic_string.h” 3

public:



  size_type
  size() const
  { return _M_string_length; }



  size_type
  length() const
  { return _M_string_length; }


  size_type
  max_size() const
  { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }

739 “/usr/include/c++/5/bits/basic_string.h” 3

  void
  resize(size_type __n, _CharT __c);

752 “/usr/include/c++/5/bits/basic_string.h” 3

  void
  resize(size_type __n)
  { this->resize(__n, _CharT()); }

777 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  capacity() const
  {

return _M_is_local() ? size_type(_S_local_capacity) : _M_allocated_capacity; }

801 “/usr/include/c++/5/bits/basic_string.h” 3

  void
  reserve(size_type __res_arg = 0);




  void
  clear()
  { _M_set_length(0); }





  bool
  empty() const
  { return this->size() == 0; }

830 “/usr/include/c++/5/bits/basic_string.h” 3

  const_reference
  operator[] (size_type __pos) const
  {

; return _M_data()[__pos]; }

847 “/usr/include/c++/5/bits/basic_string.h” 3

  reference
  operator[](size_type __pos)
  {

;

; return _M_data()[__pos]; }

868 “/usr/include/c++/5/bits/basic_string.h” 3

  const_reference
  at(size_type __n) const
  {

if (__n >= this→size()) __throw_out_of_range_fmt((“basic_string::at: __n ” “(which is %zu) >= this→size() ” “(which is %zu)“)

                        ,
   __n, this->size());

return _M_data()[__n]; }

889 “/usr/include/c++/5/bits/basic_string.h” 3

  reference
  at(size_type __n)
  {

if (__n >= size()) __throw_out_of_range_fmt((“basic_string::at: __n ” “(which is %zu) >= this→size() ” “(which is %zu)“)

                        ,
   __n, this->size());

return _M_data()[__n]; }

940 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  operator+=(const basic_string& __str)
  { return this->append(__str); }






  basic_string&
  operator+=(const _CharT* __s)
  { return this->append(__s); }






  basic_string&
  operator+=(_CharT __c)
  {

this→push_back(__c); return *this; }

981 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  append(const basic_string& __str)
  { return _M_append(__str._M_data(), __str.size()); }

998 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  append(const basic_string& __str, size_type __pos, size_type __n)
  { return _M_append(__str._M_data()
+ __str._M_check(__pos, "basic_string::append"),
__str._M_limit(__pos, __n)); }







  basic_string&
  append(const _CharT* __s, size_type __n)
  {

; _M_check_length(size_type(0), __n, “basic_string::append”); return _M_append(__s, __n); }

  basic_string&
  append(const _CharT* __s)
  {

; const size_type __n = traits_type::length(__s); _M_check_length(size_type(0), __n, “basic_string::append”); return _M_append(__s, __n); }

1040 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  append(size_type __n, _CharT __c)
  { return _M_replace_aux(this->size(), size_type(0), __n, __c); }

1067 “/usr/include/c++/5/bits/basic_string.h” 3

  template<class _InputIterator>

    basic_string&
    append(_InputIterator __first, _InputIterator __last)
    { return this->replace(end(), end(), __first, __last); }





  void
  push_back(_CharT __c)
  {

const size_type __size = this→size(); if (__size + 1 > this→capacity()) this→_M_mutate(__size, size_type(0), 0, size_type(1)); traits_type::assign(this→_M_data()[__size], __c); this→_M_set_length(__size + 1); }

  basic_string&
  assign(const basic_string& __str)
  {

this→_M_assign(__str); return *this; }

1130 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  assign(const basic_string& __str, size_type __pos, size_type __n)
  { return _M_replace(size_type(0), this->size(), __str._M_data()
 + __str._M_check(__pos, "basic_string::assign"),
 __str._M_limit(__pos, __n)); }

1146 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  assign(const _CharT* __s, size_type __n)
  {

; return _M_replace(size_type(0), this→size(), __s, __n); }

1162 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  assign(const _CharT* __s)
  {

; return _M_replace(size_type(0), this→size(), __s, traits_type::length(__s)); }

1179 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  assign(size_type __n, _CharT __c)
  { return _M_replace_aux(size_type(0), this->size(), __n, __c); }

1195 “/usr/include/c++/5/bits/basic_string.h” 3

  template<class _InputIterator>

    basic_string&
    assign(_InputIterator __first, _InputIterator __last)
    { return this->replace(begin(), end(), __first, __last); }

1250 “/usr/include/c++/5/bits/basic_string.h” 3

  void
  insert(iterator __p, size_type __n, _CharT __c)
  { this->replace(__p, __p, __n, __c); }

1293 “/usr/include/c++/5/bits/basic_string.h” 3

  template<class _InputIterator>
    void
    insert(iterator __p, _InputIterator __beg, _InputIterator __end)
    { this->replace(__p, __p, __beg, __end); }

1326 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  insert(size_type __pos1, const basic_string& __str)
  { return this->replace(__pos1, size_type(0),
    __str._M_data(), __str.size()); }

1349 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  insert(size_type __pos1, const basic_string& __str,
  size_type __pos2, size_type __n)
  { return this->replace(__pos1, size_type(0), __str._M_data()
    + __str._M_check(__pos2, "basic_string::insert"),
    __str._M_limit(__pos2, __n)); }

1372 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  insert(size_type __pos, const _CharT* __s, size_type __n)
  { return this->replace(__pos, size_type(0), __s, __n); }

1391 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  insert(size_type __pos, const _CharT* __s)
  {

; return this→replace(__pos, size_type(0), __s, traits_type::length(__s)); }

1415 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  insert(size_type __pos, size_type __n, _CharT __c)
  { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
     size_type(0), __n, __c); }

1433 “/usr/include/c++/5/bits/basic_string.h” 3

  iterator
  insert(__const_iterator __p, _CharT __c)
  {

; const size_type __pos = __p - begin(); _M_replace_aux(__pos, size_type(0), size_type(1), __c); return iterator(_M_data() + __pos); }

1457 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  erase(size_type __pos = 0, size_type __n = npos)
  {

this→_M_erase(_M_check(__pos, “basic_string::erase”), _M_limit(__pos, __n)); return *this; }

1473 “/usr/include/c++/5/bits/basic_string.h” 3

  iterator
  erase(__const_iterator __position)
  {

                       ;

const size_type __pos = __position - begin(); this→_M_erase(__pos, size_type(1)); return iterator(_M_data() + __pos); }

1492 “/usr/include/c++/5/bits/basic_string.h” 3

  iterator
  erase(__const_iterator __first, __const_iterator __last)
  {

                    ;
    const size_type __pos = __first - begin();

this→_M_erase(__pos, __last - __first); return iterator(this→_M_data() + __pos); }

1530 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  replace(size_type __pos, size_type __n, const basic_string& __str)
  { return this->replace(__pos, __n, __str._M_data(), __str.size()); }

1552 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  replace(size_type __pos1, size_type __n1, const basic_string& __str,
   size_type __pos2, size_type __n2)
  { return this->replace(__pos1, __n1, __str._M_data()
    + __str._M_check(__pos2, "basic_string::replace"),
    __str._M_limit(__pos2, __n2)); }

1577 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  replace(size_type __pos, size_type __n1, const _CharT* __s,
   size_type __n2)
  {

; return _M_replace(_M_check(__pos, “basic_string::replace”), _M_limit(__pos, __n1), __s, __n2); }

1602 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  replace(size_type __pos, size_type __n1, const _CharT* __s)
  {

; return this→replace(__pos, __n1, __s, traits_type::length(__s)); }

1626 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
  { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
     _M_limit(__pos, __n1), __n2, __c); }

1644 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  replace(__const_iterator __i1, __const_iterator __i2,
   const basic_string& __str)
  { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }

1664 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  replace(__const_iterator __i1, __const_iterator __i2,
   const _CharT* __s, size_type __n)
  {

                  ;

return this→replace(__i1 - begin(), __i2 - __i1, __s, __n); }

1686 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
  {

; return this→replace(__i1, __i2, __s, traits_type::length(__s)); }

1707 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string&
  replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
   _CharT __c)
  {

                  ;

return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c); }

1745 “/usr/include/c++/5/bits/basic_string.h” 3

  template<class _InputIterator>



    basic_string&

    replace(iterator __i1, iterator __i2,

_InputIterator __k1, _InputIterator __k2) {

; typedef typename std::__is_integer<_InputIterator>::__type _Integral; return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral()); }

  basic_string&
  replace(__const_iterator __i1, __const_iterator __i2,
   _CharT* __k1, _CharT* __k2)
  {

                  ;

; return this→replace(__i1 - begin(), __i2 - __i1, __k1, __k2 - __k1); }

  basic_string&
  replace(__const_iterator __i1, __const_iterator __i2,
   const _CharT* __k1, const _CharT* __k2)
  {

                  ;

; return this→replace(__i1 - begin(), __i2 - __i1, __k1, __k2 - __k1); }

  basic_string&
  replace(__const_iterator __i1, __const_iterator __i2,
   iterator __k1, iterator __k2)
  {

                  ;

; return this→replace(__i1 - begin(), __i2 - __i1, __k1.base(), __k2 - __k1); }

  basic_string&
  replace(__const_iterator __i1, __const_iterator __i2,
   const_iterator __k1, const_iterator __k2)
  {

                  ;

; return this→replace(__i1 - begin(), __i2 - __i1, __k1.base(), __k2 - __k1); }

1828 “/usr/include/c++/5/bits/basic_string.h” 3

private:
  template<class _Integer>

basic_string& _M_replace_dispatch(const_iterator __i1, const_iterator __i2, _Integer __n, _Integer __val, __true_type) { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }

  template<class _InputIterator>

basic_string& _M_replace_dispatch(const_iterator __i1, const_iterator __i2, _InputIterator __k1, _InputIterator __k2, __false_type);

  basic_string&
  _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
   _CharT __c);

  basic_string&
  _M_replace(size_type __pos, size_type __len1, const _CharT* __s,

const size_type __len2);

  basic_string&
  _M_append(const _CharT* __s, size_type __n);

public:

1866 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  copy(_CharT* __s, size_type __n, size_type __pos = 0) const;

1876 “/usr/include/c++/5/bits/basic_string.h” 3

  void
  swap(basic_string& __s) ;

1886 “/usr/include/c++/5/bits/basic_string.h” 3

  const _CharT*
  c_str() const
  { return _M_data(); }







  const _CharT*
  data() const
  { return _M_data(); }




  allocator_type
  get_allocator() const
  { return _M_get_allocator(); }

1919 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find(const _CharT* __s, size_type __pos, size_type __n) const;

1932 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find(const basic_string& __str, size_type __pos = 0) const

  { return this->find(__str.data(), __pos, __str.size()); }

1947 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find(const _CharT* __s, size_type __pos = 0) const
  {

; return this→find(__s, __pos, traits_type::length(__s)); }

1964 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find(_CharT __c, size_type __pos = 0) const ;

1977 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  rfind(const basic_string& __str, size_type __pos = npos) const

  { return this->rfind(__str.data(), __pos, __str.size()); }

1994 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  rfind(const _CharT* __s, size_type __pos, size_type __n) const;

2007 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  rfind(const _CharT* __s, size_type __pos = npos) const
  {

; return this→rfind(__s, __pos, traits_type::length(__s)); }

2024 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  rfind(_CharT __c, size_type __pos = npos) const ;

2038 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_first_of(const basic_string& __str, size_type __pos = 0) const

  { return this->find_first_of(__str.data(), __pos, __str.size()); }

2055 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;

2068 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_first_of(const _CharT* __s, size_type __pos = 0) const
  {

; return this→find_first_of(__s, __pos, traits_type::length(__s)); }

2087 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_first_of(_CharT __c, size_type __pos = 0) const
  { return this->find(__c, __pos); }

2102 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_last_of(const basic_string& __str, size_type __pos = npos) const

  { return this->find_last_of(__str.data(), __pos, __str.size()); }

2119 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;

2132 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_last_of(const _CharT* __s, size_type __pos = npos) const
  {

; return this→find_last_of(__s, __pos, traits_type::length(__s)); }

2151 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_last_of(_CharT __c, size_type __pos = npos) const
  { return this->rfind(__c, __pos); }

2165 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_first_not_of(const basic_string& __str, size_type __pos = 0) const

  { return this->find_first_not_of(__str.data(), __pos, __str.size()); }

2182 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_first_not_of(const _CharT* __s, size_type __pos,

size_type __n) const;

2196 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_first_not_of(const _CharT* __s, size_type __pos = 0) const
  {

; return this→find_first_not_of(__s, __pos, traits_type::length(__s)); }

2213 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_first_not_of(_CharT __c, size_type __pos = 0) const

;

2228 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_last_not_of(const basic_string& __str, size_type __pos = npos) const

  { return this->find_last_not_of(__str.data(), __pos, __str.size()); }

2245 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_last_not_of(const _CharT* __s, size_type __pos,
     size_type __n) const;

2259 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_last_not_of(const _CharT* __s, size_type __pos = npos) const
  {

; return this→find_last_not_of(__s, __pos, traits_type::length(__s)); }

2276 “/usr/include/c++/5/bits/basic_string.h” 3

  size_type
  find_last_not_of(_CharT __c, size_type __pos = npos) const

;

2292 “/usr/include/c++/5/bits/basic_string.h” 3

  basic_string
  substr(size_type __pos = 0, size_type __n = npos) const
  { return basic_string(*this,
   _M_check(__pos, "basic_string::substr"), __n); }

2311 “/usr/include/c++/5/bits/basic_string.h” 3

  int
  compare(const basic_string& __str) const
  {

const size_type __size = this→size(); const size_type __osize = __str.size(); const size_type __len = std::min(__size, __osize);

int __r = traits_type::compare(_M_data(), __str.data(), __len); if (!__r) __r = _S_compare(__size, __osize); return __r; }

2343 “/usr/include/c++/5/bits/basic_string.h” 3

  int
  compare(size_type __pos, size_type __n, const basic_string& __str) const;

2369 “/usr/include/c++/5/bits/basic_string.h” 3

  int
  compare(size_type __pos1, size_type __n1, const basic_string& __str,
   size_type __pos2, size_type __n2) const;

2387 “/usr/include/c++/5/bits/basic_string.h” 3

  int
  compare(const _CharT* __s) const;

2411 “/usr/include/c++/5/bits/basic_string.h” 3

  int
  compare(size_type __pos, size_type __n1, const _CharT* __s) const;

2438 “/usr/include/c++/5/bits/basic_string.h” 3

  int
  compare(size_type __pos, size_type __n1, const _CharT* __s,
   size_type __n2) const;

}; }

4781 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { basic_string<_CharT, _Traits, _Alloc> __str(__lhs); __str.append(__rhs); return __str; }

template<typename _CharT, typename _Traits, typename _Alloc> basic_string<_CharT,_Traits,_Alloc> operator+(const _CharT* __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);

template<typename _CharT, typename _Traits, typename _Alloc> basic_string<_CharT,_Traits,_Alloc> operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);

template<typename _CharT, typename _Traits, typename _Alloc> inline basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { basic_string<_CharT, _Traits, _Alloc> __str(__lhs); __str.append(__rhs); return __str; }

template<typename _CharT, typename _Traits, typename _Alloc> inline basic_string<_CharT, _Traits, _Alloc> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) { typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __string_type::size_type __size_type; __string_type __str(__lhs); __str.append(__size_type(1), __rhs); return __str; }

4902 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) 0; }

template inline typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type operator(const basic_string<_CharT>& __lhs, const basic_string<_CharT>& __rhs) { return (__lhs.size() __rhs.size() && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(), __lhs.size())); }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) 0; }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) 0; }

4948 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return !(__lhs == __rhs); }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator!=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return !(__lhs == __rhs); }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return !(__lhs == __rhs); }

4985 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) < 0; }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) < 0; }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator<(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) > 0; }

5022 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) > 0; }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) > 0; }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator>(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) < 0; }

5059 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator⇐(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) ⇐ 0; }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator⇐(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) ⇐ 0; }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator⇐(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) >= 0; }

5096 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __lhs.compare(__rhs) >= 0; }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, const _CharT* __rhs) { return __lhs.compare(__rhs) >= 0; }

template<typename _CharT, typename _Traits, typename _Alloc> inline bool operator>=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { return __rhs.compare(__lhs) ⇐ 0; }

5133 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> inline void swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, basic_string<_CharT, _Traits, _Alloc>& __rhs) { __lhs.swap(__rhs); }

5152 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str);

template<> basic_istream& operator>>(basic_istream& __is, basic_string& __str);

5170 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Alloc>& __str) {

  return __ostream_insert(__os, __str.data(), __str.size());
}

5193 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);

5210 “/usr/include/c++/5/bits/basic_string.h” 3

template<typename _CharT, typename _Traits, typename _Alloc> inline basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Alloc>& __str) { return std::getline(__is, __str, __is.widen(‘\n’)); }

5232 “/usr/include/c++/5/bits/basic_string.h” 3

template<> basic_istream& getline(basic_istream& __in, basic_string& __str, char __delim);

template<> basic_istream<wchar_t>& getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str, wchar_t __delim);

}

53 “/usr/include/c++/5/string” 2 3

1 “/usr/include/c++/5/bits/basic_string.tcc” 1 3

42 “/usr/include/c++/5/bits/basic_string.tcc” 3

43 “/usr/include/c++/5/bits/basic_string.tcc” 3

namespace std attribute ((visibility (“default”))) {

template<typename _CharT, typename _Traits, typename _Alloc> const typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>::npos;

template<typename _CharT, typename _Traits, typename _Alloc> void basic_string<_CharT, _Traits, _Alloc>:: swap(basic_string& __s) { if (this == &__s) return;

  std::__alloc_swap<allocator_type>::_S_do_it(_M_get_allocator(),
    __s._M_get_allocator());

  if (_M_is_local())

if (__s._M_is_local()) { if (length() && __s.length()) { _CharT __tmp_data[_S_local_capacity + 1]; traits_type::copy(__tmp_data, __s._M_local_buf, _S_local_capacity + 1); traits_type::copy(__s._M_local_buf, _M_local_buf, _S_local_capacity + 1); traits_type::copy(_M_local_buf, __tmp_data, _S_local_capacity + 1); } else if (__s.length()) { traits_type::copy(_M_local_buf, __s._M_local_buf, _S_local_capacity + 1); _M_length(__s.length()); __s._M_set_length(0); return; } else if (length()) { traits_type::copy(__s._M_local_buf, _M_local_buf, _S_local_capacity + 1); __s._M_length(length()); _M_set_length(0); return; } } else { const size_type __tmp_capacity = __s._M_allocated_capacity; traits_type::copy(__s._M_local_buf, _M_local_buf, _S_local_capacity + 1); _M_data(__s._M_data()); __s._M_data(__s._M_local_buf); _M_capacity(__tmp_capacity); } else { const size_type __tmp_capacity = _M_allocated_capacity; if (__s._M_is_local()) { traits_type::copy(_M_local_buf, __s._M_local_buf, _S_local_capacity + 1); __s._M_data(_M_data()); _M_data(_M_local_buf); } else { pointer __tmp_ptr = _M_data(); _M_data(__s._M_data()); __s._M_data(__tmp_ptr); _M_capacity(__s._M_allocated_capacity); } __s._M_capacity(__tmp_capacity); }

  const size_type __tmp_length = length();
  _M_length(__s.length());
  __s._M_length(__tmp_length);
}

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::pointer basic_string<_CharT, _Traits, _Alloc>:: _M_create(size_type& __capacity, size_type __old_capacity) {

  if (__capacity > max_size())

std::__throw_length_error((“basic_string::_M_create”));

  if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)

{ __capacity = 2 * __old_capacity;

if (__capacity > max_size()) __capacity = max_size(); }

  return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
}

template<typename _CharT, typename _Traits, typename _Alloc> template void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(_InIterator __beg, _InIterator __end, std::input_iterator_tag) { size_type __len = 0; size_type __capacity = size_type(_S_local_capacity);

while (__beg != __end && __len < __capacity) { _M_data()[__len++] = *__beg; ++__beg; }

try { while (__beg != __end) { if (__len == __capacity) {

  __capacity = __len + 1;
  pointer __another = _M_create(__capacity, __len);
  this->_S_copy(__another, _M_data(), __len);
  _M_dispose();
  _M_data(__another);
  _M_capacity(__capacity);
}

_M_data()[__len++] = *__beg; ++__beg; } } catch(…) { _M_dispose(); throw; }

_M_set_length(__len); }

template<typename _CharT, typename _Traits, typename _Alloc> template void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(_InIterator __beg, _InIterator __end, std::forward_iterator_tag) {

if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end) std::__throw_logic_error((“basic_string::” “_M_construct null not valid”) );

size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));

if (__dnew > size_type(_S_local_capacity)) { _M_data(_M_create(__dnew, size_type(0))); _M_capacity(__dnew); }

try { this→_S_copy_chars(_M_data(), __beg, __end); } catch(…) { _M_dispose(); throw; }

_M_set_length(__dnew); }

template<typename _CharT, typename _Traits, typename _Alloc> void basic_string<_CharT, _Traits, _Alloc>:: _M_construct(size_type __n, _CharT __c) { if (__n > size_type(_S_local_capacity)) { _M_data(_M_create(__n, size_type(0))); _M_capacity(__n); }

  if (__n)

this→_S_assign(_M_data(), __n, __c);

  _M_set_length(__n);
}

template<typename _CharT, typename _Traits, typename _Alloc> void basic_string<_CharT, _Traits, _Alloc>:: _M_assign(const basic_string& __str) { if (this != &__str) { const size_type __rsize = __str.length(); const size_type __capacity = capacity();

if (__rsize > __capacity) { size_type __new_capacity = __rsize; pointer __tmp = _M_create(__new_capacity, __capacity); _M_dispose(); _M_data(__tmp); _M_capacity(__new_capacity); }

if (__rsize) this→_S_copy(_M_data(), __str._M_data(), __rsize);

_M_set_length(__rsize); } }

template<typename _CharT, typename _Traits, typename _Alloc> void basic_string<_CharT, _Traits, _Alloc>:: reserve(size_type __res) {

  if (__res < length())

__res = length();

  const size_type __capacity = capacity();
  if (__res != __capacity)

{ if (__res > __capacity || __res > size_type(_S_local_capacity)) { pointer __tmp = _M_create(__res, __capacity); this→_S_copy(__tmp, _M_data(), length() + 1); _M_dispose(); _M_data(__tmp); _M_capacity(__res); } else if (!_M_is_local()) { this→_S_copy(_M_local_data(), _M_data(), length() + 1); _M_destroy(__capacity); _M_data(_M_local_data()); } } }

template<typename _CharT, typename _Traits, typename _Alloc> void basic_string<_CharT, _Traits, _Alloc>:: _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, size_type __len2) { const size_type __how_much = length() - __pos - __len1;

  size_type __new_capacity = length() + __len2 - __len1;
  pointer __r = _M_create(__new_capacity, capacity());

  if (__pos)

this→_S_copy(__r, _M_data(), __pos); if (__s && __len2) this→_S_copy(__r + __pos, __s, __len2); if (__how_much) this→_S_copy(__r + __pos + __len2, _M_data() + __pos + __len1, __how_much);

  _M_dispose();
  _M_data(__r);
  _M_capacity(__new_capacity);
}

template<typename _CharT, typename _Traits, typename _Alloc> void basic_string<_CharT, _Traits, _Alloc>:: _M_erase(size_type __pos, size_type __n) { const size_type __how_much = length() - __pos - __n;

  if (__how_much && __n)

this→_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);

  _M_set_length(length() - __n);
}

template<typename _CharT, typename _Traits, typename _Alloc> void basic_string<_CharT, _Traits, _Alloc>:: resize(size_type __n, _CharT __c) { const size_type __size = this→size(); if (__size < __n) this→append(__n - __size, __c); else if (__n < __size) this→_M_erase(__n, __size - __n); }

template<typename _CharT, typename _Traits, typename _Alloc> basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_append(const _CharT* __s, size_type __n) { const size_type __len = __n + this→size();

  if (__len <= this->capacity())

{ if (__n) this→_S_copy(this→_M_data() + this→size(), __s, __n); } else this→_M_mutate(this→size(), size_type(0), __s, __n);

  this->_M_set_length(__len);
  return *this;
}

template<typename _CharT, typename _Traits, typename _Alloc> template basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace_dispatch(const_iterator __i1, const_iterator __i2, _InputIterator __k1, _InputIterator __k2, std::__false_type) { const basic_string __s(__k1, __k2); const size_type __n1 = __i2 - __i1; return _M_replace(__i1 - begin(), __n1, __s._M_data(), __s.size()); }

template<typename _CharT, typename _Traits, typename _Alloc> basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, _CharT __c) { _M_check_length(__n1, __n2, “basic_string::_M_replace_aux”);

  const size_type __old_size = this->size();
  const size_type __new_size = __old_size + __n2 - __n1;

  if (__new_size <= this->capacity())

{ _CharT* __p = this→_M_data() + __pos1;

const size_type __how_much = __old_size - __pos1 - __n1; if (__how_much && __n1 != __n2) this→_S_move(__p + __n2, __p + __n1, __how_much); } else this→_M_mutate(__pos1, __n1, 0, __n2);

  if (__n2)

this→_S_assign(this→_M_data() + __pos1, __n2, __c);

  this->_M_set_length(__new_size);
  return *this;
}

template<typename _CharT, typename _Traits, typename _Alloc> basic_string<_CharT, _Traits, _Alloc>& basic_string<_CharT, _Traits, _Alloc>:: _M_replace(size_type __pos, size_type __len1, const _CharT* __s, const size_type __len2) { _M_check_length(__len1, __len2, “basic_string::_M_replace”);

  const size_type __old_size = this->size();
  const size_type __new_size = __old_size + __len2 - __len1;

  if (__new_size <= this->capacity())

{ _CharT* __p = this→_M_data() + __pos;

const size_type __how_much = __old_size - __pos - __len1; if (_M_disjunct(__s)) { if (__how_much && __len1 != __len2) this→_S_move(__p + __len2, __p + __len1, __how_much); if (__len2) this→_S_copy(__p, __s, __len2); } else {

   if (__len2 && __len2 <= __len1)

this→_S_move(__p, __s, __len2); if (__how_much && __len1 != __len2) this→_S_move(__p + __len2, __p + __len1, __how_much); if (__len2 > __len1) { if (__s + __len2 ⇐ __p + __len1) this→_S_move(__p, __s, __len2); else if (__s >= __p + __len1) this→_S_copy(__p, __s + __len2 - __len1, __len2); else { const size_type __nleft = (__p + __len1) - __s; this→_S_move(__p, __s, __nleft); this→_S_copy(__p + __nleft, __p + __len2, __len2 - __nleft); } } } } else this→_M_mutate(__pos, __len1, __s, __len2);

  this->_M_set_length(__new_size);
  return *this;
}

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: copy(_CharT* __s, size_type __n, size_type __pos) const { _M_check(__pos, “basic_string::copy”); __n = _M_limit(__pos, __n); ; if (__n) _S_copy(__s, _M_data() + __pos, __n);

  return __n;
}

1149 “/usr/include/c++/5/bits/basic_string.tcc” 3

template<typename _CharT, typename _Traits, typename _Alloc> basic_string<_CharT, _Traits, _Alloc> operator+(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { ; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __string_type::size_type __size_type; const __size_type __len = _Traits::length(__lhs); __string_type __str; __str.reserve(__len + __rhs.size()); __str.append(__lhs, __len); __str.append(__rhs); return __str; }

template<typename _CharT, typename _Traits, typename _Alloc> basic_string<_CharT, _Traits, _Alloc> operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) { typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __string_type::size_type __size_type; __string_type __str; const __size_type __len = __rhs.size(); __str.reserve(__len + 1); __str.append(__size_type(1), __lhs); __str.append(__rhs); return __str; }

  if (__n == 0)

return __pos ⇐ __size ? __pos : npos;

  if (__n <= __size)

{ for (; __pos ⇐ __size - __n; ++__pos) if (traits_type::eq(__data[__pos], __s[0]) && traits_type::compare(__data + __pos + 1, __s + 1, __n - 1) == 0) return __pos; } return npos; }

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find(_CharT __c, size_type __pos) const { size_type __ret = npos; const size_type __size = this→size(); if (__pos < __size) { const _CharT* __data = _M_data(); const size_type __n = __size - __pos; const _CharT* __p = traits_type::find(__data + __pos, __n, __c); if (__p) __ret = __p - __data; } return __ret; }

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: rfind(const _CharT* __s, size_type __pos, size_type __n) const { ; const size_type __size = this→size(); if (__n ⇐ __size) { __pos = std::min(size_type(__size - __n), __pos); const _CharT* __data = _M_data(); do { if (traits_type::compare(__data + __pos, __s, __n) == 0) return __pos; } while (__pos— > 0); } return npos; }

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: rfind(_CharT __c, size_type __pos) const { size_type __size = this→size(); if (__size) { if (—__size > __pos) __size = __pos; for (++__size; __size— > 0; ) if (traits_type::eq(_M_data()[__size], __c)) return __size; } return npos; }

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_first_of(const _CharT* __s, size_type __pos, size_type __n) const { ; for (; __n && __pos < this→size(); ++__pos) { const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]); if (__p) return __pos; } return npos; }

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_last_of(const _CharT* __s, size_type __pos, size_type __n) const { ; size_type __size = this→size(); if (__size && __n) { if (—__size > __pos) __size = __pos; do { if (traits_type::find(__s, __n, _M_data()[__size])) return __size; } while (__size— != 0); } return npos; }

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const { ; for (; __pos < this→size(); ++__pos) if (!traits_type::find(__s, __n, _M_data()[__pos])) return __pos; return npos; }

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_first_not_of(_CharT __c, size_type __pos) const { for (; __pos < this→size(); ++__pos) if (!traits_type::eq(_M_data()[__pos], __c)) return __pos; return npos; }

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const { ; size_type __size = this→size(); if (__size) { if (—__size > __pos) __size = __pos; do { if (!traits_type::find(__s, __n, _M_data()[__size])) return __size; } while (__size—); } return npos; }

template<typename _CharT, typename _Traits, typename _Alloc> typename basic_string<_CharT, _Traits, _Alloc>::size_type basic_string<_CharT, _Traits, _Alloc>:: find_last_not_of(_CharT __c, size_type __pos) const { size_type __size = this→size(); if (__size) { if (—__size > __pos) __size = __pos; do { if (!traits_type::eq(_M_data()[__size], __c)) return __size; } while (__size—); } return npos; }

template<typename _CharT, typename _Traits, typename _Alloc> int basic_string<_CharT, _Traits, _Alloc>:: compare(size_type __pos, size_type __n, const basic_string& __str) const { _M_check(__pos, “basic_string::compare”); __n = _M_limit(__pos, __n); const size_type __osize = __str.size(); const size_type __len = std::min(__n, __osize); int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); if (!__r) __r = _S_compare(__n, __osize); return __r; }

template<typename _CharT, typename _Traits, typename _Alloc> int basic_string<_CharT, _Traits, _Alloc>:: compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) const { _M_check(__pos1, “basic_string::compare”); __str._M_check(__pos2, “basic_string::compare”); __n1 = _M_limit(__pos1, __n1); __n2 = __str._M_limit(__pos2, __n2); const size_type __len = std::min(__n1, __n2); int __r = traits_type::compare(_M_data() + __pos1, __str.data() + __pos2, __len); if (!__r) __r = _S_compare(__n1, __n2); return __r; }

template<typename _CharT, typename _Traits, typename _Alloc> int basic_string<_CharT, _Traits, _Alloc>:: compare(const _CharT* __s) const { ; const size_type __size = this→size(); const size_type __osize = traits_type::length(__s); const size_type __len = std::min(__size, __osize); int __r = traits_type::compare(_M_data(), __s, __len); if (!__r) __r = _S_compare(__size, __osize); return __r; }

template<typename _CharT, typename _Traits, typename _Alloc> int basic_string <_CharT, _Traits, _Alloc>:: compare(size_type __pos, size_type __n1, const _CharT* __s) const { ; _M_check(__pos, “basic_string::compare”); __n1 = _M_limit(__pos, __n1); const size_type __osize = traits_type::length(__s); const size_type __len = std::min(__n1, __osize); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = _S_compare(__n1, __osize); return __r; }

template<typename _CharT, typename _Traits, typename _Alloc> int basic_string <_CharT, _Traits, _Alloc>:: compare(size_type __pos, size_type __n1, const _CharT* __s, size_type __n2) const { ; _M_check(__pos, “basic_string::compare”); __n1 = _M_limit(__pos, __n1); const size_type __len = std::min(__n1, __n2); int __r = traits_type::compare(_M_data() + __pos, __s, __len); if (!__r) __r = _S_compare(__n1, __n2); return __r; }

template<typename _CharT, typename _Traits, typename _Alloc> basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, basic_string<_CharT, _Traits, _Alloc>& __str) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __istream_type::ios_base __ios_base; typedef typename __istream_type::int_type __int_type; typedef typename __string_type::size_type __size_type; typedef ctype<_CharT> __ctype_type; typedef typename __ctype_type::ctype_base __ctype_base;

  __size_type __extracted = 0;
  typename __ios_base::iostate __err = __ios_base::goodbit;
  typename __istream_type::sentry __cerb(__in, false);
  if (__cerb)

{ try {

   __str.erase();
   _CharT __buf[128];
   __size_type __len = 0;
   const streamsize __w = __in.width();
   const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
                            : __str.max_size();
   const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
   const __int_type __eof = _Traits::eof();
   __int_type __c = __in.rdbuf()->sgetc();

   while (__extracted < __n
   && !_Traits::eq_int_type(__c, __eof)
   && !__ct.is(__ctype_base::space,
 _Traits::to_char_type(__c)))

{ if (__len == sizeof(__buf) / sizeof(_CharT)) { __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); __len = 0; } __buf[__len++] = _Traits::to_char_type(__c); ++__extracted; __c = __in.rdbuf()→snextc(); } __str.append(__buf, __len);

   if (_Traits::eq_int_type(__c, __eof))

__err |= __ios_base::eofbit; __in.width(0); } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(__ios_base::badbit); throw; } catch(…) {

   __in._M_setstate(__ios_base::badbit);
 }

}

  if (!__extracted)

__err |= __ios_base::failbit; if (__err) __in.setstate(__err); return __in; }

template<typename _CharT, typename _Traits, typename _Alloc> basic_istream<_CharT, _Traits>& getline(basic_istream<_CharT, _Traits>& __in, basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_string<_CharT, _Traits, _Alloc> __string_type; typedef typename __istream_type::ios_base __ios_base; typedef typename __istream_type::int_type __int_type; typedef typename __string_type::size_type __size_type;

  __size_type __extracted = 0;
  const __size_type __n = __str.max_size();
  typename __ios_base::iostate __err = __ios_base::goodbit;
  typename __istream_type::sentry __cerb(__in, true);
  if (__cerb)

{ try { __str.erase(); const __int_type __idelim = _Traits::to_int_type(__delim); const __int_type __eof = _Traits::eof(); __int_type __c = __in.rdbuf()→sgetc();

   while (__extracted < __n
   && !_Traits::eq_int_type(__c, __eof)
   && !_Traits::eq_int_type(__c, __idelim))

{ __str += _Traits::to_char_type(__c); ++__extracted; __c = __in.rdbuf()→snextc(); }

   if (_Traits::eq_int_type(__c, __eof))

__err |= __ios_base::eofbit; else if (_Traits::eq_int_type(__c, __idelim)) { ++__extracted; __in.rdbuf()→sbumpc(); } else __err |= __ios_base::failbit; } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(__ios_base::badbit); throw; } catch(…) {

   __in._M_setstate(__ios_base::badbit);
 }

} if (!__extracted) __err |= __ios_base::failbit; if (__err) __in.setstate(__err); return __in; }

extern template class basic_string; extern template basic_istream& operator>>(basic_istream&, string&); extern template basic_ostream& operator<<(basic_ostream&, const string&); extern template basic_istream& getline(basic_istream&, string&, char); extern template basic_istream& getline(basic_istream&, string&);

extern template class basic_string<wchar_t>; extern template basic_istream<wchar_t>& operator>>(basic_istream<wchar_t>&, wstring&); extern template basic_ostream<wchar_t>& operator<<(basic_ostream<wchar_t>&, const wstring&); extern template basic_istream<wchar_t>& getline(basic_istream<wchar_t>&, wstring&, wchar_t); extern template basic_istream<wchar_t>& getline(basic_istream<wchar_t>&, wstring&);

}

54 “/usr/include/c++/5/string” 2 3

41 “/usr/include/c++/5/bits/locale_classes.h” 2 3

namespace std attribute ((visibility (“default”))) {

62 “/usr/include/c++/5/bits/locale_classes.h” 3

class locale { public:

typedef int category;


class facet;
class id;
class _Impl;

friend class facet;
friend class _Impl;

template<typename _Facet>
  friend bool
  has_facet(const locale&) throw();

template<typename _Facet>
  friend const _Facet&
  use_facet(const locale&);

template<typename _Cache>
  friend struct __use_cache;

98 “/usr/include/c++/5/bits/locale_classes.h” 3

static const category none = 0;
static const category ctype = 1L << 0;
static const category numeric = 1L << 1;
static const category collate = 1L << 2;
static const category time = 1L << 3;
static const category monetary = 1L << 4;
static const category messages = 1L << 5;
static const category all = (ctype | numeric | collate |
    time | monetary | messages);

117 “/usr/include/c++/5/bits/locale_classes.h” 3

locale() throw();

126 “/usr/include/c++/5/bits/locale_classes.h” 3

locale(const locale& __other) throw();

136 “/usr/include/c++/5/bits/locale_classes.h” 3

explicit
locale(const char* __s);

151 “/usr/include/c++/5/bits/locale_classes.h” 3

locale(const locale& __base, const char* __s, category __cat);

192 “/usr/include/c++/5/bits/locale_classes.h” 3

locale(const locale& __base, const locale& __add, category __cat);

205 “/usr/include/c++/5/bits/locale_classes.h” 3

template<typename _Facet>
  locale(const locale& __other, _Facet* __f);


~locale() throw();

219 “/usr/include/c++/5/bits/locale_classes.h” 3

const locale&
operator=(const locale& __other) throw();

234 “/usr/include/c++/5/bits/locale_classes.h” 3

template<typename _Facet>
  locale
  combine(const locale& __other) const;






__attribute ((__abi_tag__ ("cxx11")))
string
name() const;

254 “/usr/include/c++/5/bits/locale_classes.h” 3

bool
operator==(const locale& __other) const throw();







bool
operator!=(const locale& __other) const throw()
{ return !(this->operator==(__other)); }

282 “/usr/include/c++/5/bits/locale_classes.h” 3

template<typename _Char, typename _Traits, typename _Alloc>
  bool
  operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,

const basic_string<_Char, _Traits, _Alloc>& __s2) const;

298 “/usr/include/c++/5/bits/locale_classes.h” 3

static locale
global(const locale& __loc);




static const locale&
classic();

private:

_Impl* _M_impl;


static _Impl* _S_classic;


static _Impl* _S_global;





static const char* const* const _S_categories;

333 “/usr/include/c++/5/bits/locale_classes.h” 3

enum { _S_categories_size = 6 + 6 };


static __gthread_once_t _S_once;


explicit
locale(_Impl*) throw();

static void
_S_initialize();

static void
_S_initialize_once() throw();

static category
_S_normalize_category(category);

void
_M_coalesce(const locale& __base, const locale& __add, category __cat);


static const id* const _S_twinned_facets[];

};

371 “/usr/include/c++/5/bits/locale_classes.h” 3

class locale::facet { private: friend class locale; friend class locale::_Impl;

mutable _Atomic_word _M_refcount;


static __c_locale _S_c_locale;


static const char _S_c_name[2];


static __gthread_once_t _S_once;


static void
_S_initialize_once();

protected:

402 “/usr/include/c++/5/bits/locale_classes.h” 3

explicit
facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
{ }


virtual
~facet();

static void
_S_create_c_locale(__c_locale& __cloc, const char* __s,
     __c_locale __old = 0);

static __c_locale
_S_clone_c_locale(__c_locale& __cloc) throw();

static void
_S_destroy_c_locale(__c_locale& __cloc);

static __c_locale
_S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);



static __c_locale
_S_get_c_locale();

__attribute__ ((__const__)) static const char*
_S_get_c_name() throw();

private: void _M_add_reference() const throw() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

void
_M_remove_reference() const throw()
{

  ;
  if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)

{ ; try { delete this; } catch(…) { } } }

facet(const facet&);

facet&
operator=(const facet&);

class __shim;

const facet* _M_sso_shim(const id*) const;
const facet* _M_cow_shim(const id*) const;

};

474 “/usr/include/c++/5/bits/locale_classes.h” 3

class locale::id { private: friend class locale; friend class locale::_Impl;

template<typename _Facet>
  friend const _Facet&
  use_facet(const locale&);

template<typename _Facet>
  friend bool
  has_facet(const locale&) throw();




mutable size_t _M_index;


static _Atomic_word _S_refcount;

void
operator=(const id&);

id(const id&);

public:

id() { }

size_t
_M_id() const throw();

};

class locale::_Impl { public:

friend class locale;
friend class locale::facet;

template<typename _Facet>
  friend bool
  has_facet(const locale&) throw();

template<typename _Facet>
  friend const _Facet&
  use_facet(const locale&);

template<typename _Cache>
  friend struct __use_cache;

private:

_Atomic_word _M_refcount;
const facet** _M_facets;
size_t _M_facets_size;
const facet** _M_caches;
char** _M_names;
static const locale::id* const _S_id_ctype[];
static const locale::id* const _S_id_numeric[];
static const locale::id* const _S_id_collate[];
static const locale::id* const _S_id_time[];
static const locale::id* const _S_id_monetary[];
static const locale::id* const _S_id_messages[];
static const locale::id* const* const _S_facet_categories[];

void
_M_add_reference() throw()
{ __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

void
_M_remove_reference() throw()
{

  ;
  if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)

{ ; try { delete this; } catch(…) { } } }

_Impl(const _Impl&, size_t);
_Impl(const char*, size_t);
_Impl(size_t) throw();

~_Impl() throw();

_Impl(const _Impl&);

void
operator=(const _Impl&);

bool
_M_check_same_name()
{
  bool __ret = true;
  if (_M_names[1])

for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i) __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0; return __ret; }

void
_M_replace_categories(const _Impl*, category);

void
_M_replace_category(const _Impl*, const locale::id* const*);

void
_M_replace_facet(const _Impl*, const locale::id*);

void
_M_install_facet(const locale::id*, const facet*);

template<typename _Facet>
  void
  _M_init_facet(_Facet* __facet)
  { _M_install_facet(&_Facet::id, __facet); }

template<typename _Facet>
  void
  _M_init_facet_unchecked(_Facet* __facet)
  {

__facet→_M_add_reference(); _M_facets[_Facet::id._M_id()] = __facet; }

void
_M_install_cache(const facet*, size_t);

void _M_init_extra(facet**);
void _M_init_extra(void*, void*, const char*, const char*);

};

632 “/usr/include/c++/5/bits/locale_classes.h” 3

template class __cxx11:: collate : public locale::facet { public:

  typedef _CharT char_type;
  typedef basic_string<_CharT> string_type;


protected:


  __c_locale _M_c_locale_collate;

public:

  static locale::id id;

659 “/usr/include/c++/5/bits/locale_classes.h” 3

  explicit
  collate(size_t __refs = 0)
  : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
  { }

673 “/usr/include/c++/5/bits/locale_classes.h” 3

  explicit
  collate(__c_locale __cloc, size_t __refs = 0)
  : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
  { }

690 “/usr/include/c++/5/bits/locale_classes.h” 3

  int
  compare(const _CharT* __lo1, const _CharT* __hi1,
   const _CharT* __lo2, const _CharT* __hi2) const
  { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }

709 “/usr/include/c++/5/bits/locale_classes.h” 3

  string_type
  transform(const _CharT* __lo, const _CharT* __hi) const
  { return this->do_transform(__lo, __hi); }

723 “/usr/include/c++/5/bits/locale_classes.h” 3

  long
  hash(const _CharT* __lo, const _CharT* __hi) const
  { return this->do_hash(__lo, __hi); }


  int
  _M_compare(const _CharT*, const _CharT*) const throw();

  size_t
  _M_transform(_CharT*, const _CharT*, size_t) const throw();

protected:

  virtual
  ~collate()
  { _S_destroy_c_locale(_M_c_locale_collate); }

752 “/usr/include/c++/5/bits/locale_classes.h” 3

  virtual int
  do_compare(const _CharT* __lo1, const _CharT* __hi1,

const _CharT* __lo2, const _CharT* __hi2) const;

766 “/usr/include/c++/5/bits/locale_classes.h” 3

  virtual string_type
  do_transform(const _CharT* __lo, const _CharT* __hi) const;

779 “/usr/include/c++/5/bits/locale_classes.h” 3

  virtual long
  do_hash(const _CharT* __lo, const _CharT* __hi) const;
};

template locale::id collate<_CharT>::id;

template<> int collate::_M_compare(const char*, const char*) const throw();

template<> size_t collate::_M_transform(char*, const char*, size_t) const throw();

template<> int collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();

template<> size_t collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();

template class __cxx11:: collate_byname : public collate<_CharT> { public:

  typedef _CharT char_type;
  typedef basic_string<_CharT> string_type;


  explicit
  collate_byname(const char* __s, size_t __refs = 0)
  : collate<_CharT>(__refs)
  {

if (__builtin_strcmp(__s, “C”) != 0 && __builtin_strcmp(__s, “POSIX”) != 0) { this→_S_destroy_c_locale(this→_M_c_locale_collate); this→_S_create_c_locale(this→_M_c_locale_collate, __s); } }

protected:
  virtual
  ~collate_byname() { }
};

}

1 “/usr/include/c++/5/bits/locale_classes.tcc” 1 3

37 “/usr/include/c++/5/bits/locale_classes.tcc” 3

38 “/usr/include/c++/5/bits/locale_classes.tcc” 3

namespace std attribute ((visibility (“default”))) {

template locale:: locale(const locale& __other, _Facet* __f) { _M_impl = new _Impl(*__other._M_impl, 1);

try

{ _M_impl→_M_install_facet(&_Facet::id, __f); } catch(…) { _M_impl→_M_remove_reference(); throw; } delete [] _M_impl→_M_names[0]; _M_impl→_M_names[0] = 0; }

template locale locale:: combine(const locale& __other) const { _Impl* __tmp = new _Impl(*_M_impl, 1); try { __tmp→_M_replace_facet(__other._M_impl, &_Facet::id); } catch(…) { __tmp→_M_remove_reference(); throw; } return locale(__tmp); }

template<typename _CharT, typename _Traits, typename _Alloc> bool locale:: operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1, const basic_string<_CharT, _Traits, _Alloc>& __s2) const { typedef std::collate<_CharT> __collate_type; const __collate_type& __collate = use_facet<__collate_type>(*this); return (__collate.compare(__s1.data(), __s1.data() + __s1.length(), __s2.data(), __s2.data() + __s2.length()) < 0); }

102 “/usr/include/c++/5/bits/locale_classes.tcc” 3

template bool has_facet(const locale& __loc) throw() { const size_t __i = _Facet::id._M_id(); const locale::facet** __facets = __loc._M_impl→_M_facets; return (__i < __loc._M_impl→_M_facets_size

   && dynamic_cast<const _Facet*>(__facets[__i]));



}

130 “/usr/include/c++/5/bits/locale_classes.tcc” 3

template const _Facet& use_facet(const locale& __loc) { const size_t __i = _Facet::id._M_id(); const locale::facet** __facets = __loc._M_impl→_M_facets; if (__i >= __loc._M_impl→_M_facets_size || !__facets[__i]) __throw_bad_cast();

  return dynamic_cast<const _Facet&>(*__facets[__i]);



}

template int collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw () { return 0; }

template size_t collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw () { return 0; }

template int collate<_CharT>:: do_compare(const _CharT* __lo1, const _CharT* __hi1, const _CharT* __lo2, const _CharT* __hi2) const {

  const string_type __one(__lo1, __hi1);
  const string_type __two(__lo2, __hi2);

  const _CharT* __p = __one.c_str();
  const _CharT* __pend = __one.data() + __one.length();
  const _CharT* __q = __two.c_str();
  const _CharT* __qend = __two.data() + __two.length();




  for (;;)

{ const int __res = _M_compare(__p, __q); if (__res) return __res;

__p += char_traits<_CharT>::length(__p); __q += char_traits<_CharT>::length(__q); if (__p __pend && __q __qend) return 0; else if (__p __pend) return -1; else if (__q __qend) return 1;

__p++; __q++; } }

template typename collate<_CharT>::string_type collate<_CharT>:: do_transform(const _CharT* __lo, const _CharT* __hi) const { string_type __ret;

  const string_type __str(__lo, __hi);

  const _CharT* __p = __str.c_str();
  const _CharT* __pend = __str.data() + __str.length();

  size_t __len = (__hi - __lo) * 2;

  _CharT* __c = new _CharT[__len];

  try

{

for (;;) {

   size_t __res = _M_transform(__c, __p, __len);


   if (__res >= __len)

{ __len = __res + 1; delete [] __c, __c = 0; __c = new _CharT[__len]; __res = _M_transform(__c, __p, __len); }

   __ret.append(__c, __res);
   __p += char_traits<_CharT>::length(__p);
   if (__p == __pend)

break;

   __p++;
   __ret.push_back(_CharT());
 }

} catch(…) { delete [] __c; throw; }

  delete [] __c;

  return __ret;
}

template long collate<_CharT>:: do_hash(const _CharT* __lo, const _CharT* __hi) const { unsigned long __val = 0; for (; __lo < __hi; ++__lo) __val = *__lo + ((__val << 7) | (__val >> (__gnu_cxx::__numeric_traits:: __digits - 7))); return static_cast(__val); }

extern template class collate; extern template class collate_byname;

extern template const collate& use_facet<collate >(const locale&);

extern template bool has_facet<collate >(const locale&);

extern template class collate<wchar_t>; extern template class collate_byname<wchar_t>;

extern template const collate<wchar_t>& use_facet<collate<wchar_t> >(const locale&);

extern template bool has_facet<collate<wchar_t> >(const locale&);

}

843 “/usr/include/c++/5/bits/locale_classes.h” 2 3

42 “/usr/include/c++/5/bits/ios_base.h” 2 3

1 “/usr/include/c++/5/stdexcept” 1 3

36 “/usr/include/c++/5/stdexcept” 3

37 “/usr/include/c++/5/stdexcept” 3

namespace std attribute ((visibility (“default”))) {

struct __cow_string { union { const char* _M_p; char _M_bytes[sizeof(const char*)]; };

__cow_string();
__cow_string(const std::string&);
__cow_string(const char*, size_t);
__cow_string(const __cow_string&) throw();
__cow_string& operator=(const __cow_string&) throw();
~__cow_string();

};

typedef basic_string __sso_string;

113 “/usr/include/c++/5/stdexcept” 3

class logic_error : public exception { __cow_string _M_msg;

public:

explicit
logic_error(const string& __arg);







logic_error(const logic_error&) throw();
logic_error& operator=(const logic_error&) throw();


virtual ~logic_error() throw();



virtual const char*
what() const throw();

};

class domain_error : public logic_error { public: explicit domain_error(const string& __arg);

virtual ~domain_error() throw();

};

class invalid_argument : public logic_error { public: explicit invalid_argument(const string& __arg);

virtual ~invalid_argument() throw();

};

class length_error : public logic_error { public: explicit length_error(const string& __arg);

virtual ~length_error() throw();

};

class out_of_range : public logic_error { public: explicit out_of_range(const string& __arg);

virtual ~out_of_range() throw();

};

class runtime_error : public exception { __cow_string _M_msg;

public:

explicit
runtime_error(const string& __arg);







runtime_error(const runtime_error&) throw();
runtime_error& operator=(const runtime_error&) throw();


virtual ~runtime_error() throw();



virtual const char*
what() const throw();

};

class range_error : public runtime_error { public: explicit range_error(const string& __arg);

virtual ~range_error() throw();

};

class overflow_error : public runtime_error { public: explicit overflow_error(const string& __arg);

virtual ~overflow_error() throw();

};

class underflow_error : public runtime_error { public: explicit underflow_error(const string& __arg);

virtual ~underflow_error() throw();

};

}

45 “/usr/include/c++/5/bits/ios_base.h” 2 3

namespace std attribute ((visibility (“default”))) {

enum _Ios_Fmtflags { _S_boolalpha = 1L << 0, _S_dec = 1L << 1, _S_fixed = 1L << 2, _S_hex = 1L << 3, _S_internal = 1L << 4, _S_left = 1L << 5, _S_oct = 1L << 6, _S_right = 1L << 7, _S_scientific = 1L << 8, _S_showbase = 1L << 9, _S_showpoint = 1L << 10, _S_showpos = 1L << 11, _S_skipws = 1L << 12, _S_unitbuf = 1L << 13, _S_uppercase = 1L << 14, _S_adjustfield = _S_left | _S_right | _S_internal, _S_basefield = _S_dec | _S_oct | _S_hex, _S_floatfield = _S_scientific | _S_fixed, _S_ios_fmtflags_end = 1L << 16, _S_ios_fmtflags_max = 0x7fffffff, _S_ios_fmtflags_min = ~0x7fffffff };

inline _Ios_Fmtflags operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); }

inline _Ios_Fmtflags operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); }

inline _Ios_Fmtflags operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); }

inline _Ios_Fmtflags operator~(_Ios_Fmtflags __a) { return _Ios_Fmtflags(~static_cast(__a)); }

inline const _Ios_Fmtflags& operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) { return __a = __a | __b; }

inline const _Ios_Fmtflags& operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) { return __a = __a & __b; }

inline const _Ios_Fmtflags& operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) { return __a = __a ^ __b; }

enum _Ios_Openmode { _S_app = 1L << 0, _S_ate = 1L << 1, _S_bin = 1L << 2, _S_in = 1L << 3, _S_out = 1L << 4, _S_trunc = 1L << 5, _S_ios_openmode_end = 1L << 16, _S_ios_openmode_max = 0x7fffffff, _S_ios_openmode_min = ~0x7fffffff };

inline _Ios_Openmode operator&(_Ios_Openmode __a, _Ios_Openmode __b) { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); }

inline _Ios_Openmode operator|(_Ios_Openmode __a, _Ios_Openmode __b) { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); }

inline _Ios_Openmode operator^(_Ios_Openmode __a, _Ios_Openmode __b) { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); }

inline _Ios_Openmode operator~(_Ios_Openmode __a) { return _Ios_Openmode(~static_cast(__a)); }

inline const _Ios_Openmode& operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) { return __a = __a | __b; }

inline const _Ios_Openmode& operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) { return __a = __a & __b; }

inline const _Ios_Openmode& operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) { return __a = __a ^ __b; }

enum _Ios_Iostate { _S_goodbit = 0, _S_badbit = 1L << 0, _S_eofbit = 1L << 1, _S_failbit = 1L << 2, _S_ios_iostate_end = 1L << 16, _S_ios_iostate_max = 0x7fffffff, _S_ios_iostate_min = ~0x7fffffff };

inline _Ios_Iostate operator&(_Ios_Iostate __a, _Ios_Iostate __b) { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); }

inline _Ios_Iostate operator|(_Ios_Iostate __a, _Ios_Iostate __b) { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); }

inline _Ios_Iostate operator^(_Ios_Iostate __a, _Ios_Iostate __b) { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); }

inline _Ios_Iostate operator~(_Ios_Iostate __a) { return _Ios_Iostate(~static_cast(__a)); }

inline const _Ios_Iostate& operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) { return __a = __a | __b; }

inline const _Ios_Iostate& operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) { return __a = __a & __b; }

inline const _Ios_Iostate& operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) { return __a = __a ^ __b; }

enum _Ios_Seekdir { _S_beg = 0, _S_cur = 1, _S_end = 2, _S_ios_seekdir_end = 1L << 16 };

228 “/usr/include/c++/5/bits/ios_base.h” 3

class ios_base {

struct system_error : std::runtime_error
{

  struct error_code
  {

error_code() { } private: int _M_value; const void* _M_cat; } _M_code; };

public:

255 “/usr/include/c++/5/bits/ios_base.h” 3

class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
{
public:
  explicit
  failure(const string& __str);

269 “/usr/include/c++/5/bits/ios_base.h” 3

  virtual
  ~failure() throw();

  virtual const char*
  what() const throw();
};

323 “/usr/include/c++/5/bits/ios_base.h” 3

typedef _Ios_Fmtflags fmtflags;


static const fmtflags boolalpha = _S_boolalpha;


static const fmtflags dec = _S_dec;


static const fmtflags fixed = _S_fixed;


static const fmtflags hex = _S_hex;




static const fmtflags internal = _S_internal;



static const fmtflags left = _S_left;


static const fmtflags oct = _S_oct;



static const fmtflags right = _S_right;


static const fmtflags scientific = _S_scientific;



static const fmtflags showbase = _S_showbase;



static const fmtflags showpoint = _S_showpoint;


static const fmtflags showpos = _S_showpos;


static const fmtflags skipws = _S_skipws;


static const fmtflags unitbuf = _S_unitbuf;



static const fmtflags uppercase = _S_uppercase;


static const fmtflags adjustfield = _S_adjustfield;


static const fmtflags basefield = _S_basefield;


static const fmtflags floatfield = _S_floatfield;

398 “/usr/include/c++/5/bits/ios_base.h” 3

typedef _Ios_Iostate iostate;



static const iostate badbit = _S_badbit;


static const iostate eofbit = _S_eofbit;




static const iostate failbit = _S_failbit;


static const iostate goodbit = _S_goodbit;

429 “/usr/include/c++/5/bits/ios_base.h” 3

typedef _Ios_Openmode openmode;


static const openmode app = _S_app;


static const openmode ate = _S_ate;




static const openmode binary = _S_bin;


static const openmode in = _S_in;


static const openmode out = _S_out;


static const openmode trunc = _S_trunc;

461 “/usr/include/c++/5/bits/ios_base.h” 3

typedef _Ios_Seekdir seekdir;


static const seekdir beg = _S_beg;


static const seekdir cur = _S_cur;


static const seekdir end = _S_end;


typedef int io_state;
typedef int open_mode;
typedef int seek_dir;

typedef std::streampos streampos;
typedef std::streamoff streamoff;

487 “/usr/include/c++/5/bits/ios_base.h” 3

enum event
{
  erase_event,
  imbue_event,
  copyfmt_event
};

504 “/usr/include/c++/5/bits/ios_base.h” 3

typedef void (*event_callback) (event __e, ios_base& __b, int __i);

516 “/usr/include/c++/5/bits/ios_base.h” 3

void
register_callback(event_callback __fn, int __index);

protected: streamsize _M_precision; streamsize _M_width; fmtflags _M_flags; iostate _M_exception; iostate _M_streambuf_state;

struct _Callback_list
{

  _Callback_list* _M_next;
  ios_base::event_callback _M_fn;
  int _M_index;
  _Atomic_word _M_refcount;

  _Callback_list(ios_base::event_callback __fn, int __index,
   _Callback_list* __cb)
  : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

  void
  _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }


  int
  _M_remove_reference()
  {

    ;
    int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
    if (__res == 0)
      {
        ;
      }
    return __res;
  }
};

 _Callback_list* _M_callbacks;

void
_M_call_callbacks(event __ev) throw();

void
_M_dispose_callbacks(void) throw();


struct _Words
{
  void* _M_pword;
  long _M_iword;
  _Words() : _M_pword(0), _M_iword(0) { }
};


_Words _M_word_zero;



enum { _S_local_word_size = 8 };
_Words _M_local_word[_S_local_word_size];


int _M_word_size;
_Words* _M_word;

_Words&
_M_grow_words(int __index, bool __iword);


locale _M_ios_locale;

void
_M_init() throw();

public:

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

private:
  static _Atomic_word _S_refcount;
  static bool _S_synced_with_stdio;
};






fmtflags
flags() const
{ return _M_flags; }

629 “/usr/include/c++/5/bits/ios_base.h” 3

fmtflags
flags(fmtflags __fmtfl)
{
  fmtflags __old = _M_flags;
  _M_flags = __fmtfl;
  return __old;
}

645 “/usr/include/c++/5/bits/ios_base.h” 3

fmtflags
setf(fmtflags __fmtfl)
{
  fmtflags __old = _M_flags;
  _M_flags |= __fmtfl;
  return __old;
}

662 “/usr/include/c++/5/bits/ios_base.h” 3

fmtflags
setf(fmtflags __fmtfl, fmtflags __mask)
{
  fmtflags __old = _M_flags;
  _M_flags &= ~__mask;
  _M_flags |= (__fmtfl & __mask);
  return __old;
}







void
unsetf(fmtflags __mask)
{ _M_flags &= ~__mask; }

688 “/usr/include/c++/5/bits/ios_base.h” 3

streamsize
precision() const
{ return _M_precision; }






streamsize
precision(streamsize __prec)
{
  streamsize __old = _M_precision;
  _M_precision = __prec;
  return __old;
}







streamsize
width() const
{ return _M_width; }






streamsize
width(streamsize __wide)
{
  streamsize __old = _M_width;
  _M_width = __wide;
  return __old;
}

739 “/usr/include/c++/5/bits/ios_base.h” 3

static bool
sync_with_stdio(bool __sync = true);

751 “/usr/include/c++/5/bits/ios_base.h” 3

locale
imbue(const locale& __loc) throw();

762 “/usr/include/c++/5/bits/ios_base.h” 3

locale
getloc() const
{ return _M_ios_locale; }

773 “/usr/include/c++/5/bits/ios_base.h” 3

const locale&
_M_getloc() const
{ return _M_ios_locale; }

792 “/usr/include/c++/5/bits/ios_base.h” 3

static int
xalloc() throw();

808 “/usr/include/c++/5/bits/ios_base.h” 3

long&
iword(int __ix)
{
  _Words& __word = (__ix < _M_word_size)

? _M_word[__ix] : _M_grow_words(__ix, true); return __word._M_iword; }

829 “/usr/include/c++/5/bits/ios_base.h” 3

void*&
pword(int __ix)
{
  _Words& __word = (__ix < _M_word_size)

? _M_word[__ix] : _M_grow_words(__ix, false); return __word._M_pword; }

846 “/usr/include/c++/5/bits/ios_base.h” 3

virtual ~ios_base();

protected: ios_base() throw ();

private: ios_base(const ios_base&);

ios_base&
operator=(const ios_base&);

873 “/usr/include/c++/5/bits/ios_base.h” 3

};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1076 “/usr/include/c++/5/bits/ios_base.h” 3

}

43 “/usr/include/c++/5/ios” 2 3

1 “/usr/include/c++/5/streambuf” 1 3

36 “/usr/include/c++/5/streambuf” 3

37 “/usr/include/c++/5/streambuf” 3

45 “/usr/include/c++/5/streambuf” 3

namespace std attribute ((visibility (“default”))) {

template<typename _CharT, typename _Traits> streamsize __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>, basic_streambuf<_CharT, _Traits>, bool&);

119 “/usr/include/c++/5/streambuf” 3

template<typename _CharT, typename _Traits> class basic_streambuf { public:

  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;




  typedef basic_streambuf<char_type, traits_type> __streambuf_type;


  friend class basic_ios<char_type, traits_type>;
  friend class basic_istream<char_type, traits_type>;
  friend class basic_ostream<char_type, traits_type>;
  friend class istreambuf_iterator<char_type, traits_type>;
  friend class ostreambuf_iterator<char_type, traits_type>;

  friend streamsize
  __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);

  template<bool _IsMove, typename _CharT2>
    friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        _CharT2*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT2>,
     istreambuf_iterator<_CharT2>, _CharT2*);

  template<typename _CharT2>
    friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
  istreambuf_iterator<_CharT2> >::__type
    find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
  const _CharT2&);

  template<typename _CharT2, typename _Traits2>
    friend basic_istream<_CharT2, _Traits2>&
    operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);

  template<typename _CharT2, typename _Traits2, typename _Alloc>
    friend basic_istream<_CharT2, _Traits2>&
    operator>>(basic_istream<_CharT2, _Traits2>&,
 basic_string<_CharT2, _Traits2, _Alloc>&);

  template<typename _CharT2, typename _Traits2, typename _Alloc>
    friend basic_istream<_CharT2, _Traits2>&
    getline(basic_istream<_CharT2, _Traits2>&,

basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);

protected:







  char_type* _M_in_beg;
  char_type* _M_in_cur;
  char_type* _M_in_end;
  char_type* _M_out_beg;
  char_type* _M_out_cur;
  char_type* _M_out_end;


  locale _M_buf_locale;

public:

  virtual
  ~basic_streambuf()
  { }

208 “/usr/include/c++/5/streambuf” 3

  locale
  pubimbue(const locale& __loc)
  {

locale __tmp(this→getloc()); this→imbue(__loc); _M_buf_locale = __loc; return __tmp; }

225 “/usr/include/c++/5/streambuf” 3

  locale
  getloc() const
  { return _M_buf_locale; }

238 “/usr/include/c++/5/streambuf” 3

  basic_streambuf*
  pubsetbuf(char_type* __s, streamsize __n)
  { return this->setbuf(__s, __n); }

250 “/usr/include/c++/5/streambuf” 3

  pos_type
  pubseekoff(off_type __off, ios_base::seekdir __way,

ios_base::openmode __mode = ios_base::in | ios_base::out) { return this→seekoff(__off, __way, __mode); }

262 “/usr/include/c++/5/streambuf” 3

  pos_type
  pubseekpos(pos_type __sp,

ios_base::openmode __mode = ios_base::in | ios_base::out) { return this→seekpos(__sp, __mode); }

  int
  pubsync() { return this->sync(); }

283 “/usr/include/c++/5/streambuf” 3

  streamsize
  in_avail()
  {

const streamsize __ret = this→egptr() - this→gptr(); return __ret ? __ret : this→showmanyc(); }

297 “/usr/include/c++/5/streambuf” 3

  int_type
  snextc()
  {

int_type __ret = traits_type::eof(); if (__builtin_expect(!traits_type::eq_int_type(this→sbumpc(), __ret), true)) __ret = this→sgetc(); return __ret; }

315 “/usr/include/c++/5/streambuf” 3

  int_type
  sbumpc()
  {

int_type __ret; if (__builtin_expect(this→gptr() < this→egptr(), true)) { __ret = traits_type::to_int_type(*this→gptr()); this→gbump(1); } else __ret = this→uflow(); return __ret; }

337 “/usr/include/c++/5/streambuf” 3

  int_type
  sgetc()
  {

int_type __ret; if (__builtin_expect(this→gptr() < this→egptr(), true)) __ret = traits_type::to_int_type(*this→gptr()); else __ret = this→underflow(); return __ret; }

356 “/usr/include/c++/5/streambuf” 3

  streamsize
  sgetn(char_type* __s, streamsize __n)
  { return this->xsgetn(__s, __n); }

371 “/usr/include/c++/5/streambuf” 3

  int_type
  sputbackc(char_type __c)
  {

int_type __ret; const bool __testpos = this→eback() < this→gptr(); if (__builtin_expect(!__testpos || !traits_type::eq(__c, this→gptr()[-1]), false)) __ret = this→pbackfail(traits_type::to_int_type(__c)); else { this→gbump(-1); __ret = traits_type::to_int_type(*this→gptr()); } return __ret; }

396 “/usr/include/c++/5/streambuf” 3

  int_type
  sungetc()
  {

int_type __ret; if (__builtin_expect(this→eback() < this→gptr(), true)) { this→gbump(-1); __ret = traits_type::to_int_type(*this→gptr()); } else __ret = this→pbackfail(); return __ret; }

423 “/usr/include/c++/5/streambuf” 3

  int_type
  sputc(char_type __c)
  {

int_type __ret; if (__builtin_expect(this→pptr() < this→epptr(), true)) { *this→pptr() = __c; this→pbump(1); __ret = traits_type::to_int_type(__c); } else __ret = this→overflow(traits_type::to_int_type(__c)); return __ret; }

449 “/usr/include/c++/5/streambuf” 3

  streamsize
  sputn(const char_type* __s, streamsize __n)
  { return this->xsputn(__s, __n); }

protected:

463 “/usr/include/c++/5/streambuf” 3

  basic_streambuf()
  : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
  _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
  _M_buf_locale(locale())
  { }

481 “/usr/include/c++/5/streambuf” 3

  char_type*
  eback() const { return _M_in_beg; }

  char_type*
  gptr() const { return _M_in_cur; }

  char_type*
  egptr() const { return _M_in_end; }

497 “/usr/include/c++/5/streambuf” 3

  void
  gbump(int __n) { _M_in_cur += __n; }

508 “/usr/include/c++/5/streambuf” 3

  void
  setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
  {

_M_in_beg = __gbeg; _M_in_cur = __gnext; _M_in_end = __gend; }

528 “/usr/include/c++/5/streambuf” 3

  char_type*
  pbase() const { return _M_out_beg; }

  char_type*
  pptr() const { return _M_out_cur; }

  char_type*
  epptr() const { return _M_out_end; }

544 “/usr/include/c++/5/streambuf” 3

  void
  pbump(int __n) { _M_out_cur += __n; }

554 “/usr/include/c++/5/streambuf” 3

  void
  setp(char_type* __pbeg, char_type* __pend)
  {

_M_out_beg = _M_out_cur = __pbeg; _M_out_end = __pend; }

575 “/usr/include/c++/5/streambuf” 3

  virtual void
  imbue(const locale& __loc)
  { }

590 “/usr/include/c++/5/streambuf” 3

  virtual basic_streambuf<char_type,_Traits>*
  setbuf(char_type*, streamsize)
  { return this; }

601 “/usr/include/c++/5/streambuf” 3

  virtual pos_type
  seekoff(off_type, ios_base::seekdir,
   ios_base::openmode = ios_base::in | ios_base::out)
  { return pos_type(off_type(-1)); }

613 “/usr/include/c++/5/streambuf” 3

  virtual pos_type
  seekpos(pos_type,
   ios_base::openmode = ios_base::in | ios_base::out)
  { return pos_type(off_type(-1)); }

626 “/usr/include/c++/5/streambuf” 3

  virtual int
  sync() { return 0; }

648 “/usr/include/c++/5/streambuf” 3

  virtual streamsize
  showmanyc() { return 0; }

664 “/usr/include/c++/5/streambuf” 3

  virtual streamsize
  xsgetn(char_type* __s, streamsize __n);

686 “/usr/include/c++/5/streambuf” 3

  virtual int_type
  underflow()
  { return traits_type::eof(); }

699 “/usr/include/c++/5/streambuf” 3

  virtual int_type
  uflow()
  {

int_type __ret = traits_type::eof(); const bool __testeof = traits_type::eq_int_type(this→underflow(), __ret); if (!__testeof) { __ret = traits_type::to_int_type(*this→gptr()); this→gbump(1); } return __ret; }

723 “/usr/include/c++/5/streambuf” 3

  virtual int_type
  pbackfail(int_type __c = traits_type::eof())
  { return traits_type::eof(); }

741 “/usr/include/c++/5/streambuf” 3

  virtual streamsize
  xsputn(const char_type* __s, streamsize __n);

767 “/usr/include/c++/5/streambuf” 3

  virtual int_type
  overflow(int_type __c = traits_type::eof())
  { return traits_type::eof(); }



public:

782 “/usr/include/c++/5/streambuf” 3

  void
  stossc()
  {

if (this→gptr() < this→egptr()) this→gbump(1); else this→uflow(); }

  void
  __safe_gbump(streamsize __n) { _M_in_cur += __n; }

  void
  __safe_pbump(streamsize __n) { _M_out_cur += __n; }


private:



  basic_streambuf(const basic_streambuf&);

  basic_streambuf&
  operator=(const basic_streambuf&);

822 “/usr/include/c++/5/streambuf” 3

};

836 “/usr/include/c++/5/streambuf” 3

template<> streamsize __copy_streambufs_eof(basic_streambuf* __sbin, basic_streambuf* __sbout, bool& __ineof);

template<> streamsize __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin, basic_streambuf<wchar_t>* __sbout, bool& __ineof);

}

1 “/usr/include/c++/5/bits/streambuf.tcc” 1 3

37 “/usr/include/c++/5/bits/streambuf.tcc” 3

38 “/usr/include/c++/5/bits/streambuf.tcc” 3

namespace std attribute ((visibility (“default”))) {

template<typename _CharT, typename _Traits> streamsize basic_streambuf<_CharT, _Traits>:: xsgetn(char_type* __s, streamsize __n) { streamsize __ret = 0; while (__ret < __n) { const streamsize __buf_len = this→egptr() - this→gptr(); if (__buf_len) { const streamsize __remaining = __n - __ret; const streamsize __len = std::min(__buf_len, __remaining); traits_type::copy(__s, this→gptr(), __len); __ret += __len; __s += __len; this→__safe_gbump(__len); }

if (__ret < __n) { const int_type __c = this→uflow(); if (!traits_type::eq_int_type(__c, traits_type::eof())) { traits_type::assign(*__s++, traits_type::to_char_type(__c)); ++__ret; } else break; } } return __ret; }

template<typename _CharT, typename _Traits> streamsize basic_streambuf<_CharT, _Traits>:: xsputn(const char_type* __s, streamsize __n) { streamsize __ret = 0; while (__ret < __n) { const streamsize __buf_len = this→epptr() - this→pptr(); if (__buf_len) { const streamsize __remaining = __n - __ret; const streamsize __len = std::min(__buf_len, __remaining); traits_type::copy(this→pptr(), __s, __len); __ret += __len; __s += __len; this→__safe_pbump(__len); }

if (__ret < __n) { int_type __c = this→overflow(traits_type::to_int_type(*__s)); if (!traits_type::eq_int_type(__c, traits_type::eof())) { ++__ret; ++__s; } else break; } } return __ret; }

template<typename _CharT, typename _Traits> streamsize __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin, basic_streambuf<_CharT, _Traits>* __sbout, bool& __ineof) { streamsize __ret = 0; __ineof = true; typename _Traits::int_type __c = __sbin→sgetc(); while (!_Traits::eq_int_type(__c, _Traits::eof())) { __c = __sbout→sputc(_Traits::to_char_type(__c)); if (_Traits::eq_int_type(__c, _Traits::eof())) { __ineof = false; break; } ++__ret; __c = __sbin→snextc(); } return __ret; }

template<typename _CharT, typename _Traits> inline streamsize __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin, basic_streambuf<_CharT, _Traits>* __sbout) { bool __ineof; return __copy_streambufs_eof(__sbin, __sbout, __ineof); }

extern template class basic_streambuf; extern template streamsize __copy_streambufs(basic_streambuf, basic_streambuf); extern template streamsize __copy_streambufs_eof(basic_streambuf, basic_streambuf, bool&);

extern template class basic_streambuf<wchar_t>; extern template streamsize __copy_streambufs(basic_streambuf<wchar_t>, basic_streambuf<wchar_t>); extern template streamsize __copy_streambufs_eof(basic_streambuf<wchar_t>, basic_streambuf<wchar_t>, bool&);

}

851 “/usr/include/c++/5/streambuf” 2 3

44 “/usr/include/c++/5/ios” 2 3

1 “/usr/include/c++/5/bits/basic_ios.h” 1 3

33 “/usr/include/c++/5/bits/basic_ios.h” 3

34 “/usr/include/c++/5/bits/basic_ios.h” 3

1 “/usr/include/c++/5/bits/locale_facets.h” 1 3

37 “/usr/include/c++/5/bits/locale_facets.h” 3

38 “/usr/include/c++/5/bits/locale_facets.h” 3

1 “/usr/include/c++/5/cwctype” 1 3

39 “/usr/include/c++/5/cwctype” 3

40 “/usr/include/c++/5/cwctype” 3

50 “/usr/include/c++/5/cwctype” 3

1 “/usr/include/wctype.h” 1 3 4

33 “/usr/include/wctype.h” 3 4

1 “/usr/include/wchar.h” 1 3 4

34 “/usr/include/wctype.h” 2 3 4

49 “/usr/include/wctype.h” 3 4

typedef unsigned long int wctype_t;

71 “/usr/include/wctype.h” 3 4

enum { __ISwupper = 0, __ISwlower = 1, __ISwalpha = 2, __ISwdigit = 3, __ISwxdigit = 4, __ISwspace = 5, __ISwprint = 6, __ISwgraph = 7, __ISwblank = 8, __ISwcntrl = 9, __ISwpunct = 10, __ISwalnum = 11,

_ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))), _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))), _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))), _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))), _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))), _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))), _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))), _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))), _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))), _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))), _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))), _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24)))) };

extern “C” {

extern int iswalnum (wint_t __wc) throw ();

extern int iswalpha (wint_t __wc) throw ();

extern int iswcntrl (wint_t __wc) throw ();

extern int iswdigit (wint_t __wc) throw ();

extern int iswgraph (wint_t __wc) throw ();

extern int iswlower (wint_t __wc) throw ();

extern int iswprint (wint_t __wc) throw ();

extern int iswpunct (wint_t __wc) throw ();

extern int iswspace (wint_t __wc) throw ();

extern int iswupper (wint_t __wc) throw ();

extern int iswxdigit (wint_t __wc) throw ();

extern int iswblank (wint_t __wc) throw ();

171 “/usr/include/wctype.h” 3 4

extern wctype_t wctype (const char *__property) throw ();

extern int iswctype (wint_t __wc, wctype_t __desc) throw ();

typedef const __int32_t *wctrans_t;

extern wint_t towlower (wint_t __wc) throw ();

extern wint_t towupper (wint_t __wc) throw ();

}

213 “/usr/include/wctype.h” 3 4

extern “C” {

extern wctrans_t wctrans (const char *__property) throw ();

extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();

extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();

extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();

extern wctype_t wctype_l (const char *__property, __locale_t __locale) throw ();

extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale) throw ();

extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();

extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();

extern wctrans_t wctrans_l (const char *__property, __locale_t __locale) throw ();

extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc, __locale_t __locale) throw ();

}

51 “/usr/include/c++/5/cwctype” 2 3

80 “/usr/include/c++/5/cwctype” 3

namespace std { using ::wctrans_t; using ::wctype_t; using ::wint_t;

using ::iswalnum; using ::iswalpha;

using ::iswblank;

using ::iswcntrl; using ::iswctype; using ::iswdigit; using ::iswgraph; using ::iswlower; using ::iswprint; using ::iswpunct; using ::iswspace; using ::iswupper; using ::iswxdigit; using ::towctrans; using ::towlower; using ::towupper; using ::wctrans; using ::wctype; }

40 “/usr/include/c++/5/bits/locale_facets.h” 2 3

1 “/usr/include/c++/5/cctype” 1 3

39 “/usr/include/c++/5/cctype” 3

40 “/usr/include/c++/5/cctype” 3

41 “/usr/include/c++/5/bits/locale_facets.h” 2 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/ctype_base.h” 1 3

36 “/usr/include/x86_64-linux-gnu/c++/5/bits/ctype_base.h” 3

namespace std attribute ((visibility (“default”))) {

struct ctype_base {

typedef const int* __to_type;



typedef unsigned short mask;
static const mask upper = _ISupper;
static const mask lower = _ISlower;
static const mask alpha = _ISalpha;
static const mask digit = _ISdigit;
static const mask xdigit = _ISxdigit;
static const mask space = _ISspace;
static const mask print = _ISprint;
static const mask graph = _ISalpha | _ISdigit | _ISpunct;
static const mask cntrl = _IScntrl;
static const mask punct = _ISpunct;
static const mask alnum = _ISalpha | _ISdigit;

};

}

42 “/usr/include/c++/5/bits/locale_facets.h” 2 3

1 “/usr/include/c++/5/bits/streambuf_iterator.h” 1 3

33 “/usr/include/c++/5/bits/streambuf_iterator.h” 3

34 “/usr/include/c++/5/bits/streambuf_iterator.h” 3

namespace std attribute ((visibility (“default”))) {

49 “/usr/include/c++/5/bits/streambuf_iterator.h” 3

template<typename _CharT, typename _Traits> class istreambuf_iterator : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type, _CharT*,

    _CharT&>

{
public:



  typedef _CharT char_type;
  typedef _Traits traits_type;
  typedef typename _Traits::int_type int_type;
  typedef basic_streambuf<_CharT, _Traits> streambuf_type;
  typedef basic_istream<_CharT, _Traits> istream_type;


  template<typename _CharT2>

friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, ostreambuf_iterator<_CharT2> >::__type copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, ostreambuf_iterator<_CharT2>);

  template<bool _IsMove, typename _CharT2>

friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, _CharT2*>::__type __copy_move_a2(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, _CharT2*);

  template<typename _CharT2>

friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, istreambuf_iterator<_CharT2> >::__type find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, const _CharT2&);

private:







  mutable streambuf_type* _M_sbuf;
  mutable int_type _M_c;

public:

  istreambuf_iterator() throw()
  : _M_sbuf(0), _M_c(traits_type::eof()) { }

112 “/usr/include/c++/5/bits/streambuf_iterator.h” 3

  istreambuf_iterator(istream_type& __s) throw()
  : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }


  istreambuf_iterator(streambuf_type* __s) throw()
  : _M_sbuf(__s), _M_c(traits_type::eof()) { }




  char_type
  operator*() const
  {

return traits_type::to_char_type(_M_get()); }

  istreambuf_iterator&
  operator++()
  {


                    ;

if (_M_sbuf) { _M_sbuf→sbumpc(); _M_c = traits_type::eof(); } return *this; }

  istreambuf_iterator
  operator++(int)
  {


                    ;

istreambuf_iterator __old = *this; if (_M_sbuf) { __old._M_c = _M_sbuf→sbumpc(); _M_c = traits_type::eof(); } return __old; }

  bool
  equal(const istreambuf_iterator& __b) const
  { return _M_at_eof() == __b._M_at_eof(); }

private:
  int_type
  _M_get() const
  {

const int_type __eof = traits_type::eof(); int_type __ret = __eof; if (_M_sbuf) { if (!traits_type::eq_int_type(_M_c, __eof)) __ret = _M_c; else if (!traits_type::eq_int_type((__ret = _M_sbuf→sgetc()), __eof)) _M_c = __ret; else _M_sbuf = 0; } return __ret; }

  bool
  _M_at_eof() const
  {

const int_type __eof = traits_type::eof(); return traits_type::eq_int_type(_M_get(), __eof); } };

template<typename _CharT, typename _Traits> inline bool operator==(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) { return __a.equal(__b); }

template<typename _CharT, typename _Traits> inline bool operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) { return !__a.equal(__b); }

template<typename _CharT, typename _Traits> class ostreambuf_iterator : public iterator<output_iterator_tag, void, void, void, void> { public:

  typedef _CharT char_type;
  typedef _Traits traits_type;
  typedef basic_streambuf<_CharT, _Traits> streambuf_type;
  typedef basic_ostream<_CharT, _Traits> ostream_type;


  template<typename _CharT2>

private:
  streambuf_type* _M_sbuf;
  bool _M_failed;

public:

  ostreambuf_iterator(ostream_type& __s) throw()
  : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }


  ostreambuf_iterator(streambuf_type* __s) throw()
  : _M_sbuf(__s), _M_failed(!_M_sbuf) { }


  ostreambuf_iterator&
  operator=(_CharT __c)
  {

if (!_M_failed && _Traits::eq_int_type(_M_sbuf→sputc(__c), _Traits::eof())) _M_failed = true; return *this; }

  ostreambuf_iterator&
  operator*()
  { return *this; }


  ostreambuf_iterator&
  operator++(int)
  { return *this; }


  ostreambuf_iterator&
  operator++()
  { return *this; }


  bool
  failed() const throw()
  { return _M_failed; }

  ostreambuf_iterator&
  _M_put(const _CharT* __ws, streamsize __len)
  {

if (__builtin_expect(!_M_failed, true) && __builtin_expect(this→_M_sbuf→sputn(__ws, __len) != __len, false)) _M_failed = true; return *this; } };

template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT> >::__type copy(istreambuf_iterator<_CharT> __first, istreambuf_iterator<_CharT> __last, ostreambuf_iterator<_CharT> __result) { if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed) { bool __ineof; __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof); if (!__ineof) __result._M_failed = true; } return __result; }

template<bool _IsMove, typename _CharT> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT> >::__type __copy_move_a2(_CharT* __first, _CharT* __last, ostreambuf_iterator<_CharT> __result) { const streamsize __num = __last - __first; if (__num > 0) __result._M_put(__first, __num); return __result; }

template<bool _IsMove, typename _CharT> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, ostreambuf_iterator<_CharT> >::__type __copy_move_a2(const _CharT* __first, const _CharT* __last, ostreambuf_iterator<_CharT> __result) { const streamsize __num = __last - __first; if (__num > 0) __result._M_put(__first, __num); return __result; }

template<bool _IsMove, typename _CharT> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, _CharT*>::__type __copy_move_a2(istreambuf_iterator<_CharT> __first, istreambuf_iterator<_CharT> __last, _CharT* __result) { typedef istreambuf_iterator<_CharT> __is_iterator_type; typedef typename __is_iterator_type::traits_type traits_type; typedef typename __is_iterator_type::streambuf_type streambuf_type; typedef typename traits_type::int_type int_type;

  if (__first._M_sbuf && !__last._M_sbuf)

{ streambuf_type* __sb = __first._M_sbuf; int_type __c = __sb→sgetc(); while (!traits_type::eq_int_type(__c, traits_type::eof())) { const streamsize __n = __sb→egptr() - __sb→gptr(); if (__n > 1) { traits_type::copy(__result, __sb→gptr(), __n); __sb→__safe_gbump(__n); __result += __n; __c = __sb→underflow(); } else { *__result++ = traits_type::to_char_type(__c); __c = __sb→snextc(); } } } return __result; }

template typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, istreambuf_iterator<_CharT> >::__type find(istreambuf_iterator<_CharT> __first, istreambuf_iterator<_CharT> __last, const _CharT& __val) { typedef istreambuf_iterator<_CharT> __is_iterator_type; typedef typename __is_iterator_type::traits_type traits_type; typedef typename __is_iterator_type::streambuf_type streambuf_type; typedef typename traits_type::int_type int_type;

  if (__first._M_sbuf && !__last._M_sbuf)

{ const int_type __ival = traits_type::to_int_type(__val); streambuf_type* __sb = __first._M_sbuf; int_type __c = __sb→sgetc(); while (!traits_type::eq_int_type(__c, traits_type::eof()) && !traits_type::eq_int_type(__c, __ival)) { streamsize __n = __sb→egptr() - __sb→gptr(); if (__n > 1) { const _CharT* __p = traits_type::find(__sb→gptr(), __n, __val); if (__p) __n = __p - __sb→gptr(); __sb→__safe_gbump(__n); __c = __sb→sgetc(); } else __c = __sb→snextc(); }

if (!traits_type::eq_int_type(__c, traits_type::eof())) __first._M_c = __c; else __first._M_sbuf = 0; } return __first; }

}

49 “/usr/include/c++/5/bits/locale_facets.h” 2 3

namespace std attribute ((visibility (“default”))) {

71 “/usr/include/c++/5/bits/locale_facets.h” 3

template void __convert_to_v(const char*, _Tp&, ios_base::iostate&, const __c_locale&) throw();

template<> void __convert_to_v(const char*, float&, ios_base::iostate&, const __c_locale&) throw();

template<> void __convert_to_v(const char*, double&, ios_base::iostate&, const __c_locale&) throw();

template<> void __convert_to_v(const char*, long double&, ios_base::iostate&, const __c_locale&) throw();

template<typename _CharT, typename _Traits> struct __pad { static void _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds, streamsize __newlen, streamsize __oldlen); };

template _CharT* __add_grouping(_CharT* __s, _CharT __sep, const char* __gbeg, size_t __gsize, const _CharT* __first, const _CharT* __last);

template inline ostreambuf_iterator<_CharT> __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) { __s._M_put(__ws, __len); return __s; }

template<typename _CharT, typename _OutIter> inline _OutIter __write(_OutIter __s, const _CharT* __ws, int __len) { for (int __j = 0; __j < __len; __j++, ++__s) *__s = __ws[__j]; return __s; }

149 “/usr/include/c++/5/bits/locale_facets.h” 3

template class __ctype_abstract_base : public locale::facet, public ctype_base { public:

  typedef _CharT char_type;

168 “/usr/include/c++/5/bits/locale_facets.h” 3

  bool
  is(mask __m, char_type __c) const
  { return this->do_is(__m, __c); }

185 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char_type*
  is(const char_type *__lo, const char_type *__hi, mask *__vec) const
  { return this->do_is(__lo, __hi, __vec); }

201 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char_type*
  scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
  { return this->do_scan_is(__m, __lo, __hi); }

217 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char_type*
  scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
  { return this->do_scan_not(__m, __lo, __hi); }

231 “/usr/include/c++/5/bits/locale_facets.h” 3

  char_type
  toupper(char_type __c) const
  { return this->do_toupper(__c); }

246 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char_type*
  toupper(char_type *__lo, const char_type* __hi) const
  { return this->do_toupper(__lo, __hi); }

260 “/usr/include/c++/5/bits/locale_facets.h” 3

  char_type
  tolower(char_type __c) const
  { return this->do_tolower(__c); }

275 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char_type*
  tolower(char_type* __lo, const char_type* __hi) const
  { return this->do_tolower(__lo, __hi); }

292 “/usr/include/c++/5/bits/locale_facets.h” 3

  char_type
  widen(char __c) const
  { return this->do_widen(__c); }

311 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char*
  widen(const char* __lo, const char* __hi, char_type* __to) const
  { return this->do_widen(__lo, __hi, __to); }

330 “/usr/include/c++/5/bits/locale_facets.h” 3

  char
  narrow(char_type __c, char __dfault) const
  { return this->do_narrow(__c, __dfault); }

352 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char_type*
  narrow(const char_type* __lo, const char_type* __hi,
   char __dfault, char* __to) const
  { return this->do_narrow(__lo, __hi, __dfault, __to); }

protected:
  explicit
  __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }

  virtual
  ~__ctype_abstract_base() { }

377 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual bool
  do_is(mask __m, char_type __c) const = 0;

396 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_is(const char_type* __lo, const char_type* __hi,
 mask* __vec) const = 0;

415 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_scan_is(mask __m, const char_type* __lo,

const char_type* __hi) const = 0;

434 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const = 0;

452 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_toupper(char_type __c) const = 0;

469 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_toupper(char_type* __lo, const char_type* __hi) const = 0;

485 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_tolower(char_type __c) const = 0;

502 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_tolower(char_type* __lo, const char_type* __hi) const = 0;

521 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_widen(char __c) const = 0;

542 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char*
  do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;

563 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char
  do_narrow(char_type __c, char __dfault) const = 0;

588 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_narrow(const char_type* __lo, const char_type* __hi,

char __dfault, char* __to) const = 0; };

611 “/usr/include/c++/5/bits/locale_facets.h” 3

template class ctype : public __ctype_abstract_base<_CharT> { public:

  typedef _CharT char_type;
  typedef typename __ctype_abstract_base<_CharT>::mask mask;


  static locale::id id;

  explicit
  ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }

protected: virtual ~ctype();

  virtual bool
  do_is(mask __m, char_type __c) const;

  virtual const char_type*
  do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

  virtual const char_type*
  do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

  virtual const char_type*
  do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;

  virtual char_type
  do_toupper(char_type __c) const;

  virtual const char_type*
  do_toupper(char_type* __lo, const char_type* __hi) const;

  virtual char_type
  do_tolower(char_type __c) const;

  virtual const char_type*
  do_tolower(char_type* __lo, const char_type* __hi) const;

  virtual char_type
  do_widen(char __c) const;

  virtual const char*
  do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

  virtual char
  do_narrow(char_type, char __dfault) const;

  virtual const char_type*
  do_narrow(const char_type* __lo, const char_type* __hi,

char __dfault, char* __to) const; };

template locale::id ctype<_CharT>::id;

680 “/usr/include/c++/5/bits/locale_facets.h” 3

template<> class ctype : public locale::facet, public ctype_base { public:

  typedef char char_type;

protected:

  __c_locale _M_c_locale_ctype;
  bool _M_del;
  __to_type _M_toupper;
  __to_type _M_tolower;
  const mask* _M_table;
  mutable char _M_widen_ok;
  mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
  mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
  mutable char _M_narrow_ok;


public:

  static locale::id id;

  static const size_t table_size = 1 + static_cast<unsigned char>(-1);

717 “/usr/include/c++/5/bits/locale_facets.h” 3

  explicit
  ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);

730 “/usr/include/c++/5/bits/locale_facets.h” 3

  explicit
  ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
 size_t __refs = 0);

743 “/usr/include/c++/5/bits/locale_facets.h” 3

  inline bool
  is(mask __m, char __c) const;

758 “/usr/include/c++/5/bits/locale_facets.h” 3

  inline const char*
  is(const char* __lo, const char* __hi, mask* __vec) const;

772 “/usr/include/c++/5/bits/locale_facets.h” 3

  inline const char*
  scan_is(mask __m, const char* __lo, const char* __hi) const;

786 “/usr/include/c++/5/bits/locale_facets.h” 3

  inline const char*
  scan_not(mask __m, const char* __lo, const char* __hi) const;

801 “/usr/include/c++/5/bits/locale_facets.h” 3

  char_type
  toupper(char_type __c) const
  { return this->do_toupper(__c); }

818 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char_type*
  toupper(char_type *__lo, const char_type* __hi) const
  { return this->do_toupper(__lo, __hi); }

834 “/usr/include/c++/5/bits/locale_facets.h” 3

  char_type
  tolower(char_type __c) const
  { return this->do_tolower(__c); }

851 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char_type*
  tolower(char_type* __lo, const char_type* __hi) const
  { return this->do_tolower(__lo, __hi); }

871 “/usr/include/c++/5/bits/locale_facets.h” 3

  char_type
  widen(char __c) const
  {

if (_M_widen_ok) return _M_widen[static_cast(__c)]; this→_M_widen_init(); return this→do_widen(__c); }

898 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char*
  widen(const char* __lo, const char* __hi, char_type* __to) const
  {

if (_M_widen_ok == 1) { __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } if (!_M_widen_ok) _M_widen_init(); return this→do_widen(__lo, __hi, __to); }

929 “/usr/include/c++/5/bits/locale_facets.h” 3

  char
  narrow(char_type __c, char __dfault) const
  {

if (_M_narrow[static_cast(__c)]) return _M_narrow[static_cast(__c)]; const char __t = do_narrow(__c, __dfault); if (__t != __dfault) _M_narrow[static_cast(__c)] = __t; return __t; }

962 “/usr/include/c++/5/bits/locale_facets.h” 3

  const char_type*
  narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) const
  {

if (__builtin_expect(_M_narrow_ok == 1, true)) { __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; } if (!_M_narrow_ok) _M_narrow_init(); return this→do_narrow(__lo, __hi, __dfault, __to); }

  const mask*
  table() const throw()
  { return _M_table; }


  static const mask*
  classic_table() throw();
protected:







  virtual
  ~ctype();

1011 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_toupper(char_type __c) const;

1028 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_toupper(char_type* __lo, const char_type* __hi) const;

1044 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_tolower(char_type __c) const;

1061 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_tolower(char_type* __lo, const char_type* __hi) const;

1081 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_widen(char __c) const
  { return __c; }

1104 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char*
  do_widen(const char* __lo, const char* __hi, char_type* __to) const
  {

__builtin_memcpy(__to, __lo, __hi - __lo); return __hi; }

1130 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char
  do_narrow(char_type __c, char __dfault) const
  { return __c; }

1156 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_narrow(const char_type* __lo, const char_type* __hi,

char __dfault, char* __to) const { __builtin_memcpy(__to, __lo, __hi - __lo); return __hi; }

private:
  void _M_narrow_init() const;
  void _M_widen_init() const;
};

1181 “/usr/include/c++/5/bits/locale_facets.h” 3

template<> class ctype<wchar_t> : public __ctype_abstract_base<wchar_t> { public:

  typedef wchar_t char_type;
  typedef wctype_t __wmask_type;

protected:
  __c_locale _M_c_locale_ctype;


  bool _M_narrow_ok;
  char _M_narrow[128];
  wint_t _M_widen[1 + static_cast<unsigned char>(-1)];


  mask _M_bit[16];
  __wmask_type _M_wmask[16];

public:


  static locale::id id;

1214 “/usr/include/c++/5/bits/locale_facets.h” 3

  explicit
  ctype(size_t __refs = 0);

1225 “/usr/include/c++/5/bits/locale_facets.h” 3

  explicit
  ctype(__c_locale __cloc, size_t __refs = 0);

protected:
  __wmask_type
  _M_convert_to_wmask(const mask __m) const throw();


  virtual
  ~ctype();

1249 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual bool
  do_is(mask __m, char_type __c) const;

1268 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

1286 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

1304 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_scan_not(mask __m, const char_type* __lo,
const char_type* __hi) const;

1321 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_toupper(char_type __c) const;

1338 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_toupper(char_type* __lo, const char_type* __hi) const;

1354 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_tolower(char_type __c) const;

1371 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_tolower(char_type* __lo, const char_type* __hi) const;

1391 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_widen(char __c) const;

1413 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char*
  do_widen(const char* __lo, const char* __hi, char_type* __to) const;

1436 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char
  do_narrow(char_type __c, char __dfault) const;

1462 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual const char_type*
  do_narrow(const char_type* __lo, const char_type* __hi,

char __dfault, char* __to) const;

  void
  _M_initialize_ctype() throw();
};

template class ctype_byname : public ctype<_CharT> { public: typedef typename ctype<_CharT>::mask mask;

  explicit
  ctype_byname(const char* __s, size_t __refs = 0);







protected:
  virtual
  ~ctype_byname() { };
};

template<> class ctype_byname : public ctype { public: explicit ctype_byname(const char* __s, size_t __refs = 0);

protected:
  virtual
  ~ctype_byname();
};

template<> class ctype_byname<wchar_t> : public ctype<wchar_t> { public: explicit ctype_byname(const char* __s, size_t __refs = 0);

protected:
  virtual
  ~ctype_byname();
};

}

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/ctype_inline.h” 1 3

37 “/usr/include/x86_64-linux-gnu/c++/5/bits/ctype_inline.h” 3

namespace std attribute ((visibility (“default”))) {

bool ctype:: is(mask __m, char __c) const { return _M_table[static_cast(__c)] & __m; }

const char* ctype:: is(const char* __low, const char* __high, mask* __vec) const { while (__low < __high) __vec++ = _M_table[static_cast(__low++)]; return __high; }

const char* ctype:: scan_is(mask __m, const char* __low, const char* __high) const { while (__low < __high && !(_M_table[static_cast(*__low)] & __m)) ++__low; return __low; }

const char* ctype:: scan_not(mask __m, const char* __low, const char* __high) const { while (__low < __high && (_M_table[static_cast(*__low)] & __m) != 0) ++__low; return __low; }

}

1535 “/usr/include/c++/5/bits/locale_facets.h” 2 3

namespace std attribute ((visibility (“default”))) {

class __num_base { public:

enum
  {

_S_ominus, _S_oplus, _S_ox, _S_oX, _S_odigits, _S_odigits_end = _S_odigits + 16, _S_oudigits = _S_odigits_end, _S_oudigits_end = _S_oudigits + 16, _S_oe = _S_odigits + 14, _S_oE = _S_oudigits + 14, _S_oend = _S_oudigits_end };

static const char* _S_atoms_out;



static const char* _S_atoms_in;

enum
{
  _S_iminus,
  _S_iplus,
  _S_ix,
  _S_iX,
  _S_izero,
  _S_ie = _S_izero + 14,
  _S_iE = _S_izero + 20,
  _S_iend = 26
};



static void
_S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();

};

template struct __numpunct_cache : public locale::facet { const char* _M_grouping; size_t _M_grouping_size; bool _M_use_grouping; const _CharT* _M_truename; size_t _M_truename_size; const _CharT* _M_falsename; size_t _M_falsename_size; _CharT _M_decimal_point; _CharT _M_thousands_sep;

  _CharT _M_atoms_out[__num_base::_S_oend];





  _CharT _M_atoms_in[__num_base::_S_iend];

  bool _M_allocated;

  __numpunct_cache(size_t __refs = 0)
  : facet(__refs), _M_grouping(0), _M_grouping_size(0),

_M_use_grouping(false), _M_truename(0), _M_truename_size(0), _M_falsename(0), _M_falsename_size(0), _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()), _M_allocated(false) { }

  ~__numpunct_cache();

  void
  _M_cache(const locale& __loc);

private:
  __numpunct_cache&
  operator=(const __numpunct_cache&);

  explicit
  __numpunct_cache(const __numpunct_cache&);
};

template __numpunct_cache<_CharT>::~__numpunct_cache() { if (_M_allocated) { delete [] _M_grouping; delete [] _M_truename; delete [] _M_falsename; } }

namespace __cxx11 {

1665 “/usr/include/c++/5/bits/locale_facets.h” 3

template class numpunct : public locale::facet { public:

  typedef _CharT char_type;
  typedef basic_string<_CharT> string_type;

  typedef __numpunct_cache<_CharT> __cache_type;

protected:
  __cache_type* _M_data;

public:

  static locale::id id;






  explicit
  numpunct(size_t __refs = 0)
  : facet(__refs), _M_data(0)
  { _M_initialize_numpunct(); }

1703 “/usr/include/c++/5/bits/locale_facets.h” 3

  explicit
  numpunct(__cache_type* __cache, size_t __refs = 0)
  : facet(__refs), _M_data(__cache)
  { _M_initialize_numpunct(); }

1717 “/usr/include/c++/5/bits/locale_facets.h” 3

  explicit
  numpunct(__c_locale __cloc, size_t __refs = 0)
  : facet(__refs), _M_data(0)
  { _M_initialize_numpunct(__cloc); }

1731 “/usr/include/c++/5/bits/locale_facets.h” 3

  char_type
  decimal_point() const
  { return this->do_decimal_point(); }

1744 “/usr/include/c++/5/bits/locale_facets.h” 3

  char_type
  thousands_sep() const
  { return this->do_thousands_sep(); }

1775 “/usr/include/c++/5/bits/locale_facets.h” 3

  string
  grouping() const
  { return this->do_grouping(); }

1788 “/usr/include/c++/5/bits/locale_facets.h” 3

  string_type
  truename() const
  { return this->do_truename(); }

1801 “/usr/include/c++/5/bits/locale_facets.h” 3

  string_type
  falsename() const
  { return this->do_falsename(); }

protected:

  virtual
  ~numpunct();

1818 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_decimal_point() const
  { return _M_data->_M_decimal_point; }

1830 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual char_type
  do_thousands_sep() const
  { return _M_data->_M_thousands_sep; }

1843 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual string
  do_grouping() const
  { return _M_data->_M_grouping; }

1856 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual string_type
  do_truename() const
  { return _M_data->_M_truename; }

1869 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual string_type
  do_falsename() const
  { return _M_data->_M_falsename; }


  void
  _M_initialize_numpunct(__c_locale __cloc = 0);
};

template locale::id numpunct<_CharT>::id;

template<> numpunct::~numpunct();

template<> void numpunct::_M_initialize_numpunct(__c_locale __cloc);

template<> numpunct<wchar_t>::~numpunct();

template<> void numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);

template class numpunct_byname : public numpunct<_CharT> { public: typedef _CharT char_type; typedef basic_string<_CharT> string_type;

  explicit
  numpunct_byname(const char* __s, size_t __refs = 0)
  : numpunct<_CharT>(__refs)
  {

if (__builtin_strcmp(__s, “C”) != 0 && __builtin_strcmp(__s, “POSIX”) != 0) { __c_locale __tmp; this→_S_create_c_locale(__tmp, __s); this→_M_initialize_numpunct(__tmp); this→_S_destroy_c_locale(__tmp); } }

protected:
  virtual
  ~numpunct_byname() { }
};

}

1947 “/usr/include/c++/5/bits/locale_facets.h” 3

template<typename _CharT, typename _InIter> class num_get : public locale::facet { public:

  typedef _CharT char_type;
  typedef _InIter iter_type;



  static locale::id id;

1968 “/usr/include/c++/5/bits/locale_facets.h” 3

  explicit
  num_get(size_t __refs = 0) : facet(__refs) { }

1994 “/usr/include/c++/5/bits/locale_facets.h” 3

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, bool& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

2031 “/usr/include/c++/5/bits/locale_facets.h” 3

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, long& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, unsigned short& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, unsigned int& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, unsigned long& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, long long& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, unsigned long long& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

2091 “/usr/include/c++/5/bits/locale_facets.h” 3

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, float& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, double& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, long double& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

2134 “/usr/include/c++/5/bits/locale_facets.h” 3

  iter_type
  get(iter_type __in, iter_type __end, ios_base& __io,

ios_base::iostate& __err, void*& __v) const { return this→do_get(__in, __end, __io, __err, __v); }

protected:

  virtual ~num_get() { }

  __attribute ((__abi_tag__ ("cxx11")))
  iter_type
  _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
     string&) const;

  template<typename _ValueT>

__attribute ((abi_tag (“cxx11”))) iter_type _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, _ValueT&) const;

  template<typename _CharT2>
  typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type

_M_find(const _CharT2*, size_t __len, _CharT2 __c) const { int __ret = -1; if (__len ⇐ 10) { if (__c >= _CharT2(‘0’) && __c < _CharT2(_CharT2(‘0’) + __len)) __ret = __c - _CharT2(‘0’); } else { if (__c >= _CharT2(‘0’) && __c ⇐ _CharT2(‘9’)) __ret = __c - _CharT2(‘0’); else if (__c >= _CharT2(‘a’) && __c ⇐ _CharT2(‘f’)) __ret = 10 + (__c - _CharT2(‘a’)); else if (__c >= _CharT2(‘A’) && __c ⇐ _CharT2(‘F’)) __ret = 10 + (__c - _CharT2(‘A’)); } return __ret; }

  template<typename _CharT2>
  typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
      int>::__type

_M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const { int __ret = -1; const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); if (__q) { __ret = __q - __zero; if (__ret > 15) __ret -= 6; } return __ret; }

2207 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual iter_type
  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;

  virtual iter_type
  do_get(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, long& __v) const
  { return _M_extract_int(__beg, __end, __io, __err, __v); }

  virtual iter_type
  do_get(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, unsigned short& __v) const
  { return _M_extract_int(__beg, __end, __io, __err, __v); }

  virtual iter_type
  do_get(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, unsigned int& __v) const
  { return _M_extract_int(__beg, __end, __io, __err, __v); }

  virtual iter_type
  do_get(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, unsigned long& __v) const
  { return _M_extract_int(__beg, __end, __io, __err, __v); }


  virtual iter_type
  do_get(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, long long& __v) const
  { return _M_extract_int(__beg, __end, __io, __err, __v); }

  virtual iter_type
  do_get(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, unsigned long long& __v) const
  { return _M_extract_int(__beg, __end, __io, __err, __v); }


  virtual iter_type
  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;

  virtual iter_type
  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
  double&) const;







  virtual iter_type
  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
  long double&) const;


  virtual iter_type
  do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;

2270 “/usr/include/c++/5/bits/locale_facets.h” 3

};

template<typename _CharT, typename _InIter> locale::id num_get<_CharT, _InIter>::id;

2288 “/usr/include/c++/5/bits/locale_facets.h” 3

template<typename _CharT, typename _OutIter> class num_put : public locale::facet { public:

  typedef _CharT char_type;
  typedef _OutIter iter_type;



  static locale::id id;

2309 “/usr/include/c++/5/bits/locale_facets.h” 3

  explicit
  num_put(size_t __refs = 0) : facet(__refs) { }

2327 “/usr/include/c++/5/bits/locale_facets.h” 3

  iter_type
  put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
  { return this->do_put(__s, __io, __fill, __v); }

2369 “/usr/include/c++/5/bits/locale_facets.h” 3

  iter_type
  put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
  { return this->do_put(__s, __io, __fill, __v); }

  iter_type
  put(iter_type __s, ios_base& __io, char_type __fill,

unsigned long __v) const { return this→do_put(__s, __io, __fill, __v); }

  iter_type
  put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
  { return this->do_put(__s, __io, __fill, __v); }

  iter_type
  put(iter_type __s, ios_base& __io, char_type __fill,

unsigned long long __v) const { return this→do_put(__s, __io, __fill, __v); }

2432 “/usr/include/c++/5/bits/locale_facets.h” 3

  iter_type
  put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
  { return this->do_put(__s, __io, __fill, __v); }

  iter_type
  put(iter_type __s, ios_base& __io, char_type __fill,

long double __v) const { return this→do_put(__s, __io, __fill, __v); }

2457 “/usr/include/c++/5/bits/locale_facets.h” 3

  iter_type
  put(iter_type __s, ios_base& __io, char_type __fill,

const void* __v) const { return this→do_put(__s, __io, __fill, __v); }

protected:
  template<typename _ValueT>

iter_type _M_insert_float(iter_type, ios_base& __io, char_type __fill, char __mod, _ValueT __v) const;

  void
  _M_group_float(const char* __grouping, size_t __grouping_size,
   char_type __sep, const char_type* __p, char_type* __new,
   char_type* __cs, int& __len) const;

  template<typename _ValueT>

iter_type _M_insert_int(iter_type, ios_base& __io, char_type __fill, _ValueT __v) const;

  void
  _M_group_int(const char* __grouping, size_t __grouping_size,
 char_type __sep, ios_base& __io, char_type* __new,
 char_type* __cs, int& __len) const;

  void
  _M_pad(char_type __fill, streamsize __w, ios_base& __io,
  char_type* __new, const char_type* __cs, int& __len) const;


  virtual
  ~num_put() { };

2505 “/usr/include/c++/5/bits/locale_facets.h” 3

  virtual iter_type
  do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;

  virtual iter_type
  do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
  { return _M_insert_int(__s, __io, __fill, __v); }

  virtual iter_type
  do_put(iter_type __s, ios_base& __io, char_type __fill,
  unsigned long __v) const
  { return _M_insert_int(__s, __io, __fill, __v); }


  virtual iter_type
  do_put(iter_type __s, ios_base& __io, char_type __fill,
  long long __v) const
  { return _M_insert_int(__s, __io, __fill, __v); }

  virtual iter_type
  do_put(iter_type __s, ios_base& __io, char_type __fill,
  unsigned long long __v) const
  { return _M_insert_int(__s, __io, __fill, __v); }


  virtual iter_type
  do_put(iter_type, ios_base&, char_type, double) const;






  virtual iter_type
  do_put(iter_type, ios_base&, char_type, long double) const;


  virtual iter_type
  do_put(iter_type, ios_base&, char_type, const void*) const;







};

template <typename _CharT, typename _OutIter> locale::id num_put<_CharT, _OutIter>::id;

template inline bool isspace(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }

template inline bool isprint(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }

template inline bool iscntrl(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }

template inline bool isupper(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }

template inline bool islower(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }

template inline bool isalpha(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }

template inline bool isdigit(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }

template inline bool ispunct(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }

template inline bool isxdigit(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }

template inline bool isalnum(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }

template inline bool isgraph(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }

2637 “/usr/include/c++/5/bits/locale_facets.h” 3

template inline _CharT toupper(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }

template inline _CharT tolower(_CharT __c, const locale& __loc) { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }

}

1 “/usr/include/c++/5/bits/locale_facets.tcc” 1 3

33 “/usr/include/c++/5/bits/locale_facets.tcc” 3

34 “/usr/include/c++/5/bits/locale_facets.tcc” 3

namespace std attribute ((visibility (“default”))) {

template struct __use_cache { const _Facet* operator() (const locale& __loc) const; };

template struct __use_cache<__numpunct_cache<_CharT> > { const __numpunct_cache<_CharT>* operator() (const locale& __loc) const { const size_t __i = numpunct<_CharT>::id._M_id(); const locale::facet** __caches = __loc._M_impl→_M_caches; if (!__caches[__i]) { __numpunct_cache<_CharT>* __tmp = 0; try { __tmp = new __numpunct_cache<_CharT>; __tmp→_M_cache(__loc); } catch(…) { delete __tmp; throw; } __loc._M_impl→_M_install_cache(__tmp, __i); } return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]); } };

template void __numpunct_cache<_CharT>::_M_cache(const locale& __loc) { const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);

  char* __grouping = 0;
  _CharT* __truename = 0;
  _CharT* __falsename = 0;
  try

{ const string& __g = __np.grouping(); _M_grouping_size = __g.size(); __grouping = new char[_M_grouping_size]; __g.copy(__grouping, _M_grouping_size); _M_use_grouping = (_M_grouping_size && static_cast(__grouping[0]) > 0 && (__grouping[0] != __gnu_cxx::__numeric_traits::__max));

const basic_string<_CharT>& __tn = __np.truename(); _M_truename_size = __tn.size(); __truename = new _CharT[_M_truename_size]; __tn.copy(__truename, _M_truename_size);

const basic_string<_CharT>& __fn = __np.falsename(); _M_falsename_size = __fn.size(); __falsename = new _CharT[_M_falsename_size]; __fn.copy(__falsename, _M_falsename_size);

_M_decimal_point = __np.decimal_point(); _M_thousands_sep = __np.thousands_sep();

const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc); __ct.widen(__num_base::_S_atoms_out, __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out); __ct.widen(__num_base::_S_atoms_in, __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in);

_M_grouping = __grouping; _M_truename = __truename; _M_falsename = __falsename; _M_allocated = true; } catch(…) { delete [] __grouping; delete [] __truename; delete [] __falsename; throw; } }

139 “/usr/include/c++/5/bits/locale_facets.tcc” 3

attribute ((pure)) bool __verify_grouping(const char* __grouping, size_t __grouping_size, const string& __grouping_tmp) throw ();

template<typename _CharT, typename _InIter> __attribute ((abi_tag (“cxx11”))) _InIter num_get<_CharT, _InIter>:: _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io, ios_base::iostate& __err, string& __xtrc) const { typedef char_traits<_CharT> __traits_type; typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const _CharT* __lit = __lc→_M_atoms_in; char_type __c = char_type();

  bool __testeof = __beg == __end;


  if (!__testeof)

{ __c = *__beg; const bool __plus = __c __lit[__num_base::_S_iplus]; if ((__plus || __c __lit[__num_base::_S_iminus]) && !(__lc→_M_use_grouping && __c __lc->_M_thousands_sep) && !(__c __lc→_M_decimal_point)) { __xtrc += __plus ? ’+’ : ’-’; if (++__beg != __end) __c = *__beg; else __testeof = true; } }

  bool __found_mantissa = false;
  int __sep_pos = 0;
  while (!__testeof)

{ if ((__lc→_M_use_grouping && __c __lc->_M_thousands_sep) || __c __lc→_M_decimal_point) break; else if (__c == __lit[__num_base::_S_izero]) { if (!__found_mantissa) { __xtrc += ‘0’; __found_mantissa = true; } ++__sep_pos;

   if (++__beg != __end)

__c = *__beg; else __testeof = true; } else break; }

  bool __found_dec = false;
  bool __found_sci = false;
  string __found_grouping;
  if (__lc->_M_use_grouping)

__found_grouping.reserve(32); const char_type* __lit_zero = __lit + __num_base::_S_izero;

  if (!__lc->_M_allocated)

while (!__testeof) { const int __digit = _M_find(__lit_zero, 10, __c); if (__digit != -1) { __xtrc += ‘0’ + __digit; __found_mantissa = true; } else if (__c == __lc→_M_decimal_point && !__found_dec && !__found_sci) { __xtrc += ’.’; __found_dec = true; } else if ((__c __lit[__num_base::_S_ie] || __c __lit[__num_base::_S_iE]) && !__found_sci && __found_mantissa) {

__xtrc += ‘e’; __found_sci = true;

if (++__beg != __end) { __c = *__beg; const bool __plus = __c __lit[__num_base::_S_iplus]; if (__plus || __c __lit[__num_base::_S_iminus]) __xtrc += __plus ? ’+’ : ’-’; else continue; } else { __testeof = true; break; } } else break;

 if (++__beg != __end)
   __c = *__beg;
 else
   __testeof = true;

} else while (!__testeof) {

 if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
   {

if (!__found_dec && !__found_sci) {

  if (__sep_pos)
    {

__found_grouping += static_cast(__sep_pos); __sep_pos = 0; } else {

__xtrc.clear(); break; } } else break; } else if (__c == __lc→_M_decimal_point) { if (!__found_dec && !__found_sci) {

  if (__found_grouping.size())
    __found_grouping += static_cast<char>(__sep_pos);
  __xtrc += '.';
  __found_dec = true;
}

else break; } else { const char_type* __q = __traits_type::find(__lit_zero, 10, __c); if (__q) { __xtrc += ‘0’ + (__q - __lit_zero); __found_mantissa = true; ++__sep_pos; } else if ((__c __lit[__num_base::_S_ie] || __c __lit[__num_base::_S_iE]) && !__found_sci && __found_mantissa) {

  if (__found_grouping.size() && !__found_dec)
    __found_grouping += static_cast<char>(__sep_pos);
  __xtrc += 'e';
  __found_sci = true;


  if (++__beg != __end)
    {

__c = *__beg; const bool __plus = __c __lit[__num_base::_S_iplus]; if ((__plus || __c __lit[__num_base::_S_iminus]) && !(__lc→_M_use_grouping && __c __lc->_M_thousands_sep) && !(__c __lc→_M_decimal_point)) __xtrc += __plus ? ’+’ : ’-’; else continue; } else { __testeof = true; break; } } else break; }

 if (++__beg != __end)
   __c = *__beg;
 else
   __testeof = true;

}

  if (__found_grouping.size())
    {

if (!__found_dec && !__found_sci) __found_grouping += static_cast(__sep_pos);

      if (!std::__verify_grouping(__lc->_M_grouping,
      __lc->_M_grouping_size,
      __found_grouping))
 __err = ios_base::failbit;
    }

  return __beg;
}

template<typename _CharT, typename _InIter> template __attribute ((abi_tag (“cxx11”))) _InIter num_get<_CharT, _InIter>:: _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io, ios_base::iostate& __err, _ValueT& __v) const { typedef char_traits<_CharT> __traits_type; using __gnu_cxx::__add_unsigned; typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const _CharT* __lit = __lc→_M_atoms_in; char_type __c = char_type();

const ios_base::fmtflags __basefield = __io.flags() & ios_base::basefield; const bool __oct = __basefield == ios_base::oct; int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);

bool __testeof = __beg == __end;

bool __negative = false; if (!__testeof) { __c = *__beg; __negative = __c __lit[__num_base::_S_iminus]; if ((__negative || __c __lit[__num_base::_S_iplus]) && !(__lc→_M_use_grouping && __c __lc->_M_thousands_sep) && !(__c __lc→_M_decimal_point)) { if (++__beg != __end) __c = *__beg; else __testeof = true; } }

bool __found_zero = false; int __sep_pos = 0; while (!__testeof) { if ((__lc→_M_use_grouping && __c __lc->_M_thousands_sep) || __c __lc→_M_decimal_point) break; else if (__c __lit[__num_base::_S_izero] && (!__found_zero || __base 10)) { __found_zero = true; ++__sep_pos; if (__basefield == 0) __base = 8; if (__base == 8) __sep_pos = 0; } else if (__found_zero && (__c __lit[__num_base::_S_ix] || __c __lit[__num_base::_S_iX])) { if (__basefield == 0) __base = 16; if (__base == 16) { __found_zero = false; __sep_pos = 0; } else break; } else break;

 if (++__beg != __end)
   {

__c = *__beg; if (!__found_zero) break; } else __testeof = true; }

const size_t __len = (__base == 16 ? __num_base::_S_iend - __num_base::_S_izero : __base);

string __found_grouping; if (__lc→_M_use_grouping) __found_grouping.reserve(32); bool __testfail = false; bool __testoverflow = false; const __unsigned_type __max = (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) ? -__gnu_cxx::__numeric_traits<_ValueT>::__min : __gnu_cxx::__numeric_traits<_ValueT>::__max; const __unsigned_type __smax = __max / __base; __unsigned_type __result = 0; int __digit = 0; const char_type* __lit_zero = __lit + __num_base::_S_izero;

if (!__lc→_M_allocated)

while (!__testeof) { __digit = _M_find(__lit_zero, __len, __c); if (__digit == -1) break;

   if (__result > __smax)

__testoverflow = true; else { __result *= __base; __testoverflow |= __result > __max - __digit; __result += __digit; ++__sep_pos; }

   if (++__beg != __end)

__c = *__beg; else __testeof = true; } else while (!__testeof) {

   if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)

{

if (__sep_pos)
  {
    __found_grouping += static_cast<char>(__sep_pos);
    __sep_pos = 0;
  }
else
  {
    __testfail = true;
    break;
  }

} else if (__c == __lc→_M_decimal_point) break; else { const char_type* __q = __traits_type::find(__lit_zero, __len, __c); if (!__q) break;

__digit = __q - __lit_zero;
if (__digit > 15)
  __digit -= 6;
if (__result > __smax)
  __testoverflow = true;
else
  {
    __result *= __base;
    __testoverflow |= __result > __max - __digit;
    __result += __digit;
    ++__sep_pos;
  }

}

   if (++__beg != __end)

__c = *__beg; else __testeof = true; }

if (__found_grouping.size()) {

 __found_grouping += static_cast<char>(__sep_pos);

 if (!std::__verify_grouping(__lc->_M_grouping,
 __lc->_M_grouping_size,
 __found_grouping))
   __err = ios_base::failbit;

}

if ((!__sep_pos && !__found_zero && !__found_grouping.size()) || __testfail) { __v = 0; __err = ios_base::failbit; } else if (__testoverflow) { if (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) __v = __gnu_cxx::__numeric_traits<_ValueT>::__min; else __v = __gnu_cxx::__numeric_traits<_ValueT>::__max; __err = ios_base::failbit; } else __v = __negative ? -__result : __result;

if (__testeof) __err |= ios_base::eofbit; return __beg; }

template<typename _CharT, typename _InIter> _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, bool& __v) const { if (!(__io.flags() & ios_base::boolalpha)) {

long __l = -1; __beg = _M_extract_int(__beg, __end, __io, __err, __l); if (__l 0 || __l 1) __v = bool(__l); else {

   __v = true;
   __err = ios_base::failbit;
   if (__beg == __end)

__err |= ios_base::eofbit; } } else {

typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc);

bool __testf = true; bool __testt = true; bool __donef = __lc→_M_falsename_size == 0; bool __donet = __lc→_M_truename_size == 0; bool __testeof = false; size_t __n = 0; while (!__donef || !__donet) { if (__beg == __end) { __testeof = true; break; }

   const char_type __c = *__beg;

   if (!__donef)

__testf = __c == __lc→_M_falsename[__n];

   if (!__testf && __donet)

break;

   if (!__donet)

__testt = __c == __lc→_M_truename[__n];

   if (!__testt && __donef)

break;

   if (!__testt && !__testf)

break;

   ++__n;
   ++__beg;

   __donef = !__testf || __n >= __lc->_M_falsename_size;
   __donet = !__testt || __n >= __lc->_M_truename_size;
 }

if (__testf && __n == __lc→_M_falsename_size && __n) { __v = false; if (__testt && __n == __lc→_M_truename_size) __err = ios_base::failbit; else __err = __testeof ? ios_base::eofbit : ios_base::goodbit; } else if (__testt && __n == __lc→_M_truename_size && __n) { __v = true; __err = __testeof ? ios_base::eofbit : ios_base::goodbit; } else {

   __v = false;
   __err = ios_base::failbit;
   if (__testeof)

__err |= ios_base::eofbit; } } return __beg; }

template<typename _CharT, typename _InIter> _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, float& __v) const { string __xtrc; __xtrc.reserve(32); __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); if (__beg == __end) __err |= ios_base::eofbit; return __beg; }

template<typename _CharT, typename _InIter> _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, double& __v) const { string __xtrc; __xtrc.reserve(32); __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); if (__beg == __end) __err |= ios_base::eofbit; return __beg; }

735 “/usr/include/c++/5/bits/locale_facets.tcc” 3

template<typename _CharT, typename _InIter> _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, long double& __v) const { string __xtrc; __xtrc.reserve(32); __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); if (__beg == __end) __err |= ios_base::eofbit; return __beg; }

template<typename _CharT, typename _InIter> _InIter num_get<_CharT, _InIter>:: do_get(iter_type __beg, iter_type __end, ios_base& __io, ios_base::iostate& __err, void*& __v) const {

  typedef ios_base::fmtflags fmtflags;
  const fmtflags __fmt = __io.flags();
  __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);

  typedef __gnu_cxx::__conditional_type<(sizeof(void*)
      <= sizeof(unsigned long)),

unsigned long, unsigned long long>::__type _UIntPtrType;

  _UIntPtrType __ul;
  __beg = _M_extract_int(__beg, __end, __io, __err, __ul);


  __io.flags(__fmt);

  __v = reinterpret_cast<void*>(__ul);
  return __beg;
}

template<typename _CharT, typename _OutIter> void num_put<_CharT, _OutIter>:: _M_pad(_CharT __fill, streamsize __w, ios_base& __io, _CharT* __new, const _CharT* __cs, int& __len) const {

  __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
    __cs, __w, __len);
  __len = static_cast<int>(__w);
}

template<typename _CharT, typename _ValueT> int __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit, ios_base::fmtflags __flags, bool __dec) { _CharT* __buf = __bufend; if (__builtin_expect(__dec, true)) {

do { *—__buf = __lit[(__v % 10) + __num_base::_S_odigits]; __v /= 10; } while (__v != 0); } else if ((__flags & ios_base::basefield) == ios_base::oct) {

do { *—__buf = __lit[(__v & 0x7) + __num_base::_S_odigits]; __v >>= 3; } while (__v != 0); } else {

const bool __uppercase = __flags & ios_base::uppercase; const int __case_offset = __uppercase ? __num_base::_S_oudigits : __num_base::_S_odigits; do { *—__buf = __lit[(__v & 0xf) + __case_offset]; __v >>= 4; } while (__v != 0); } return __bufend - __buf; }

template<typename _CharT, typename _OutIter> void num_put<_CharT, _OutIter>:: _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep, ios_base&, _CharT* __new, _CharT* __cs, int& __len) const { _CharT* __p = std::__add_grouping(__new, __sep, __grouping, __grouping_size, __cs, __cs + __len); __len = __p - __new; }

template<typename _CharT, typename _OutIter> template _OutIter num_put<_CharT, _OutIter>:: _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill, _ValueT __v) const { using __gnu_cxx::__add_unsigned; typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const _CharT* __lit = __lc→_M_atoms_out; const ios_base::fmtflags __flags = __io.flags();

const int __ilen = 5 * sizeof(_ValueT); _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __ilen));

const ios_base::fmtflags __basefield = __flags & ios_base::basefield; const bool __dec = (__basefield != ios_base::oct && __basefield != ios_base::hex); const __unsigned_type __u = ((__v > 0 || !__dec) ? __unsigned_type(__v) : -__unsigned_type(__v)); int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec); __cs += __ilen - __len;

if (__lc→_M_use_grouping) {

 _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
      * (__len + 1)
      * 2));
 _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
__lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
 __cs = __cs2 + 2;

}

if (__builtin_expect(__dec, true)) {

 if (__v >= 0)
   {

if (bool(__flags & ios_base::showpos) && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) *—__cs = __lit[__num_base::_S_oplus], ++__len; } else *—__cs = __lit[__num_base::_S_ominus], ++__len; } else if (bool(__flags & ios_base::showbase) && __v) { if (__basefield == ios_base::oct) *—__cs = __lit[__num_base::_S_odigits], ++__len; else {

const bool __uppercase = __flags & ios_base::uppercase; *—__cs = __lit[__num_base::_S_ox + __uppercase];

*—__cs = __lit[__num_base::_S_odigits]; __len += 2; } }

const streamsize __w = __io.width(); if (__w > static_cast(__len)) { _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w)); _M_pad(__fill, __w, __io, __cs3, __cs, __len); __cs = __cs3; } __io.width(0);

return std::__write(__s, __cs, __len); }

template<typename _CharT, typename _OutIter> void num_put<_CharT, _OutIter>:: _M_group_float(const char* __grouping, size_t __grouping_size, _CharT __sep, const _CharT* __p, _CharT* __new, _CharT* __cs, int& __len) const {

  const int __declen = __p ? __p - __cs : __len;
  _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
  __grouping_size,
  __cs, __cs + __declen);


  int __newlen = __p2 - __new;
  if (__p)

{ char_traits<_CharT>::copy(__p2, __p, __len - __declen); __newlen += __len - __declen; } __len = __newlen; }

971 “/usr/include/c++/5/bits/locale_facets.tcc” 3

template<typename _CharT, typename _OutIter> template _OutIter num_put<_CharT, _OutIter>:: _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, _ValueT __v) const { typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc);

const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();

const int __max_digits = __gnu_cxx::__numeric_traits<_ValueT>::__digits10;

int __len;

char __fbuf[16]; __num_base::_S_format_float(__io, __fbuf, __mod);

const bool __use_prec = (__io.flags() & ios_base::floatfield) != ios_base::floatfield;

int __cs_size = __max_digits * 3; char* __cs = static_cast<char*>(__builtin_alloca(__cs_size)); if (__use_prec) __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __prec, __v); else __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __v);

if (__len >= __cs_size) { __cs_size = __len + 1; __cs = static_cast<char*>(__builtin_alloca(__cs_size)); if (__use_prec) __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __prec, __v); else __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, __fbuf, __v); }

1044 “/usr/include/c++/5/bits/locale_facets.tcc” 3

const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

_CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len)); __ctype.widen(__cs, __cs + __len, __ws);

_CharT* __wp = 0; const char* __p = char_traits::find(__cs, __len, ’.’); if (__p) { __wp = __ws + (__p - __cs); *__wp = __lc→_M_decimal_point; }

if (__lc→_M_use_grouping && (__wp || __len < 3 || (__cs[1] ⇐ ‘9’ && __cs[2] ⇐ ‘9’ && __cs[1] >= ‘0’ && __cs[2] >= ‘0’))) {

 _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
      * __len * 2));

 streamsize __off = 0;
 if (__cs[0] == '-' || __cs[0] == '+')
   {

__off = 1; __ws2[0] = __ws[0]; __len -= 1; }

 _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
  __lc->_M_thousands_sep, __wp, __ws2 + __off,
  __ws + __off, __len);
 __len += __off;

 __ws = __ws2;

}

const streamsize __w = __io.width(); if (__w > static_cast(__len)) { _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w)); _M_pad(__fill, __w, __io, __ws3, __ws, __len); __ws = __ws3; } __io.width(0);

return std::__write(__s, __ws, __len); }

template<typename _CharT, typename _OutIter> _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const { const ios_base::fmtflags __flags = __io.flags(); if ((__flags & ios_base::boolalpha) == 0) { const long __l = __v; __s = _M_insert_int(__s, __io, __fill, __l); } else { typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc);

const _CharT* __name = __v ? __lc→_M_truename : __lc→_M_falsename; int __len = __v ? __lc→_M_truename_size : __lc→_M_falsename_size;

const streamsize __w = __io.width(); if (__w > static_cast(__len)) { const streamsize __plen = __w - __len; _CharT* __ps = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __plen));

   char_traits<_CharT>::assign(__ps, __plen, __fill);
   __io.width(0);

   if ((__flags & ios_base::adjustfield) == ios_base::left)

{ __s = std::__write(__s, __name, __len); __s = std::__write(__s, __ps, __plen); } else { __s = std::__write(__s, __ps, __plen); __s = std::__write(__s, __name, __len); } return __s; } __io.width(0); __s = std::__write(__s, __name, __len); } return __s; }

template<typename _CharT, typename _OutIter> _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const { return _M_insert_float(__s, __io, __fill, char(), __v); }

1169 “/usr/include/c++/5/bits/locale_facets.tcc” 3

template<typename _CharT, typename _OutIter> _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, long double __v) const { return _M_insert_float(__s, __io, __fill, ‘L’, __v); }

template<typename _CharT, typename _OutIter> _OutIter num_put<_CharT, _OutIter>:: do_put(iter_type __s, ios_base& __io, char_type __fill, const void* __v) const { const ios_base::fmtflags __flags = __io.flags(); const ios_base::fmtflags __fmt = ~(ios_base::basefield | ios_base::uppercase); __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));

  typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
      <= sizeof(unsigned long)),

unsigned long, unsigned long long>::__type _UIntPtrType;

  __s = _M_insert_int(__s, __io, __fill,
 reinterpret_cast<_UIntPtrType>(__v));
  __io.flags(__flags);
  return __s;
}

1206 “/usr/include/c++/5/bits/locale_facets.tcc” 3

template<typename _CharT, typename _Traits> void __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill, _CharT* __news, const _CharT* __olds, streamsize __newlen, streamsize __oldlen) { const size_t __plen = static_cast<size_t>(__newlen - __oldlen); const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;

  if (__adjust == ios_base::left)

{ _Traits::copy(__news, __olds, __oldlen); _Traits::assign(__news + __oldlen, __plen, __fill); return; }

  size_t __mod = 0;
  if (__adjust == ios_base::internal)

{

      const locale& __loc = __io._M_getloc();

const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

if (__ctype.widen(’-’) __olds[0] || __ctype.widen('+') __olds[0]) { __news[0] = __olds[0]; __mod = 1; ++__news; } else if (__ctype.widen(‘0’) __olds[0] && __oldlen > 1 && (__ctype.widen('x') __olds[1] || __ctype.widen(‘X’) == __olds[1])) { __news[0] = __olds[0]; __news[1] = __olds[1]; __mod = 2; __news += 2; }

} _Traits::assign(__news, __plen, __fill); _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod); }

template _CharT* __add_grouping(_CharT* __s, _CharT __sep, const char* __gbeg, size_t __gsize, const _CharT* __first, const _CharT* __last) { size_t __idx = 0; size_t __ctr = 0;

  while (__last - __first > __gbeg[__idx]
  && static_cast<signed char>(__gbeg[__idx]) > 0
  && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)

{ __last -= __gbeg[__idx]; __idx < __gsize - 1 ? ++__idx : ++__ctr; }

  while (__first != __last)

*__s++ = *__first++;

  while (__ctr--)

{ *__s++ = __sep; for (char __i = __gbeg[__idx]; __i > 0; —__i) *__s++ = *__first++; }

  while (__idx--)

{ *__s++ = __sep; for (char __i = __gbeg[__idx]; __i > 0; —__i) *__s++ = *__first++; }

  return __s;
}

extern template class __cxx11:: numpunct; extern template class __cxx11:: numpunct_byname; extern template class num_get; extern template class num_put; extern template class ctype_byname;

extern template const ctype& use_facet<ctype >(const locale&);

extern template const numpunct& use_facet<numpunct >(const locale&);

extern template const num_put& use_facet<num_put >(const locale&);

extern template const num_get& use_facet<num_get >(const locale&);

extern template bool has_facet<ctype >(const locale&);

extern template bool has_facet<numpunct >(const locale&);

extern template bool has_facet<num_put >(const locale&);

extern template bool has_facet<num_get >(const locale&);

extern template class __cxx11:: numpunct<wchar_t>; extern template class __cxx11:: numpunct_byname<wchar_t>; extern template class num_get<wchar_t>; extern template class num_put<wchar_t>; extern template class ctype_byname<wchar_t>;

extern template const ctype<wchar_t>& use_facet<ctype<wchar_t> >(const locale&);

extern template const numpunct<wchar_t>& use_facet<numpunct<wchar_t> >(const locale&);

extern template const num_put<wchar_t>& use_facet<num_put<wchar_t> >(const locale&);

extern template const num_get<wchar_t>& use_facet<num_get<wchar_t> >(const locale&);

extern template bool has_facet<ctype<wchar_t> >(const locale&);

extern template bool has_facet<numpunct<wchar_t> >(const locale&);

extern template bool has_facet<num_put<wchar_t> >(const locale&);

extern template bool has_facet<num_get<wchar_t> >(const locale&);

}

2652 “/usr/include/c++/5/bits/locale_facets.h” 2 3

38 “/usr/include/c++/5/bits/basic_ios.h” 2 3

namespace std attribute ((visibility (“default”))) {

template inline const _Facet& __check_facet(const _Facet* __f) { if (!__f) __throw_bad_cast(); return *__f; }

66 “/usr/include/c++/5/bits/basic_ios.h” 3

template<typename _CharT, typename _Traits> class basic_ios : public ios_base { public:

  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;






  typedef ctype<_CharT> __ctype_type;
  typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
       __num_put_type;
  typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
       __num_get_type;



protected:
  basic_ostream<_CharT, _Traits>* _M_tie;
  mutable char_type _M_fill;
  mutable bool _M_fill_init;
  basic_streambuf<_CharT, _Traits>* _M_streambuf;


  const __ctype_type* _M_ctype;

  const __num_put_type* _M_num_put;

  const __num_get_type* _M_num_get;

public:

120 “/usr/include/c++/5/bits/basic_ios.h” 3

  operator void*() const
  { return this->fail() ? 0 : const_cast<basic_ios*>(this); }


  bool
  operator!() const
  { return this->fail(); }

136 “/usr/include/c++/5/bits/basic_ios.h” 3

  iostate
  rdstate() const
  { return _M_streambuf_state; }

147 “/usr/include/c++/5/bits/basic_ios.h” 3

  void
  clear(iostate __state = goodbit);







  void
  setstate(iostate __state)
  { this->clear(this->rdstate() | __state); }




  void
  _M_setstate(iostate __state)
  {

_M_streambuf_state |= __state; if (this→exceptions() & __state) throw; }

  bool
  good() const
  { return this->rdstate() == 0; }







  bool
  eof() const
  { return (this->rdstate() & eofbit) != 0; }

200 “/usr/include/c++/5/bits/basic_ios.h” 3

  bool
  fail() const
  { return (this->rdstate() & (badbit | failbit)) != 0; }







  bool
  bad() const
  { return (this->rdstate() & badbit) != 0; }

221 “/usr/include/c++/5/bits/basic_ios.h” 3

  iostate
  exceptions() const
  { return _M_exception; }

256 “/usr/include/c++/5/bits/basic_ios.h” 3

  void
  exceptions(iostate __except)
  {
    _M_exception = __except;
    this->clear(_M_streambuf_state);
  }







  explicit
  basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
  : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),

_M_ctype(0), _M_num_put(0), _M_num_get(0) { this→init(__sb); }

  virtual
  ~basic_ios() { }

294 “/usr/include/c++/5/bits/basic_ios.h” 3

  basic_ostream<_CharT, _Traits>*
  tie() const
  { return _M_tie; }

306 “/usr/include/c++/5/bits/basic_ios.h” 3

  basic_ostream<_CharT, _Traits>*
  tie(basic_ostream<_CharT, _Traits>* __tiestr)
  {
    basic_ostream<_CharT, _Traits>* __old = _M_tie;
    _M_tie = __tiestr;
    return __old;
  }







  basic_streambuf<_CharT, _Traits>*
  rdbuf() const
  { return _M_streambuf; }

346 “/usr/include/c++/5/bits/basic_ios.h” 3

  basic_streambuf<_CharT, _Traits>*
  rdbuf(basic_streambuf<_CharT, _Traits>* __sb);

360 “/usr/include/c++/5/bits/basic_ios.h” 3

  basic_ios&
  copyfmt(const basic_ios& __rhs);







  char_type
  fill() const
  {

if (!_M_fill_init) { _M_fill = this→widen(’ ’); _M_fill_init = true; } return _M_fill; }

389 “/usr/include/c++/5/bits/basic_ios.h” 3

  char_type
  fill(char_type __ch)
  {

char_type __old = this→fill(); _M_fill = __ch; return __old; }

409 “/usr/include/c++/5/bits/basic_ios.h” 3

  locale
  imbue(const locale& __loc);

429 “/usr/include/c++/5/bits/basic_ios.h” 3

  char
  narrow(char_type __c, char __dfault) const
  { return __check_facet(_M_ctype).narrow(__c, __dfault); }

448 “/usr/include/c++/5/bits/basic_ios.h” 3

  char_type
  widen(char __c) const
  { return __check_facet(_M_ctype).widen(__c); }

protected:







  basic_ios()
  : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),

_M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) { }

  void
  init(basic_streambuf<_CharT, _Traits>* __sb);

509 “/usr/include/c++/5/bits/basic_ios.h” 3

  void
  _M_cache_locale(const locale& __loc);
};

}

1 “/usr/include/c++/5/bits/basic_ios.tcc” 1 3

33 “/usr/include/c++/5/bits/basic_ios.tcc” 3

34 “/usr/include/c++/5/bits/basic_ios.tcc” 3

namespace std attribute ((visibility (“default”))) {

template<typename _CharT, typename _Traits> void basic_ios<_CharT, _Traits>::clear(iostate __state) { if (this→rdbuf()) _M_streambuf_state = __state; else _M_streambuf_state = __state | badbit; if (this→exceptions() & this→rdstate()) __throw_ios_failure((“basic_ios::clear”)); }

template<typename _CharT, typename _Traits> basic_streambuf<_CharT, _Traits>* basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb) { basic_streambuf<_CharT, _Traits>* __old = _M_streambuf; _M_streambuf = __sb; this→clear(); return __old; }

template<typename _CharT, typename _Traits> basic_ios<_CharT, _Traits>& basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) {

  if (this != &__rhs)

{

_Words* __words = (__rhs._M_word_size ⇐ _S_local_word_size) ? _M_local_word : new _Words[__rhs._M_word_size];

_Callback_list* __cb = __rhs._M_callbacks; if (__cb) __cb→_M_add_reference(); _M_call_callbacks(erase_event); if (_M_word != _M_local_word) { delete [] _M_word; _M_word = 0; } _M_dispose_callbacks();

_M_callbacks = __cb; for (int __i = 0; __i < __rhs._M_word_size; ++__i) __words[__i] = __rhs._M_word[__i]; _M_word = __words; _M_word_size = __rhs._M_word_size;

this→flags(__rhs.flags()); this→width(__rhs.width()); this→precision(__rhs.precision()); this→tie(__rhs.tie()); this→fill(__rhs.fill()); _M_ios_locale = __rhs.getloc(); _M_cache_locale(_M_ios_locale);

_M_call_callbacks(copyfmt_event);

this→exceptions(__rhs.exceptions()); } return *this; }

template<typename _CharT, typename _Traits> locale basic_ios<_CharT, _Traits>::imbue(const locale& __loc) { locale __old(this→getloc()); ios_base::imbue(__loc); _M_cache_locale(__loc); if (this→rdbuf() != 0) this→rdbuf()→pubimbue(__loc); return __old; }

template<typename _CharT, typename _Traits> void basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) {

  ios_base::_M_init();


  _M_cache_locale(_M_ios_locale);

146 “/usr/include/c++/5/bits/basic_ios.tcc” 3

  _M_fill = _CharT();
  _M_fill_init = false;

  _M_tie = 0;
  _M_exception = goodbit;
  _M_streambuf = __sb;
  _M_streambuf_state = __sb ? goodbit : badbit;
}

template<typename _CharT, typename _Traits> void basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) { if (__builtin_expect(has_facet<__ctype_type>(__loc), true)) _M_ctype = &use_facet<__ctype_type>(__loc); else _M_ctype = 0;

  if (__builtin_expect(has_facet<__num_put_type>(__loc), true))

_M_num_put = &use_facet<__num_put_type>(__loc); else _M_num_put = 0;

  if (__builtin_expect(has_facet<__num_get_type>(__loc), true))

_M_num_get = &use_facet<__num_get_type>(__loc); else _M_num_get = 0; }

extern template class basic_ios;

extern template class basic_ios<wchar_t>;

}

517 “/usr/include/c++/5/bits/basic_ios.h” 2 3

45 “/usr/include/c++/5/ios” 2 3

39 “/usr/include/c++/5/ostream” 2 3

namespace std attribute ((visibility (“default”))) {

57 “/usr/include/c++/5/ostream” 3

template<typename _CharT, typename _Traits> class basic_ostream : virtual public basic_ios<_CharT, _Traits> { public:

  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;


  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
  typedef basic_ios<_CharT, _Traits> __ios_type;
  typedef basic_ostream<_CharT, _Traits> __ostream_type;
  typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
         __num_put_type;
  typedef ctype<_CharT> __ctype_type;

83 “/usr/include/c++/5/ostream” 3

  explicit
  basic_ostream(__streambuf_type* __sb)
  { this->init(__sb); }






  virtual
  ~basic_ostream() { }


  class sentry;
  friend class sentry;

107 “/usr/include/c++/5/ostream” 3

  __ostream_type&
  operator<<(__ostream_type& (*__pf)(__ostream_type&))
  {

return __pf(*this); }

  __ostream_type&
  operator<<(__ios_type& (*__pf)(__ios_type&))
  {

__pf(*this); return *this; }

  __ostream_type&
  operator<<(ios_base& (*__pf) (ios_base&))
  {

__pf(*this); return *this; }

165 “/usr/include/c++/5/ostream” 3

  __ostream_type&
  operator<<(long __n)
  { return _M_insert(__n); }

  __ostream_type&
  operator<<(unsigned long __n)
  { return _M_insert(__n); }

  __ostream_type&
  operator<<(bool __n)
  { return _M_insert(__n); }

  __ostream_type&
  operator<<(short __n);

  __ostream_type&
  operator<<(unsigned short __n)
  {

return _M_insert(static_cast(__n)); }

  __ostream_type&
  operator<<(int __n);

  __ostream_type&
  operator<<(unsigned int __n)
  {

return _M_insert(static_cast(__n)); }

  __ostream_type&
  operator<<(long long __n)
  { return _M_insert(__n); }

  __ostream_type&
  operator<<(unsigned long long __n)
  { return _M_insert(__n); }

219 “/usr/include/c++/5/ostream” 3

  __ostream_type&
  operator<<(double __f)
  { return _M_insert(__f); }

  __ostream_type&
  operator<<(float __f)
  {

return _M_insert(static_cast(__f)); }

  __ostream_type&
  operator<<(long double __f)
  { return _M_insert(__f); }

244 “/usr/include/c++/5/ostream” 3

  __ostream_type&
  operator<<(const void* __p)
  { return _M_insert(__p); }

269 “/usr/include/c++/5/ostream” 3

  __ostream_type&
  operator<<(__streambuf_type* __sb);

302 “/usr/include/c++/5/ostream” 3

  __ostream_type&
  put(char_type __c);






  void
  _M_write(const char_type* __s, streamsize __n)
  {

const streamsize __put = this→rdbuf()→sputn(__s, __n); if (__put != __n) this→setstate(ios_base::badbit); }

334 “/usr/include/c++/5/ostream” 3

  __ostream_type&
  write(const char_type* __s, streamsize __n);

347 “/usr/include/c++/5/ostream” 3

  __ostream_type&
  flush();

357 “/usr/include/c++/5/ostream” 3

  pos_type
  tellp();

368 “/usr/include/c++/5/ostream” 3

  __ostream_type&
  seekp(pos_type);

380 “/usr/include/c++/5/ostream” 3

   __ostream_type&
  seekp(off_type, ios_base::seekdir);

protected:
  basic_ostream()
  { this->init(0); }

413 “/usr/include/c++/5/ostream” 3

  template<typename _ValueT>

__ostream_type& _M_insert(_ValueT __v); };

425 “/usr/include/c++/5/ostream” 3

template <typename _CharT, typename _Traits> class basic_ostream<_CharT, _Traits>::sentry {

  bool _M_ok;
  basic_ostream<_CharT, _Traits>& _M_os;

public:

444 “/usr/include/c++/5/ostream” 3

  explicit
  sentry(basic_ostream<_CharT, _Traits>& __os);

454 “/usr/include/c++/5/ostream” 3

  ~sentry()
  {

if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception()) {

 if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
   _M_os.setstate(ios_base::badbit);

} }

475 “/usr/include/c++/5/ostream” 3

  operator bool() const
  { return _M_ok; }
};

495 “/usr/include/c++/5/ostream” 3

template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) { return __ostream_insert(__out, &__c, 1); }

template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) { return (__out << __out.widen(__c)); }

template inline basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __out, char __c) { return __ostream_insert(__out, &__c, 1); }

template inline basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __out, signed char __c) { return (__out << static_cast(__c)); }

template inline basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c) { return (__out << static_cast(__c)); }

537 “/usr/include/c++/5/ostream” 3

template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) { if (!__s) __out.setstate(ios_base::badbit); else __ostream_insert(__out, __s, static_cast(_Traits::length(__s))); return __out; }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits> & operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);

template inline basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __out, const char* __s) { if (!__s) __out.setstate(ios_base::badbit); else __ostream_insert(__out, __s, static_cast(_Traits::length(__s))); return __out; }

template inline basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s) { return (__out << reinterpret_cast<const char*>(__s)); }

template inline basic_ostream<char, _Traits> & operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s) { return (__out << reinterpret_cast<const char*>(__s)); }

588 “/usr/include/c++/5/ostream” 3

template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& endl(basic_ostream<_CharT, _Traits>& __os) { return flush(__os.put(__os.widen(‘\n’))); }

600 “/usr/include/c++/5/ostream” 3

template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& ends(basic_ostream<_CharT, _Traits>& __os) { return __os.put(_CharT()); }

template<typename _CharT, typename _Traits> inline basic_ostream<_CharT, _Traits>& flush(basic_ostream<_CharT, _Traits>& __os) { return __os.flush(); }

635 “/usr/include/c++/5/ostream” 3

}

1 “/usr/include/c++/5/bits/ostream.tcc” 1 3

37 “/usr/include/c++/5/bits/ostream.tcc” 3

38 “/usr/include/c++/5/bits/ostream.tcc” 3

namespace std attribute ((visibility (“default”))) {

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>::sentry:: sentry(basic_ostream<_CharT, _Traits>& __os) : _M_ok(false), _M_os(__os) {

  if (__os.tie() && __os.good())

__os.tie()→flush();

  if (__os.good())

_M_ok = true; else __os.setstate(ios_base::failbit); }

template<typename _CharT, typename _Traits> template basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: _M_insert(_ValueT __v) { sentry __cerb(*this); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const __num_put_type& __np = __check_facet(this→_M_num_put); if (__np.put(*this, *this, this→fill(), __v).failed()) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: operator<<(short __n) {

  const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
  if (__fmt == ios_base::oct || __fmt == ios_base::hex)

return _M_insert(static_cast(static_cast(__n))); else return _M_insert(static_cast(__n)); }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: operator<<(int __n) {

  const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
  if (__fmt == ios_base::oct || __fmt == ios_base::hex)

return _M_insert(static_cast(static_cast(__n))); else return _M_insert(static_cast(__n)); }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: operator<<(__streambuf_type* __sbin) { ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this); if (__cerb && __sbin) { try { if (!__copy_streambufs(__sbin, this→rdbuf())) __err |= ios_base::failbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::failbit); } } else if (!__sbin) __err |= ios_base::badbit; if (__err) this→setstate(__err); return *this; }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: put(char_type __c) {

  sentry __cerb(*this);
  if (__cerb)

{ ios_base::iostate __err = ios_base::goodbit; try { const int_type __put = this→rdbuf()→sputc(__c); if (traits_type::eq_int_type(__put, traits_type::eof())) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: write(const _CharT* __s, streamsize __n) {

  sentry __cerb(*this);
  if (__cerb)

{ try { _M_write(__s, __n); } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } } return *this; }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: flush() {

  ios_base::iostate __err = ios_base::goodbit;
  try

{ if (this→rdbuf() && this→rdbuf()→pubsync() == -1) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); return *this; }

template<typename _CharT, typename _Traits> typename basic_ostream<_CharT, _Traits>::pos_type basic_ostream<_CharT, _Traits>:: tellp() { pos_type __ret = pos_type(-1); try { if (!this→fail()) __ret = this→rdbuf()→pubseekoff(0, ios_base::cur, ios_base::out); } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } return __ret; }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: seekp(pos_type __pos) { ios_base::iostate __err = ios_base::goodbit; try { if (!this→fail()) {

   const pos_type __p = this->rdbuf()->pubseekpos(__pos,
        ios_base::out);


   if (__p == pos_type(off_type(-1)))

__err |= ios_base::failbit; } } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); return *this; }

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>:: seekp(off_type __off, ios_base::seekdir __dir) { ios_base::iostate __err = ios_base::goodbit; try { if (!this→fail()) {

   const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
        ios_base::out);


   if (__p == pos_type(off_type(-1)))

template<typename _CharT, typename _Traits> basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s) { if (!__s) __out.setstate(ios_base::badbit); else {

const size_t __clen = char_traits::length(__s); try { struct __ptr_guard { _CharT *__p; __ptr_guard (_CharT __ip): __p(__ip) { } ~__ptr_guard() { delete[] __p; } _CharT __get() { return __p; } } __pg (new _CharT[__clen]);

   _CharT *__ws = __pg.__get();
   for (size_t __i = 0; __i < __clen; ++__i)

__ws[__i] = __out.widen(__s[__i]); __ostream_insert(__out, __ws, __clen); } catch(__cxxabiv1::__forced_unwind&) { __out._M_setstate(ios_base::badbit); throw; } catch(…) { __out._M_setstate(ios_base::badbit); } } return __out; }

extern template class basic_ostream; extern template ostream& endl(ostream&); extern template ostream& ends(ostream&); extern template ostream& flush(ostream&); extern template ostream& operator<<(ostream&, char); extern template ostream& operator<<(ostream&, unsigned char); extern template ostream& operator<<(ostream&, signed char); extern template ostream& operator<<(ostream&, const char*); extern template ostream& operator<<(ostream&, const unsigned char*); extern template ostream& operator<<(ostream&, const signed char*);

extern template ostream& ostream::_M_insert(long); extern template ostream& ostream::_M_insert(unsigned long); extern template ostream& ostream::_M_insert(bool);

extern template ostream& ostream::_M_insert(long long); extern template ostream& ostream::_M_insert(unsigned long long);

extern template ostream& ostream::_M_insert(double); extern template ostream& ostream::_M_insert(long double); extern template ostream& ostream::_M_insert(const void*);

extern template class basic_ostream<wchar_t>; extern template wostream& endl(wostream&); extern template wostream& ends(wostream&); extern template wostream& flush(wostream&); extern template wostream& operator<<(wostream&, wchar_t); extern template wostream& operator<<(wostream&, char); extern template wostream& operator<<(wostream&, const wchar_t*); extern template wostream& operator<<(wostream&, const char*);

extern template wostream& wostream::_M_insert(long); extern template wostream& wostream::_M_insert(unsigned long); extern template wostream& wostream::_M_insert(bool);

extern template wostream& wostream::_M_insert(long long); extern template wostream& wostream::_M_insert(unsigned long long);

extern template wostream& wostream::_M_insert(double); extern template wostream& wostream::_M_insert(long double); extern template wostream& wostream::_M_insert(const void*);

}

639 “/usr/include/c++/5/ostream” 2 3

40 “/usr/include/c++/5/iostream” 2 3

1 “/usr/include/c++/5/istream” 1 3

36 “/usr/include/c++/5/istream” 3

37 “/usr/include/c++/5/istream” 3

namespace std attribute ((visibility (“default”))) {

57 “/usr/include/c++/5/istream” 3

template<typename _CharT, typename _Traits> class basic_istream : virtual public basic_ios<_CharT, _Traits> { public:

  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;


  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
  typedef basic_ios<_CharT, _Traits> __ios_type;
  typedef basic_istream<_CharT, _Traits> __istream_type;
  typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
    __num_get_type;
  typedef ctype<_CharT> __ctype_type;

protected:





  streamsize _M_gcount;

public:







  explicit
  basic_istream(__streambuf_type* __sb)
  : _M_gcount(streamsize(0))
  { this->init(__sb); }






  virtual
  ~basic_istream()
  { _M_gcount = streamsize(0); }


  class sentry;
  friend class sentry;

119 “/usr/include/c++/5/istream” 3

  __istream_type&
  operator>>(__istream_type& (*__pf)(__istream_type&))
  { return __pf(*this); }

  __istream_type&
  operator>>(__ios_type& (*__pf)(__ios_type&))
  {

__pf(*this); return *this; }

  __istream_type&
  operator>>(ios_base& (*__pf)(ios_base&))
  {

__pf(*this); return *this; }

167 “/usr/include/c++/5/istream” 3

  __istream_type&
  operator>>(bool& __n)
  { return _M_extract(__n); }

  __istream_type&
  operator>>(short& __n);

  __istream_type&
  operator>>(unsigned short& __n)
  { return _M_extract(__n); }

  __istream_type&
  operator>>(int& __n);

  __istream_type&
  operator>>(unsigned int& __n)
  { return _M_extract(__n); }

  __istream_type&
  operator>>(long& __n)
  { return _M_extract(__n); }

  __istream_type&
  operator>>(unsigned long& __n)
  { return _M_extract(__n); }


  __istream_type&
  operator>>(long long& __n)
  { return _M_extract(__n); }

  __istream_type&
  operator>>(unsigned long long& __n)
  { return _M_extract(__n); }

213 “/usr/include/c++/5/istream” 3

  __istream_type&
  operator>>(float& __f)
  { return _M_extract(__f); }

  __istream_type&
  operator>>(double& __f)
  { return _M_extract(__f); }

  __istream_type&
  operator>>(long double& __f)
  { return _M_extract(__f); }

234 “/usr/include/c++/5/istream” 3

  __istream_type&
  operator>>(void*& __p)
  { return _M_extract(__p); }

258 “/usr/include/c++/5/istream” 3

  __istream_type&
  operator>>(__streambuf_type* __sb);

268 “/usr/include/c++/5/istream” 3

  streamsize
  gcount() const
  { return _M_gcount; }

301 “/usr/include/c++/5/istream” 3

  int_type
  get();

315 “/usr/include/c++/5/istream” 3

  __istream_type&
  get(char_type& __c);

342 “/usr/include/c++/5/istream” 3

  __istream_type&
  get(char_type* __s, streamsize __n, char_type __delim);

353 “/usr/include/c++/5/istream” 3

  __istream_type&
  get(char_type* __s, streamsize __n)
  { return this->get(__s, __n, this->widen('\n')); }

376 “/usr/include/c++/5/istream” 3

  __istream_type&
  get(__streambuf_type& __sb, char_type __delim);

386 “/usr/include/c++/5/istream” 3

  __istream_type&
  get(__streambuf_type& __sb)
  { return this->get(__sb, this->widen('\n')); }

415 “/usr/include/c++/5/istream” 3

  __istream_type&
  getline(char_type* __s, streamsize __n, char_type __delim);

426 “/usr/include/c++/5/istream” 3

  __istream_type&
  getline(char_type* __s, streamsize __n)
  { return this->getline(__s, __n, this->widen('\n')); }

450 “/usr/include/c++/5/istream” 3

  __istream_type&
  ignore(streamsize __n, int_type __delim);

  __istream_type&
  ignore(streamsize __n);

  __istream_type&
  ignore();

467 “/usr/include/c++/5/istream” 3

  int_type
  peek();

485 “/usr/include/c++/5/istream” 3

  __istream_type&
  read(char_type* __s, streamsize __n);

504 “/usr/include/c++/5/istream” 3

  streamsize
  readsome(char_type* __s, streamsize __n);

521 “/usr/include/c++/5/istream” 3

  __istream_type&
  putback(char_type __c);

537 “/usr/include/c++/5/istream” 3

  __istream_type&
  unget();

555 “/usr/include/c++/5/istream” 3

  int
  sync();

570 “/usr/include/c++/5/istream” 3

  pos_type
  tellg();

585 “/usr/include/c++/5/istream” 3

  __istream_type&
  seekg(pos_type);

601 “/usr/include/c++/5/istream” 3

  __istream_type&
  seekg(off_type, ios_base::seekdir);


protected:
  basic_istream()
  : _M_gcount(streamsize(0))
  { this->init(0); }

639 “/usr/include/c++/5/istream” 3

  template<typename _ValueT>

__istream_type& _M_extract(_ValueT& __v); };

template<> basic_istream& basic_istream:: getline(char_type* __s, streamsize __n, char_type __delim);

template<> basic_istream& basic_istream:: ignore(streamsize __n);

template<> basic_istream& basic_istream:: ignore(streamsize __n, int_type __delim);

template<> basic_istream<wchar_t>& basic_istream<wchar_t>:: getline(char_type* __s, streamsize __n, char_type __delim);

template<> basic_istream<wchar_t>& basic_istream<wchar_t>:: ignore(streamsize __n);

template<> basic_istream<wchar_t>& basic_istream<wchar_t>:: ignore(streamsize __n, int_type __delim);

685 “/usr/include/c++/5/istream” 3

template<typename _CharT, typename _Traits> class basic_istream<_CharT, _Traits>::sentry {

  bool _M_ok;

public:

  typedef _Traits traits_type;
  typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
  typedef basic_istream<_CharT, _Traits> __istream_type;
  typedef typename __istream_type::__ctype_type __ctype_type;
  typedef typename _Traits::int_type __int_type;

721 “/usr/include/c++/5/istream” 3

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

734 “/usr/include/c++/5/istream” 3

  operator bool() const
  { return _M_ok; }
};

750 “/usr/include/c++/5/istream” 3

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

template inline basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c) { return (__in >> reinterpret_cast<char&>(__c)); }

template inline basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& __in, signed char& __c) { return (__in >> reinterpret_cast<char&>(__c)); }

792 “/usr/include/c++/5/istream” 3

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);

template<> basic_istream& operator>>(basic_istream& __in, char* __s);

template inline basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s) { return (__in >> reinterpret_cast<char*>(__s)); }

template inline basic_istream<char, _Traits>& operator>>(basic_istream<char, _Traits>& __in, signed char* __s) { return (__in >> reinterpret_cast<char*>(__s)); }

823 “/usr/include/c++/5/istream” 3

template<typename _CharT, typename _Traits> class basic_iostream : public basic_istream<_CharT, _Traits>, public basic_ostream<_CharT, _Traits> { public:

  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;


  typedef basic_istream<_CharT, _Traits> __istream_type;
  typedef basic_ostream<_CharT, _Traits> __ostream_type;







  explicit
  basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
  : __istream_type(__sb), __ostream_type(__sb) { }




  virtual
  ~basic_iostream() { }

protected:
  basic_iostream()
  : __istream_type(), __ostream_type() { }

884 “/usr/include/c++/5/istream” 3

};

906 “/usr/include/c++/5/istream” 3

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& ws(basic_istream<_CharT, _Traits>& __is);

931 “/usr/include/c++/5/istream” 3

}

1 “/usr/include/c++/5/bits/istream.tcc” 1 3

37 “/usr/include/c++/5/bits/istream.tcc” 3

38 “/usr/include/c++/5/bits/istream.tcc” 3

namespace std attribute ((visibility (“default”))) {

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>::sentry:: sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) { ios_base::iostate __err = ios_base::goodbit; if (__in.good()) { if (__in.tie()) __in.tie()→flush(); if (!__noskip && bool(__in.flags() & ios_base::skipws)) { const __int_type __eof = traits_type::eof(); __streambuf_type* __sb = __in.rdbuf(); __int_type __c = __sb→sgetc();

   const __ctype_type& __ct = __check_facet(__in._M_ctype);
   while (!traits_type::eq_int_type(__c, __eof)
   && __ct.is(ctype_base::space,
traits_type::to_char_type(__c)))

__c = __sb→snextc();

   if (traits_type::eq_int_type(__c, __eof))

__err |= ios_base::eofbit; } }

  if (__in.good() && __err == ios_base::goodbit)

_M_ok = true; else { __err |= ios_base::failbit; __in.setstate(__err); } }

template<typename _CharT, typename _Traits> template basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: _M_extract(_ValueT& __v) { sentry __cerb(*this, false); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const __num_get_type& __ng = __check_facet(this→_M_num_get); __ng.get(*this, 0, *this, __err, __v); } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: operator>>(short& __n) {

  sentry __cerb(*this, false);
  if (__cerb)

{ ios_base::iostate __err = ios_base::goodbit; try { long __l; const __num_get_type& __ng = __check_facet(this→_M_num_get); __ng.get(*this, 0, *this, __err, __l);

   if (__l < __gnu_cxx::__numeric_traits<short>::__min)

{ __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__min; } else if (__l > __gnu_cxx::__numeric_traits::__max) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__max; } else __n = short(__l); } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: operator>>(int& __n) {

  sentry __cerb(*this, false);
  if (__cerb)

{ ios_base::iostate __err = ios_base::goodbit; try { long __l; const __num_get_type& __ng = __check_facet(this→_M_num_get); __ng.get(*this, 0, *this, __err, __l);

   if (__l < __gnu_cxx::__numeric_traits<int>::__min)

{ __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__min; } else if (__l > __gnu_cxx::__numeric_traits::__max) { __err |= ios_base::failbit; __n = __gnu_cxx::__numeric_traits::__max; } else __n = int(__l); } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: operator>>(__streambuf_type* __sbout) { ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, false); if (__cerb && __sbout) { try { bool __ineof; if (!__copy_streambufs_eof(this→rdbuf(), __sbout, __ineof)) __err |= ios_base::failbit; if (__ineof) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::failbit); throw; } catch(…) { this→_M_setstate(ios_base::failbit); } } else if (!__sbout) __err |= ios_base::failbit; if (__err) this→setstate(__err); return *this; }

template<typename _CharT, typename _Traits> typename basic_istream<_CharT, _Traits>::int_type basic_istream<_CharT, _Traits>:: get(void) { const int_type __eof = traits_type::eof(); int_type __c = __eof; _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { __c = this→rdbuf()→sbumpc();

   if (!traits_type::eq_int_type(__c, __eof))

_M_gcount = 1; else __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } } if (!_M_gcount) __err |= ios_base::failbit; if (__err) this→setstate(__err); return __c; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: get(char_type& __c) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(*this, true); if (__cerb) { try { const int_type __cb = this→rdbuf()→sbumpc();

   if (!traits_type::eq_int_type(__cb, traits_type::eof()))

{ _M_gcount = 1; __c = traits_type::to_char_type(__cb); } else __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } } if (!_M_gcount) __err |= ios_base::failbit; if (__err) this→setstate(__err); return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: get(char_type* __s, streamsize __n, char_type __delim) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(this, true); if (__cerb) { try { const int_type __idelim = traits_type::to_int_type(__delim); const int_type __eof = traits_type::eof(); __streambuf_type __sb = this→rdbuf(); int_type __c = __sb→sgetc();

   while (_M_gcount + 1 < __n
   && !traits_type::eq_int_type(__c, __eof)
   && !traits_type::eq_int_type(__c, __idelim))

{ *__s++ = traits_type::to_char_type(__c); ++_M_gcount; __c = __sb→snextc(); } if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } }

  if (__n > 0)

*__s = char_type(); if (!_M_gcount) __err |= ios_base::failbit; if (__err) this→setstate(__err); return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: get(__streambuf_type& __sb, char_type __delim) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(this, true); if (__cerb) { try { const int_type __idelim = traits_type::to_int_type(__delim); const int_type __eof = traits_type::eof(); __streambuf_type __this_sb = this→rdbuf(); int_type __c = __this_sb→sgetc(); char_type __c2 = traits_type::to_char_type(__c);

   while (!traits_type::eq_int_type(__c, __eof)
   && !traits_type::eq_int_type(__c, __idelim)
   && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))

{ ++_M_gcount; __c = __this_sb→snextc(); __c2 = traits_type::to_char_type(__c); } if (traits_type::eq_int_type(__c, __eof)) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } } if (!_M_gcount) __err |= ios_base::failbit; if (__err) this→setstate(__err); return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: getline(char_type* __s, streamsize __n, char_type __delim) { _M_gcount = 0; ios_base::iostate __err = ios_base::goodbit; sentry __cerb(this, true); if (__cerb) { try { const int_type __idelim = traits_type::to_int_type(__delim); const int_type __eof = traits_type::eof(); __streambuf_type __sb = this→rdbuf(); int_type __c = __sb→sgetc();

          while (_M_gcount + 1 < __n
                 && !traits_type::eq_int_type(__c, __eof)
                 && !traits_type::eq_int_type(__c, __idelim))
            {
              *__s++ = traits_type::to_char_type(__c);
              __c = __sb->snextc();
              ++_M_gcount;
            }
          if (traits_type::eq_int_type(__c, __eof))
            __err |= ios_base::eofbit;
          else
            {
              if (traits_type::eq_int_type(__c, __idelim))
                {
                  __sb->sbumpc();
                  ++_M_gcount;
                }
              else
                __err |= ios_base::failbit;
            }
        }

catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } }

  if (__n > 0)

*__s = char_type(); if (!_M_gcount) __err |= ios_base::failbit; if (__err) this→setstate(__err); return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: ignore(void) { _M_gcount = 0; sentry __cerb(this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type __sb = this→rdbuf();

   if (traits_type::eq_int_type(__sb->sbumpc(), __eof))

__err |= ios_base::eofbit; else _M_gcount = 1; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: ignore(streamsize __n) { _M_gcount = 0; sentry __cerb(this, true); if (__cerb && __n > 0) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type __sb = this→rdbuf(); int_type __c = __sb→sgetc();

513 “/usr/include/c++/5/bits/istream.tcc” 3

   bool __large_ignore = false;
   while (true)

{ while (_M_gcount < __n && !traits_type::eq_int_type(__c, __eof)) { ++_M_gcount; __c = __sb→snextc(); } if (__n == __gnu_cxx::__numeric_traits::__max && !traits_type::eq_int_type(__c, __eof)) { _M_gcount = __gnu_cxx::__numeric_traits::__min; __large_ignore = true; } else break; }

   if (__large_ignore)

_M_gcount = __gnu_cxx::__numeric_traits::__max;

   if (traits_type::eq_int_type(__c, __eof))
            __err |= ios_base::eofbit;
        }

catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: ignore(streamsize __n, int_type __delim) { _M_gcount = 0; sentry __cerb(this, true); if (__cerb && __n > 0) { ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type __sb = this→rdbuf(); int_type __c = __sb→sgetc();

   bool __large_ignore = false;
   while (true)

{ while (_M_gcount < __n && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __delim)) { ++_M_gcount; __c = __sb→snextc(); } if (__n == __gnu_cxx::__numeric_traits::__max && !traits_type::eq_int_type(__c, __eof) && !traits_type::eq_int_type(__c, __delim)) { _M_gcount = __gnu_cxx::__numeric_traits::__min; __large_ignore = true; } else break; }

   if (__large_ignore)

_M_gcount = __gnu_cxx::__numeric_traits::__max;

          if (traits_type::eq_int_type(__c, __eof))
            __err |= ios_base::eofbit;
   else if (traits_type::eq_int_type(__c, __delim))

{ if (_M_gcount < __gnu_cxx::__numeric_traits::__max) ++_M_gcount; __sb→sbumpc(); } } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> typename basic_istream<_CharT, _Traits>::int_type basic_istream<_CharT, _Traits>:: peek(void) { int_type __c = traits_type::eof(); _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { __c = this→rdbuf()→sgetc(); if (traits_type::eq_int_type(__c, traits_type::eof())) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return __c; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: read(char_type* __s, streamsize __n) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try { _M_gcount = this→rdbuf()→sgetn(__s, __n); if (_M_gcount != __n) __err |= (ios_base::eofbit | ios_base::failbit); } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> streamsize basic_istream<_CharT, _Traits>:: readsome(char_type* __s, streamsize __n) { _M_gcount = 0; sentry __cerb(*this, true); if (__cerb) { ios_base::iostate __err = ios_base::goodbit; try {

   const streamsize __num = this->rdbuf()->in_avail();
   if (__num > 0)

_M_gcount = this→rdbuf()→sgetn(__s, std::min(__num, __n)); else if (__num == -1) __err |= ios_base::eofbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return _M_gcount; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: putback(char_type __c) {

  _M_gcount = 0;

  this->clear(this->rdstate() & ~ios_base::eofbit);
  sentry __cerb(*this, true);
  if (__cerb)

{ ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this→rdbuf(); if (!__sb || traits_type::eq_int_type(__sb→sputbackc(__c), __eof)) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: unget(void) {

  _M_gcount = 0;

  this->clear(this->rdstate() & ~ios_base::eofbit);
  sentry __cerb(*this, true);
  if (__cerb)

{ ios_base::iostate __err = ios_base::goodbit; try { const int_type __eof = traits_type::eof(); __streambuf_type* __sb = this→rdbuf(); if (!__sb || traits_type::eq_int_type(__sb→sungetc(), __eof)) __err |= ios_base::badbit; } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> int basic_istream<_CharT, _Traits>:: sync(void) {

  int __ret = -1;
  sentry __cerb(*this, true);
  if (__cerb)

{ ios_base::iostate __err = ios_base::goodbit; try { __streambuf_type* __sb = this→rdbuf(); if (__sb) { if (__sb→pubsync() == -1) __err |= ios_base::badbit; else __ret = 0; } } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return __ret; }

template<typename _CharT, typename _Traits> typename basic_istream<_CharT, _Traits>::pos_type basic_istream<_CharT, _Traits>:: tellg(void) {

  pos_type __ret = pos_type(-1);
  sentry __cerb(*this, true);
  if (__cerb)

{ try { if (!this→fail()) __ret = this→rdbuf()→pubseekoff(0, ios_base::cur, ios_base::in); } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } } return __ret; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: seekg(pos_type __pos) {

  this->clear(this->rdstate() & ~ios_base::eofbit);
  sentry __cerb(*this, true);
  if (__cerb)

{ ios_base::iostate __err = ios_base::goodbit; try { if (!this→fail()) {

const pos_type __p = this->rdbuf()->pubseekpos(__pos,
     ios_base::in);


if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;

} } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>:: seekg(off_type __off, ios_base::seekdir __dir) {

  this->clear(this->rdstate() & ~ios_base::eofbit);
  sentry __cerb(*this, true);
  if (__cerb)

{ ios_base::iostate __err = ios_base::goodbit; try { if (!this→fail()) {

const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
     ios_base::in);


if (__p == pos_type(off_type(-1)))
  __err |= ios_base::failbit;

} } catch(__cxxabiv1::__forced_unwind&) { this→_M_setstate(ios_base::badbit); throw; } catch(…) { this→_M_setstate(ios_base::badbit); } if (__err) this→setstate(__err); } return *this; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef typename __istream_type::int_type __int_type;

  typename __istream_type::sentry __cerb(__in, false);
  if (__cerb)

{ ios_base::iostate __err = ios_base::goodbit; try { const __int_type __cb = __in.rdbuf()→sbumpc(); if (!_Traits::eq_int_type(__cb, _Traits::eof())) __c = _Traits::to_char_type(__cb); else __err |= (ios_base::eofbit | ios_base::failbit); } catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(ios_base::badbit); throw; } catch(…) { __in._M_setstate(ios_base::badbit); } if (__err) __in.setstate(__err); } return __in; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef typename _Traits::int_type int_type; typedef _CharT char_type; typedef ctype<_CharT> __ctype_type;

  streamsize __extracted = 0;
  ios_base::iostate __err = ios_base::goodbit;
  typename __istream_type::sentry __cerb(__in, false);
  if (__cerb)

{ try {

   streamsize __num = __in.width();
   if (__num <= 0)

__num = __gnu_cxx::__numeric_traits::__max;

   const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());

   const int_type __eof = _Traits::eof();
   __streambuf_type* __sb = __in.rdbuf();
   int_type __c = __sb->sgetc();

   while (__extracted < __num - 1
   && !_Traits::eq_int_type(__c, __eof)
   && !__ct.is(ctype_base::space,
 _Traits::to_char_type(__c)))

{ *__s++ = _Traits::to_char_type(__c); ++__extracted; __c = __sb→snextc(); } if (_Traits::eq_int_type(__c, __eof)) __err |= ios_base::eofbit;

   *__s = char_type();
   __in.width(0);
 }

catch(__cxxabiv1::__forced_unwind&) { __in._M_setstate(ios_base::badbit); throw; } catch(…) { __in._M_setstate(ios_base::badbit); } } if (!__extracted) __err |= ios_base::failbit; if (__err) __in.setstate(__err); return __in; }

template<typename _CharT, typename _Traits> basic_istream<_CharT, _Traits>& ws(basic_istream<_CharT, _Traits>& __in) { typedef basic_istream<_CharT, _Traits> __istream_type; typedef basic_streambuf<_CharT, _Traits> __streambuf_type; typedef typename __istream_type::int_type __int_type; typedef ctype<_CharT> __ctype_type;

  const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
  const __int_type __eof = _Traits::eof();
  __streambuf_type* __sb = __in.rdbuf();
  __int_type __c = __sb->sgetc();

  while (!_Traits::eq_int_type(__c, __eof)
  && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))

__c = __sb→snextc();

   if (_Traits::eq_int_type(__c, __eof))

__in.setstate(ios_base::eofbit); return __in; }

extern template class basic_istream; extern template istream& ws(istream&); extern template istream& operator>>(istream&, char&); extern template istream& operator>>(istream&, char*); extern template istream& operator>>(istream&, unsigned char&); extern template istream& operator>>(istream&, signed char&); extern template istream& operator>>(istream&, unsigned char*); extern template istream& operator>>(istream&, signed char*);

extern template istream& istream::_M_extract(unsigned short&); extern template istream& istream::_M_extract(unsigned int&); extern template istream& istream::_M_extract(long&); extern template istream& istream::_M_extract(unsigned long&); extern template istream& istream::_M_extract(bool&);

extern template istream& istream::_M_extract(long long&); extern template istream& istream::_M_extract(unsigned long long&);

extern template istream& istream::_M_extract(float&); extern template istream& istream::_M_extract(double&); extern template istream& istream::_M_extract(long double&); extern template istream& istream::_M_extract(void*&);

extern template class basic_iostream;

extern template class basic_istream<wchar_t>; extern template wistream& ws(wistream&); extern template wistream& operator>>(wistream&, wchar_t&); extern template wistream& operator>>(wistream&, wchar_t*);

extern template wistream& wistream::_M_extract(unsigned short&); extern template wistream& wistream::_M_extract(unsigned int&); extern template wistream& wistream::_M_extract(long&); extern template wistream& wistream::_M_extract(unsigned long&); extern template wistream& wistream::_M_extract(bool&);

extern template wistream& wistream::_M_extract(long long&); extern template wistream& wistream::_M_extract(unsigned long long&);

extern template wistream& wistream::_M_extract(float&); extern template wistream& wistream::_M_extract(double&); extern template wistream& wistream::_M_extract(long double&); extern template wistream& wistream::_M_extract(void*&);

extern template class basic_iostream<wchar_t>;

}

935 “/usr/include/c++/5/istream” 2 3

41 “/usr/include/c++/5/iostream” 2 3

namespace std attribute ((visibility (“default”))) {

60 “/usr/include/c++/5/iostream” 3

extern istream cin; extern ostream cout; extern ostream cerr; extern ostream clog;

extern wistream wcin; extern wostream wcout; extern wostream wcerr; extern wostream wclog;

static ios_base::Init __ioinit;

}

2 “driver.cpp” 2

2 “driver.cpp”

using namespace std;

int main() { cout << “Hello, world!” << endl; return 0; }

StudC++

Проводник

7EDJTPKK.cpp

1 “driver.cpp”

1 ""

1 ""

1 “/usr/include/stdc-predef.h” 1 3 4

1 "" 2

1 “driver.cpp”

1 “/usr/include/c++/5/iostream” 1 3

36 “/usr/include/c++/5/iostream” 3

37 “/usr/include/c++/5/iostream” 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 1 3

194 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 3

194 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 3

216 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 3

482 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/os_defines.h” 1 3

39 “/usr/include/x86_64-linux-gnu/c++/5/bits/os_defines.h” 3

1 “/usr/include/features.h” 1 3 4

367 “/usr/include/features.h” 3 4

1 “/usr/include/x86_64-linux-gnu/sys/cdefs.h” 1 3 4

410 “/usr/include/x86_64-linux-gnu/sys/cdefs.h” 3 4

1 “/usr/include/x86_64-linux-gnu/bits/wordsize.h” 1 3 4

411 “/usr/include/x86_64-linux-gnu/sys/cdefs.h” 2 3 4

368 “/usr/include/features.h” 2 3 4

391 “/usr/include/features.h” 3 4

1 “/usr/include/x86_64-linux-gnu/gnu/stubs.h” 1 3 4

10 “/usr/include/x86_64-linux-gnu/gnu/stubs.h” 3 4

1 “/usr/include/x86_64-linux-gnu/gnu/stubs-64.h” 1 3 4

11 “/usr/include/x86_64-linux-gnu/gnu/stubs.h” 2 3 4

392 “/usr/include/features.h” 2 3 4

40 “/usr/include/x86_64-linux-gnu/c++/5/bits/os_defines.h” 2 3

483 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 2 3

1 “/usr/include/x86_64-linux-gnu/c++/5/bits/cpu_defines.h” 1 3

486 “/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h” 2 3

39 “/usr/include/c++/5/iostream” 2 3

1 “/usr/include/c++/5/ostream” 1 3

36 “/usr/include/c++/5/ostream” 3

37 “/usr/include/c++/5/ostream” 3

1 “/usr/include/c++/5/ios” 1 3

36 “/usr/include/c++/5/ios” 3

37 “/usr/include/c++/5/ios” 3

1 “/usr/include/c++/5/iosfwd” 1 3

36 “/usr/include/c++/5/iosfwd” 3

37 “/usr/include/c++/5/iosfwd” 3

1 “/usr/include/c++/5/bits/stringfwd.h” 1 3

37 “/usr/include/c++/5/bits/stringfwd.h” 3

38 “/usr/include/c++/5/bits/stringfwd.h” 3

1 “/usr/include/c++/5/bits/memoryfwd.h” 1 3

46 “/usr/include/c++/5/bits/memoryfwd.h” 3

47 “/usr/include/c++/5/bits/memoryfwd.h” 3

63 “/usr/include/c++/5/bits/memoryfwd.h” 3

41 “/usr/include/c++/5/bits/stringfwd.h” 2 3

67 “/usr/include/c++/5/bits/stringfwd.h” 3

90 “/usr/include/c++/5/bits/stringfwd.h” 3

40 “/usr/include/c++/5/iosfwd” 2 3

1 “/usr/include/c++/5/bits/postypes.h” 1 3

38 “/usr/include/c++/5/bits/postypes.h” 3

39 “/usr/include/c++/5/bits/postypes.h” 3

1 “/usr/include/c++/5/cwchar” 1 3

39 “/usr/include/c++/5/cwchar” 3

40 “/usr/include/c++/5/cwchar” 3

1 “/usr/include/wchar.h” 1 3 4

36 “/usr/include/wchar.h” 3 4

1 “/usr/include/stdio.h” 1 3 4

44 “/usr/include/stdio.h” 3 4

64 “/usr/include/stdio.h” 3 4

37 “/usr/include/wchar.h” 2 3 4

1 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stdarg.h” 1 3 4

40 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stdarg.h” 3 4

40 “/usr/include/wchar.h” 2 3 4

1 “/usr/include/x86_64-linux-gnu/bits/wchar.h” 1 3 4

42 “/usr/include/wchar.h” 2 3 4

51 “/usr/include/wchar.h” 3 4

1 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h” 1 3 4

216 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h” 3 4

357 “/usr/lib/gcc/x86_64-linux-gnu/5/include/stddef.h” 3 4

52 “/usr/include/wchar.h” 2 3 4

82 “/usr/include/wchar.h” 3 4