Index: lib/StaticAnalyzer/Checkers/MallocChecker.cpp =================================================================== --- lib/StaticAnalyzer/Checkers/MallocChecker.cpp +++ lib/StaticAnalyzer/Checkers/MallocChecker.cpp @@ -2511,6 +2511,10 @@ return true; } + if (FName.endswith("postEvent") || FD->getQualifiedNameAsString() == "QCoreApplication::postEvent") { + return true; + } + // Handle cases where we know a buffer's /address/ can escape. // Note that the above checks handle some special cases where we know that // even though the address escapes, it's still our responsibility to free the Index: test/Analysis/qt_malloc.cpp =================================================================== --- test/Analysis/qt_malloc.cpp +++ test/Analysis/qt_malloc.cpp @@ -0,0 +1,42971 @@ +// RUN: %clang_cc1 -analyze -analyzer-checker=core,alpha.deadcode.UnreachableCode,alpha.core.CastSize,unix.Malloc,cplusplus -analyzer-store=region -verify %s +// expected-no-diagnostics + +# 1 "../test.cpp" +# 1 "" +# 1 "" +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 1 "" 2 +# 1 "../test.cpp" +# 1 "/usr/include/qt4/QtGui/QApplication" 1 3 4 +# 1 "/usr/include/qt4/QtGui/qapplication.h" 1 3 4 +# 45 "/usr/include/qt4/QtGui/qapplication.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qcoreapplication.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qcoreapplication.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qobject.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qobject.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qobjectdefs.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qobjectdefs.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qnamespace.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qglobal.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 3 4 + +# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 216 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 46 "/usr/include/qt4/QtCore/qglobal.h" 2 3 4 +# 62 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qconfig.h" 1 3 4 +# 1 "/usr/include/qt4/Gentoo/gentoo-qconfig.h" 1 3 4 +# 2 "/usr/include/qt4/QtCore/qconfig.h" 2 3 4 +# 12 "/usr/include/qt4/QtCore/qconfig.h" 3 4 +# 1 "/usr/include/x86_64-pc-linux-gnu/qt4/QtCore/qconfig.h" 1 3 4 +# 13 "/usr/include/qt4/QtCore/qconfig.h" 2 3 4 +# 63 "/usr/include/qt4/QtCore/qglobal.h" 2 3 4 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/algorithm" 1 3 4 +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/algorithm" 3 4 + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/algorithm" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/utility" 1 3 +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/utility" 3 + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/utility" 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/utility" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 194 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + + +} +# 216 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/os_defines.h" 3 +# 1 "/usr/include/features.h" 1 3 4 +# 366 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 402 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 403 "/usr/include/sys/cdefs.h" 2 3 4 +# 367 "/usr/include/features.h" 2 3 4 +# 390 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 391 "/usr/include/features.h" 2 3 4 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3 +# 483 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 486 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/utility" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_relops.h" 1 3 +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_relops.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + namespace rel_ops + { + +# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_relops.h" 3 + template + inline bool + operator!=(const _Tp& __x, const _Tp& __y) + { return !(__x == __y); } +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_relops.h" 3 + template + inline bool + operator>(const _Tp& __x, const _Tp& __y) + { return __y < __x; } +# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_relops.h" 3 + template + inline bool + operator<=(const _Tp& __x, const _Tp& __y) + { return !(__y < __x); } +# 124 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_relops.h" 3 + template + inline bool + operator>=(const _Tp& __x, const _Tp& __y) + { return !(__x < __y); } + + + } + +} +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/utility" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_pair.h" 1 3 +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_pair.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/move.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/move.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/concept_check.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/concept_check.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/concept_check.h" 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/move.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline _Tp* + __addressof(_Tp& __r) + { + return reinterpret_cast<_Tp*> + (&const_cast(reinterpret_cast(__r))); + } + + +} +# 159 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 174 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/move.h" 3 + template + inline void + swap(_Tp& __a, _Tp& __b) + + + + + { + + + + _Tp __tmp = (__a); + __a = (__b); + __b = (__tmp); + } + + + + + template + inline void + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + + + + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_pair.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 95 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_pair.h" 3 + template + 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 + pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) { } +# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_pair.h" 3 + }; + + + template + inline bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } + + + template + 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 + inline bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 284 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_pair.h" 3 + template + inline pair<_T1, _T2> + make_pair(_T1 __x, _T2 __y) + { return pair<_T1, _T2>(__x, __y); } + + + + + +} +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/utility" 2 3 +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/algorithm" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/functexcept.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/functexcept.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/exception_defines.h" 1 3 +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/cpp_type_traits.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/cpp_type_traits.h" 3 + +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/cpp_type_traits.h" 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/cpp_type_traits.h" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + template + 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 + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + 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 + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 270 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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_floating + { + enum { __value = 1 }; + typedef __true_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 + 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 + { + 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_byte + { + enum { __value = 1 }; + typedef __true_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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/cpp_type_traits.h" 3 + +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/type_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/type_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/type_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__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 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; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __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; + + + + template + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + inline bool + __is_null_pointer(_Type) + { return false; } +# 165 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/type_traits.h" 3 + template::__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::__type, + typename _Up2 = typename __promote<_Up>::__type> + struct __promote_2 + { + typedef __typeof__(_Tp2() + _Up2()) __type; + }; + + template::__type, + typename _Up2 = typename __promote<_Up>::__type, + typename _Vp2 = typename __promote<_Vp>::__type> + struct __promote_3 + { + typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type; + }; + + template::__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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/numeric_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/numeric_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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::__value, + __numeric_traits_integer<_Value>, + __numeric_traits_floating<_Value> >::__type + { }; + + +} +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_types.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_types.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_types.h" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 89 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_types.h" 3 + template + struct iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 165 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + { + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_types.h" 3 + +} +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_funcs.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_funcs.h" 3 + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_funcs.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/debug/debug.h" 1 3 +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; +} +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + inline void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + ; + while (__n--) + ++__i; + } + + template + inline void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + __i += __n; + } +# 171 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_funcs.h" 3 + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator_base_funcs.h" 3 + +} +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 1 3 +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ptr_traits.h" 1 3 +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public 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 + reverse_iterator(const reverse_iterator<_Iter>& __x) + : current(__x.base()) { } + + + + + iterator_type + base() const + { return current; } +# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + inline bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + inline bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __y.base() < __x.base(); } + + template + inline bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + template + inline bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __y < __x; } + + template + inline bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return !(__y < __x); } + + template + inline bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return !(__x < __y); } + + template + + + + + + + + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + explicit + back_insert_iterator(_Container& __x) : container(&__x) { } +# 441 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + back_insert_iterator& + operator=(typename _Container::const_reference __value) + { + container->push_back(__value); + return *this; + } +# 464 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + template + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 505 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + explicit front_insert_iterator(_Container& __x) : container(&__x) { } +# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + front_insert_iterator& + operator=(typename _Container::const_reference __value) + { + container->push_front(__value); + return *this; + } +# 554 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + template + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 599 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + insert_iterator& + operator=(typename _Container::const_reference __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } +# 668 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + insert_iterator& + operator*() + { return *this; } + + + insert_iterator& + operator++() + { return *this; } + + + insert_iterator& + operator++(int) + { return *this; } + }; +# 694 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + using std::iterator_traits; + using std::iterator; + template + 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 + __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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_iterator.h" 3 + template + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + + { return __lhs.base() == __rhs.base(); } + + template + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + + { return __lhs.base() == __rhs.base(); } + + template + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + + { return __lhs.base() != __rhs.base(); } + + template + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + + { return __lhs.base() != __rhs.base(); } + + + template + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + + { return __lhs.base() < __rhs.base(); } + + template + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + + { return __lhs.base() < __rhs.base(); } + + template + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + + { return __lhs.base() > __rhs.base(); } + + template + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + + { return __lhs.base() > __rhs.base(); } + + template + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + + { return __lhs.base() <= __rhs.base(); } + + template + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + + { return __lhs.base() <= __rhs.base(); } + + template + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + + { return __lhs.base() >= __rhs.base(); } + + template + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + + { return __lhs.base() >= __rhs.base(); } + + + + + + template + + + + + + + + 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 + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 2 3 + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/predefined_ops.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + + 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 + 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 + 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 + 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 + 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 + + 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 + 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 + 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 + 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 + 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 + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(__pred); } + + template + 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 + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + __iter_comp_val(_Compare __comp, _Value &__val) + { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); } + + template + 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 + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, _M_ref)); } + }; + + template + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + struct __iter_swap + { + template + 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 + static void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { + swap(*__a, *__b); + } + }; +# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, ++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 192 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 262 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + + 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 + struct __copy_move + { + template + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, ++__first) + *__result = *__first; + return __result; + } + }; +# 330 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template<> + struct __copy_move + { + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + 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 + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + 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 + 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 + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + 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))); + } +# 458 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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)); + } +# 510 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + struct __copy_move_backward + { + template + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; +# 538 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template<> + struct __copy_move_backward + { + template + 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; + } + }; +# 568 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + 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 + 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))); + } +# 632 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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)); + } +# 690 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + 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); + } +# 734 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(std::__niter_base(__first), std::__niter_base(__last), + __value); + } + + template + inline typename + __gnu_cxx::__enable_if::__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 + 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 + 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; + } +# 794 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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 + 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 + 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 + struct __lc_rai + { + template + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + 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 + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + 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 + static bool __lc(_II1, _II1, _II2, _II2); + }; + + template + template + 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 + 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 + 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 + _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; + } +# 994 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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); } + + + + +# 1051 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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)); + } +# 1083 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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; + } +# 1211 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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)); + } +# 1247 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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 + 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); + } +# 1290 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1323 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + template + 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)); + } +# 1423 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algobase.h" 3 + +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/algorithm" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 1 3 +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cstdlib" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cstdlib" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cstdlib" 3 +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 32 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 64 "/usr/include/bits/waitstatus.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 36 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 37 "/usr/include/endian.h" 2 3 4 +# 60 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 27 "/usr/include/bits/byteswap.h" 3 4 +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/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/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 122 "/usr/include/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; +# 28 "/usr/include/bits/byteswap.h" 2 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 29 "/usr/include/bits/byteswap.h" 2 3 4 + + + + + + +# 1 "/usr/include/bits/byteswap-16.h" 1 3 4 +# 36 "/usr/include/bits/byteswap.h" 2 3 4 +# 44 "/usr/include/bits/byteswap.h" 3 4 +static __inline unsigned int +__bswap_32 (unsigned int __bsx) +{ + return __builtin_bswap32 (__bsx); +} +# 108 "/usr/include/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 +# 65 "/usr/include/bits/waitstatus.h" 2 3 4 + +union wait + { + int w_status; + struct + { + + unsigned int __w_termsig:7; + unsigned int __w_coredump:1; + unsigned int __w_retcode:8; + unsigned int:16; + + + + + + + + } __wait_terminated; + struct + { + + unsigned int __w_stopval:8; + unsigned int __w_stopsig:8; + unsigned int:16; + + + + + + + } __wait_stopped; + }; +# 43 "/usr/include/stdlib.h" 2 3 4 +# 95 "/usr/include/stdlib.h" 3 4 + + +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; + + +# 139 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) throw () ; + + + + +extern double atof (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +__extension__ extern long long int atoll (const char *__nptr) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + throw () __attribute__ ((__nonnull__ (1))); + +# 235 "/usr/include/stdlib.h" 3 4 +# 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; +# 236 "/usr/include/stdlib.h" 2 3 4 + + + +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 4))); + +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + __locale_t __loc) + throw () __attribute__ ((__nonnull__ (1, 3))); +# 305 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) throw () ; + + +extern long int a64l (const char *__s) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 27 "/usr/include/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + + + +typedef __loff_t loff_t; + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; +# 132 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 57 "/usr/include/time.h" 3 4 + + +typedef __clock_t clock_t; + + + +# 73 "/usr/include/time.h" 3 4 + + +typedef __time_t time_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; +# 133 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 147 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; +# 194 "/usr/include/sys/types.h" 3 4 +typedef int int8_t __attribute__ ((__mode__ (__QI__))); +typedef int int16_t __attribute__ ((__mode__ (__HI__))); +typedef int int32_t __attribute__ ((__mode__ (__SI__))); +typedef int int64_t __attribute__ ((__mode__ (__DI__))); + + +typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__))); +typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__))); +typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__))); +typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__))); + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 219 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 22 "/usr/include/bits/select.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 23 "/usr/include/bits/select.h" 2 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/sigset.h" 1 3 4 +# 22 "/usr/include/bits/sigset.h" 3 4 +typedef int __sig_atomic_t; + + + + +typedef struct + { + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; + } __sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 + + + +typedef __sigset_t sigset_t; + + + + + +# 1 "/usr/include/time.h" 1 3 4 +# 120 "/usr/include/time.h" 3 4 +struct timespec + { + __time_t tv_sec; + __syscall_slong_t tv_nsec; + }; +# 44 "/usr/include/sys/select.h" 2 3 4 + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 30 "/usr/include/bits/time.h" 3 4 +struct timeval + { + __time_t tv_sec; + __suseconds_t tv_usec; + }; +# 46 "/usr/include/sys/select.h" 2 3 4 +# 54 "/usr/include/sys/select.h" 3 4 +typedef long int __fd_mask; +# 64 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 96 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 106 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 118 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 131 "/usr/include/sys/select.h" 3 4 +} +# 220 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/sysmacros.h" 1 3 4 +# 24 "/usr/include/sys/sysmacros.h" 3 4 +extern "C" { + +__extension__ +extern unsigned int gnu_dev_major (unsigned long long int __dev) + throw () __attribute__ ((__const__)); +__extension__ +extern unsigned int gnu_dev_minor (unsigned long long int __dev) + throw () __attribute__ ((__const__)); +__extension__ +extern unsigned long long int gnu_dev_makedev (unsigned int __major, + unsigned int __minor) + throw () __attribute__ ((__const__)); +# 58 "/usr/include/sys/sysmacros.h" 3 4 +} +# 223 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 262 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes.h" 2 3 4 +# 60 "/usr/include/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/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/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/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; +# 271 "/usr/include/sys/types.h" 2 3 4 + + +} +# 315 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) throw (); + + +extern void srandom (unsigned int __seed) throw (); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) throw () __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + throw () __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + throw () __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int rand (void) throw (); + +extern void srand (unsigned int __seed) throw (); + + + + +extern int rand_r (unsigned int *__seed) throw (); + + + + + + + +extern double drand48 (void) throw (); +extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) throw (); +extern long int nrand48 (unsigned short int __xsubi[3]) + throw () __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) throw (); +extern long int jrand48 (unsigned short int __xsubi[3]) + throw () __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) throw (); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + throw () __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + throw () __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + + + + + +extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ; + +extern void *calloc (size_t __nmemb, size_t __size) + throw () __attribute__ ((__malloc__)) ; + + + + + + + + + + +extern void *realloc (void *__ptr, size_t __size) + throw () __attribute__ ((__warn_unused_result__)); + +extern void free (void *__ptr) throw (); + + + + +extern void cfree (void *__ptr) throw (); + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) throw (); + + + + + +} +# 493 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + throw () __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ; + + + + +extern void abort (void) throw () __attribute__ ((__noreturn__)); + + + +extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); + + + + + + + + + +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + throw () __attribute__ ((__nonnull__ (1))); + + + + + + +extern void exit (int __status) throw () __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__)); + + + + + + + +extern void _Exit (int __status) throw () __attribute__ ((__noreturn__)); + + + + + + +extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ; + + + + + +extern char *secure_getenv (const char *__name) + throw () __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + throw () __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) throw (); +# 606 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))); +# 619 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 629 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 641 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 651 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 662 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ; +# 673 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 683 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 693 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 705 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; + + + + + + + + + +extern int system (const char *__command) ; + + + + + + +extern char *canonicalize_file_name (const char *__name) + throw () __attribute__ ((__nonnull__ (1))) ; +# 733 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) throw () ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + + + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) throw () __attribute__ ((__const__)) ; +extern long int labs (long int __x) throw () __attribute__ ((__const__)) ; + + + +__extension__ extern long long int llabs (long long int __x) + throw () __attribute__ ((__const__)) ; + + + + + + + +extern div_t div (int __numer, int __denom) + throw () __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + throw () __attribute__ ((__const__)) ; + + + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + throw () __attribute__ ((__const__)) ; + +# 811 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + throw () __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + throw () __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + throw () __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + throw () __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + throw () __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + throw () __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + + +extern int mblen (const char *__s, size_t __n) throw (); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) throw (); + + +extern int wctomb (char *__s, wchar_t __wchar) throw (); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) throw (); + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + throw (); + + + + + + + + +extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ; +# 898 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + throw () __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + +extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1))); + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) throw (); + + + +extern int unlockpt (int __fd) throw (); + + + + +extern char *ptsname (int __fd) throw () ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + throw () __attribute__ ((__nonnull__ (2))); + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + throw () __attribute__ ((__nonnull__ (1))); + + +# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 +# 955 "/usr/include/stdlib.h" 2 3 4 +# 967 "/usr/include/stdlib.h" 3 4 +} +# 73 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cstdlib" 2 3 +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cstdlib" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + using ::abs; + using ::atexit; + + + + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + inline ldiv_t + div(long __i, long __j) { return ldiv(__i, __j); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } + + + + inline __int128 + abs(__int128 __x) { return __x >= 0 ? __x : -__x; } +# 195 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cstdlib" 3 + +} +# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cstdlib" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + using ::lldiv_t; + + + + + + using ::_Exit; + + + + using ::llabs; + + inline lldiv_t + div(long long __n, long long __d) + { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; } + + using ::lldiv; +# 241 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cstdlib" 3 + using ::atoll; + using ::strtoll; + using ::strtoull; + + using ::strtof; + using ::strtold; + + +} + +namespace std +{ + + using ::__gnu_cxx::lldiv_t; + + using ::__gnu_cxx::_Exit; + + using ::__gnu_cxx::llabs; + using ::__gnu_cxx::div; + using ::__gnu_cxx::lldiv; + + using ::__gnu_cxx::atoll; + using ::__gnu_cxx::strtof; + using ::__gnu_cxx::strtoll; + using ::__gnu_cxx::strtoull; + using ::__gnu_cxx::strtold; +} +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 203 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 + template + bool + binary_search(_FIter, _FIter, const _Tp&); + + template + bool + binary_search(_FIter, _FIter, const _Tp&, _Compare); + + template + _OIter + copy(_IIter, _IIter, _OIter); + + template + _BIter2 + copy_backward(_BIter1, _BIter1, _BIter2); +# 232 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 + template + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&); + + template + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&, _Compare); + + template + void + fill(_FIter, _FIter, const _Tp&); + + template + _OIter + fill_n(_OIter, _Size, const _Tp&); + + + + template + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); +# 271 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 + template + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2); + + template + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + void + inplace_merge(_BIter, _BIter, _BIter); + + template + void + inplace_merge(_BIter, _BIter, _BIter, _Compare); +# 334 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 + template + void + iter_swap(_FIter1, _FIter2); + + template + _FIter + lower_bound(_FIter, _FIter, const _Tp&); + + template + _FIter + lower_bound(_FIter, _FIter, const _Tp&, _Compare); + + template + void + make_heap(_RAIter, _RAIter); + + template + void + make_heap(_RAIter, _RAIter, _Compare); + + template + + const _Tp& + max(const _Tp&, const _Tp&); + + template + + const _Tp& + max(const _Tp&, const _Tp&, _Compare); + + + + + template + + const _Tp& + min(const _Tp&, const _Tp&); + + template + + const _Tp& + min(const _Tp&, const _Tp&, _Compare); +# 433 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 + template + bool + next_permutation(_BIter, _BIter); + + template + bool + next_permutation(_BIter, _BIter, _Compare); +# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 + template + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); + + template + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); +# 471 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 + template + void + pop_heap(_RAIter, _RAIter); + + template + void + pop_heap(_RAIter, _RAIter, _Compare); + + template + bool + prev_permutation(_BIter, _BIter); + + template + bool + prev_permutation(_BIter, _BIter, _Compare); + + template + void + push_heap(_RAIter, _RAIter); + + template + void + push_heap(_RAIter, _RAIter, _Compare); + + + + template + _FIter + remove(_FIter, _FIter, const _Tp&); + + template + _FIter + remove_if(_FIter, _FIter, _Predicate); + + template + _OIter + remove_copy(_IIter, _IIter, _OIter, const _Tp&); + + template + _OIter + remove_copy_if(_IIter, _IIter, _OIter, _Predicate); + + + + template + _OIter + replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); + + template + _OIter + replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); + + + + template + void + reverse(_BIter, _BIter); + + template + _OIter + reverse_copy(_BIter, _BIter, _OIter); + + inline namespace _V2 + { + template + _FIter + rotate(_FIter, _FIter, _FIter); + } + + template + _OIter + rotate_copy(_FIter, _FIter, _FIter, _OIter); +# 557 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/algorithmfwd.h" 3 + template + void + sort_heap(_RAIter, _RAIter); + + template + void + sort_heap(_RAIter, _RAIter, _Compare); + + template + _BIter + stable_partition(_BIter, _BIter, _Predicate); + + template + void + swap(_Tp&, _Tp&) + + + + + ; + + template + void + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + + + + ; + + template + _FIter2 + swap_ranges(_FIter1, _FIter1, _FIter2); + + + + template + _FIter + unique(_FIter, _FIter); + + template + _FIter + unique(_FIter, _FIter, _BinaryPredicate); + + + + template + _FIter + upper_bound(_FIter, _FIter, const _Tp&); + + template + _FIter + upper_bound(_FIter, _FIter, const _Tp&, _Compare); + + + + + + template + _FIter + adjacent_find(_FIter, _FIter); + + template + _FIter + adjacent_find(_FIter, _FIter, _BinaryPredicate); + + template + typename iterator_traits<_IIter>::difference_type + count(_IIter, _IIter, const _Tp&); + + template + typename iterator_traits<_IIter>::difference_type + count_if(_IIter, _IIter, _Predicate); + + template + bool + equal(_IIter1, _IIter1, _IIter2); + + template + bool + equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + _IIter + find(_IIter, _IIter, const _Tp&); + + template + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + _IIter + find_if(_IIter, _IIter, _Predicate); + + template + _Funct + for_each(_IIter, _IIter, _Funct); + + template + void + generate(_FIter, _FIter, _Generator); + + template + _OIter + generate_n(_OIter, _Size, _Generator); + + template + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); + + template + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + + _FIter + max_element(_FIter, _FIter); + + template + + _FIter + max_element(_FIter, _FIter, _Compare); + + template + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + + _FIter + min_element(_FIter, _FIter); + + template + + _FIter + min_element(_FIter, _FIter, _Compare); + + template + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2); + + template + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + void + nth_element(_RAIter, _RAIter, _RAIter); + + template + void + nth_element(_RAIter, _RAIter, _RAIter, _Compare); + + template + void + partial_sort(_RAIter, _RAIter, _RAIter); + + template + void + partial_sort(_RAIter, _RAIter, _RAIter, _Compare); + + template + _BIter + partition(_BIter, _BIter, _Predicate); + + template + void + random_shuffle(_RAIter, _RAIter); + + template + void + random_shuffle(_RAIter, _RAIter, + + + + _Generator&); + + + template + void + replace(_FIter, _FIter, const _Tp&, const _Tp&); + + template + void + replace_if(_FIter, _FIter, _Predicate, const _Tp&); + + template + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2); + + template + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&); + + template + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); + + template + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, + _OIter, _Compare); + + template + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + void + sort(_RAIter, _RAIter); + + template + void + sort(_RAIter, _RAIter, _Compare); + + template + void + stable_sort(_RAIter, _RAIter); + + template + void + stable_sort(_RAIter, _RAIter, _Compare); + + template + _OIter + transform(_IIter, _IIter, _OIter, _UnaryOperation); + + template + _OIter + transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); + + template + _OIter + unique_copy(_IIter, _IIter, _OIter); + + template + _OIter + unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); + + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 1 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + _Distance + __is_heap_until(_RandomAccessIterator __first, _Distance __n, + _Compare __comp) + { + _Distance __parent = 0; + for (_Distance __child = 1; __child < __n; ++__child) + { + if (__comp(__first + __parent, __first + __child)) + return __child; + if ((__child & 1) == 0) + ++__parent; + } + return __n; + } + + + + template + inline bool + __is_heap(_RandomAccessIterator __first, _Distance __n) + { + return std::__is_heap_until(__first, __n, + __gnu_cxx::__ops::__iter_less_iter()) == __n; + } + + template + inline bool + __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n) + { + return std::__is_heap_until(__first, __n, + __gnu_cxx::__ops::__iter_comp_iter(__comp)) == __n; + } + + template + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::__is_heap(__first, std::distance(__first, __last)); } + + template + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { return std::__is_heap(__first, __comp, std::distance(__first, __last)); } + + + + + template + void + __push_heap(_RandomAccessIterator __first, + _Distance __holeIndex, _Distance __topIndex, _Tp __value, + _Compare __comp) + { + _Distance __parent = (__holeIndex - 1) / 2; + while (__holeIndex > __topIndex && __comp(__first + __parent, __value)) + { + *(__first + __holeIndex) = (*(__first + __parent)); + __holeIndex = __parent; + __parent = (__holeIndex - 1) / 2; + } + *(__first + __holeIndex) = (__value); + } +# 148 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 + template + inline void + push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + + + + + ; + ; + + _ValueType __value = (*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), (__value), + __gnu_cxx::__ops::__iter_less_val()); + } +# 182 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 + template + inline void + push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + + + + ; + ; + + _ValueType __value = (*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), (__value), + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template + void + __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, + _Distance __len, _Tp __value, _Compare __comp) + { + const _Distance __topIndex = __holeIndex; + _Distance __secondChild = __holeIndex; + while (__secondChild < (__len - 1) / 2) + { + __secondChild = 2 * (__secondChild + 1); + if (__comp(__first + __secondChild, + __first + (__secondChild - 1))) + __secondChild--; + *(__first + __holeIndex) = (*(__first + __secondChild)); + __holeIndex = __secondChild; + } + if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2) + { + __secondChild = 2 * (__secondChild + 1); + *(__first + __holeIndex) = (*(__first + (__secondChild - 1))) + ; + __holeIndex = __secondChild - 1; + } + std::__push_heap(__first, __holeIndex, __topIndex, + (__value), + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template + inline void + __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _RandomAccessIterator __result, _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + _ValueType __value = (*__result); + *__result = (*__first); + std::__adjust_heap(__first, _DistanceType(0), + _DistanceType(__last - __first), + (__value), __comp); + } +# 261 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 + template + inline void + pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + + + + + + ; + ; + ; + + if (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } + } +# 295 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 + template + inline void + pop_heap(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + + + + ; + ; + ; + + if (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + } + + template + void + __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + if (__last - __first < 2) + return; + + const _DistanceType __len = __last - __first; + _DistanceType __parent = (__len - 2) / 2; + while (true) + { + _ValueType __value = (*(__first + __parent)); + std::__adjust_heap(__first, __parent, __len, (__value), + __comp); + if (__parent == 0) + return; + __parent--; + } + } +# 349 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 + template + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + + std::__make_heap(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 374 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 + template + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + ; + + std::__make_heap(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + void + __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + while (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, __comp); + } + } +# 408 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 + template + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + std::__sort_heap(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 434 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 + template + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + ; + ; + + std::__sort_heap(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 529 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_heap.h" 3 + +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tempbuf.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tempbuf.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_construct.h" 1 3 +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_construct.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/new" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/new" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/new" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/exception" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/exception" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/exception" 3 + +#pragma GCC visibility push(default) + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/atomic_lockfree_defines.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/atomic_lockfree_defines.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/atomic_lockfree_defines.h" 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/exception" 2 3 + +extern "C++" { + +namespace std +{ +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/exception" 3 + void terminate() throw() __attribute__ ((__noreturn__)); + + + unexpected_handler set_unexpected(unexpected_handler) throw(); +# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/exception" 3 + void unexpected() __attribute__ ((__noreturn__)); +# 127 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/exception" 3 + bool uncaught_exception() throw() __attribute__ ((__pure__)); + + +} + +namespace __gnu_cxx +{ + +# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/exception" 3 + void __verbose_terminate_handler(); + + +} + +} + +#pragma GCC visibility pop +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/new" 2 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/new" 3 + struct nothrow_t { }; + + extern const nothrow_t nothrow; + + + + typedef void (*new_handler)(); + + + + new_handler set_new_handler(new_handler) throw(); + + + + + +} +# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/new" 3 +void* operator new(std::size_t) throw(std::bad_alloc) + __attribute__((__externally_visible__)); +void* operator new[](std::size_t) throw(std::bad_alloc) + __attribute__((__externally_visible__)); +void operator delete(void*) throw() + __attribute__((__externally_visible__)); +void operator delete[](void*) 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 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_construct.h" 2 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/alloc_traits.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/alloc_traits.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/alloc_traits.h" 3 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/allocator.h" 1 3 +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/allocator.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/new_allocator.h" 1 3 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/new_allocator.h" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + using std::size_t; + using std::ptrdiff_t; +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + struct rebind + { typedef new_allocator<_Tp1> other; }; + + + + + + + + new_allocator() throw() { } + + new_allocator(const new_allocator&) throw() { } + + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/allocator.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/memoryfwd.h" 1 3 +# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/memoryfwd.h" 3 + +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/memoryfwd.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/memoryfwd.h" 3 + template + class allocator; + + template<> + class allocator; + + + template + struct uses_allocator; + + + + +} +# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + + }; +# 91 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + + + allocator() throw() { } + + allocator(const allocator& __a) throw() + : __gnu_cxx::new_allocator<_Tp>(__a) { } + + template + allocator(const allocator<_Tp1>&) throw() { } + + ~allocator() throw() { } + + + }; + + template + 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 + 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; + + + + + + + template + 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 + 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; } + }; +# 222 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/allocator.h" 3 + +} +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/alloc_traits.h" 2 3 + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 94 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/alloc_traits.h" 3 +template + struct __alloc_traits + + + + { + typedef _Alloc allocator_type; +# 172 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + 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 + struct rebind + { typedef typename _Alloc::template rebind<_Tp>::other other; }; + + }; + + +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_construct.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 77 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_construct.h" 3 + template + inline void + _Construct(_T1* __p, const _T2& __value) + { + + + ::new(static_cast(__p)) _T1(__value); + } + + + + + + template + inline void + _Destroy(_Tp* __pointer) + { __pointer->~_Tp(); } + + template + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator __first, _ForwardIterator __last) + { + for (; __first != __last; ++__first) + std::_Destroy(std::__addressof(*__first)); + } + }; + + template<> + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator, _ForwardIterator) { } + }; + + + + + + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: + __destroy(__first, __last); + } + + + + + + + + template + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + _Allocator& __alloc) + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __first != __last; ++__first) + __traits::destroy(__alloc, std::__addressof(*__first)); + } + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + allocator<_Tp>&) + { + _Destroy(__first, __last); + } + + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tempbuf.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tempbuf.h" 3 + template + pair<_Tp*, ptrdiff_t> + get_temporary_buffer(ptrdiff_t __len) + { + const ptrdiff_t __max = + __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); + if (__len > __max) + __len = __max; + + while (__len > 0) + { + _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), + std::nothrow)); + if (__tmp != 0) + return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); + __len /= 2; + } + return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); + } +# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tempbuf.h" 3 + template + inline void + return_temporary_buffer(_Tp* __p) + { ::operator delete(__p, std::nothrow); } + + + + + + + + template + class _Temporary_buffer + { + + + + public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef pointer iterator; + typedef ptrdiff_t size_type; + + protected: + size_type _M_original_len; + size_type _M_len; + pointer _M_buffer; + + public: + + size_type + size() const + { return _M_len; } + + + size_type + requested_size() const + { return _M_original_len; } + + + iterator + begin() + { return _M_buffer; } + + + iterator + end() + { return _M_buffer + _M_len; } + + + + + + _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last); + + ~_Temporary_buffer() + { + std::_Destroy(_M_buffer, _M_buffer + _M_len); + std::return_temporary_buffer(_M_buffer); + } + + private: + + _Temporary_buffer(const _Temporary_buffer&); + + void + operator=(const _Temporary_buffer&); + }; + + + template + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + if(__first == __last) + return; + + _Pointer __cur = __first; + try + { + std::_Construct(std::__addressof(*__first), + (*__seed)); + _Pointer __prev = __cur; + ++__cur; + for(; __cur != __last; ++__cur, ++__prev) + std::_Construct(std::__addressof(*__cur), + (*__prev)); + *__seed = (*__prev); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer, _Pointer, _ForwardIterator) { } + }; +# 229 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tempbuf.h" 3 + template + inline void + __uninitialized_construct_buf(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + typedef typename std::iterator_traits<_Pointer>::value_type + _ValueType; + + std::__uninitialized_construct_buf_dispatch< + __has_trivial_constructor(_ValueType)>:: + __ucr(__first, __last, __seed); + } + + template + _Temporary_buffer<_ForwardIterator, _Tp>:: + _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) + : _M_original_len(std::distance(__first, __last)), + _M_len(0), _M_buffer(0) + { + try + { + std::pair __p(std::get_temporary_buffer< + value_type>(_M_original_len)); + _M_buffer = __p.first; + _M_len = __p.second; + if (_M_buffer) + std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len, + __first); + } + catch(...) + { + std::return_temporary_buffer(_M_buffer); + _M_buffer = 0; + _M_len = 0; + throw; + } + } + + +} +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 2 3 +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + void + __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b, + _Iterator __c, _Compare __comp) + { + if (__comp(__a, __b)) + { + if (__comp(__b, __c)) + std::iter_swap(__result, __b); + else if (__comp(__a, __c)) + std::iter_swap(__result, __c); + else + std::iter_swap(__result, __a); + } + else if (__comp(__a, __c)) + std::iter_swap(__result, __a); + else if (__comp(__b, __c)) + std::iter_swap(__result, __c); + else + std::iter_swap(__result, __b); + } + + + template + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + case 2: + if (__pred(__first)) + return __first; + ++__first; + case 1: + if (__pred(__first)) + return __first; + ++__first; + case 0: + default: + return __last; + } + } + + template + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + + template + inline _InputIterator + __find_if_not(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__negate(__pred), + std::__iterator_category(__first)); + } + + + + + template + _InputIterator + __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred) + { + for (; __len; --__len, ++__first) + if (!__pred(__first)) + break; + return __first; + } +# 202 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _ForwardIterator1 + __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + if (__first1 == __last1 || __first2 == __last2) + return __first1; + + + _ForwardIterator2 __p1(__first2); + if (++__p1 == __last2) + return std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + + _ForwardIterator2 __p; + _ForwardIterator1 __current = __first1; + + for (;;) + { + __first1 = + std::__find_if(__first1, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2)); + + if (__first1 == __last1) + return __last1; + + __p = __p1; + __current = __first1; + if (++__current == __last1) + return __last1; + + while (__predicate(__current, __p)) + { + if (++__p == __last2) + return __first1; + if (++__current == __last1) + return __last1; + } + ++__first1; + } + return __first1; + } + + + + + + + template + _ForwardIterator + __search_n_aux(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, _UnaryPredicate __unary_pred, + std::forward_iterator_tag) + { + __first = std::__find_if(__first, __last, __unary_pred); + while (__first != __last) + { + typename iterator_traits<_ForwardIterator>::difference_type + __n = __count; + _ForwardIterator __i = __first; + ++__i; + while (__i != __last && __n != 1 && __unary_pred(__i)) + { + ++__i; + --__n; + } + if (__n == 1) + return __first; + if (__i == __last) + return __last; + __first = std::__find_if(++__i, __last, __unary_pred); + } + return __last; + } + + + + + + template + _RandomAccessIter + __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last, + _Integer __count, _UnaryPredicate __unary_pred, + std::random_access_iterator_tag) + { + typedef typename std::iterator_traits<_RandomAccessIter>::difference_type + _DistanceType; + + _DistanceType __tailSize = __last - __first; + _DistanceType __remainder = __count; + + while (__remainder <= __tailSize) + { + __first += __remainder; + __tailSize -= __remainder; + + + _RandomAccessIter __backTrack = __first; + while (__unary_pred(--__backTrack)) + { + if (--__remainder == 0) + return (__first - __count); + } + __remainder = __count + 1 - (__first - __backTrack); + } + return __last; + } + + template + _ForwardIterator + __search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, + _UnaryPredicate __unary_pred) + { + if (__count <= 0) + return __first; + + if (__count == 1) + return std::__find_if(__first, __last, __unary_pred); + + return std::__search_n_aux(__first, __last, __count, __unary_pred, + std::__iterator_category(__first)); + } + + + template + _ForwardIterator1 + __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + forward_iterator_tag, forward_iterator_tag, + _BinaryPredicate __comp) + { + if (__first2 == __last2) + return __last1; + + _ForwardIterator1 __result = __last1; + while (1) + { + _ForwardIterator1 __new_result + = std::__search(__first1, __last1, __first2, __last2, __comp); + if (__new_result == __last1) + return __result; + else + { + __result = __new_result; + __first1 = __new_result; + ++__first1; + } + } + } + + + template + _BidirectionalIterator1 + __find_end(_BidirectionalIterator1 __first1, + _BidirectionalIterator1 __last1, + _BidirectionalIterator2 __first2, + _BidirectionalIterator2 __last2, + bidirectional_iterator_tag, bidirectional_iterator_tag, + _BinaryPredicate __comp) + { + + + + + + + typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1; + typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2; + + _RevIterator1 __rlast1(__first1); + _RevIterator2 __rlast2(__first2); + _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1, + _RevIterator2(__last2), __rlast2, + __comp); + + if (__rresult == __rlast1) + return __last1; + else + { + _BidirectionalIterator1 __result = __rresult.base(); + std::advance(__result, -std::distance(__first2, __last2)); + return __result; + } + } +# 423 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator1 + find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + + + + + + + ; + ; + + return std::__find_end(__first1, __last1, __first2, __last2, + std::__iterator_category(__first1), + std::__iterator_category(__first2), + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 471 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator1 + find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __comp) + { + + + + + + + ; + ; + + return std::__find_end(__first1, __last1, __first2, __last2, + std::__iterator_category(__first1), + std::__iterator_category(__first2), + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 636 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _OutputIterator + __remove_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = *__first; + ++__result; + } + return __result; + } +# 665 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + remove_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, const _Tp& __value) + { + + + + + + + ; + + return std::__remove_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 697 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + remove_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _Predicate __pred) + { + + + + + + + ; + + return std::__remove_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 855 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = (*__first); + ++__result; + } + return __result; + } +# 891 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + remove(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + + + + + + ; + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 924 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + ; + + return std::__remove_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + template + _ForwardIterator + __adjacent_find(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + if (__first == __last) + return __last; + _ForwardIterator __next = __first; + while (++__next != __last) + { + if (__binary_pred(__first, __next)) + return __first; + __first = __next; + } + return __last; + } + + template + _ForwardIterator + __unique(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + + __first = std::__adjacent_find(__first, __last, __binary_pred); + if (__first == __last) + return __last; + + + _ForwardIterator __dest = __first; + ++__first; + while (++__first != __last) + if (!__binary_pred(__dest, __first)) + *++__dest = (*__first); + return ++__dest; + } +# 990 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + + ; + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1020 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + unique(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + + + + + + + ; + + return std::__unique(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + + + template + _OutputIterator + __unique_copy(_ForwardIterator __first, _ForwardIterator __last, + _OutputIterator __result, _BinaryPredicate __binary_pred, + forward_iterator_tag, output_iterator_tag) + { + + + + + + _ForwardIterator __next = __first; + *__result = *__first; + while (++__next != __last) + if (!__binary_pred(__first, __next)) + { + __first = __next; + *++__result = *__first; + } + return ++__result; + } + + + + + + + + template + _OutputIterator + __unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _BinaryPredicate __binary_pred, + input_iterator_tag, output_iterator_tag) + { + + + + + + typename iterator_traits<_InputIterator>::value_type __value = *__first; + __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred)) + __rebound_pred + = __gnu_cxx::__ops::__iter_comp_val(__binary_pred); + *__result = __value; + while (++__first != __last) + if (!__rebound_pred(__first, __value)) + { + __value = *__first; + *++__result = __value; + } + return ++__result; + } + + + + + + + + template + _ForwardIterator + __unique_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _BinaryPredicate __binary_pred, + input_iterator_tag, forward_iterator_tag) + { + + + + + *__result = *__first; + while (++__first != __last) + if (!__binary_pred(__result, __first)) + *++__result = *__first; + return ++__result; + } + + + + + + + template + void + __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last, + bidirectional_iterator_tag) + { + while (true) + if (__first == __last || __first == --__last) + return; + else + { + std::iter_swap(__first, __last); + ++__first; + } + } + + + + + + + template + void + __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + if (__first == __last) + return; + --__last; + while (__first < __last) + { + std::iter_swap(__first, __last); + ++__first; + --__last; + } + } +# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) + { + + + + ; + std::__reverse(__first, __last, std::__iterator_category(__first)); + } +# 1202 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _OutputIterator + reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, + _OutputIterator __result) + { + + + + + + ; + + while (__first != __last) + { + --__last; + *__result = *__last; + ++__result; + } + return __result; + } + + + + + + template + _EuclideanRingElement + __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n) + { + while (__n != 0) + { + _EuclideanRingElement __t = __m % __n; + __m = __n; + __n = __t; + } + return __m; + } + + inline namespace _V2 + { + + + template + _ForwardIterator + __rotate(_ForwardIterator __first, + _ForwardIterator __middle, + _ForwardIterator __last, + forward_iterator_tag) + { + if (__first == __middle) + return __last; + else if (__last == __middle) + return __first; + + _ForwardIterator __first2 = __middle; + do + { + std::iter_swap(__first, __first2); + ++__first; + ++__first2; + if (__first == __middle) + __middle = __first2; + } + while (__first2 != __last); + + _ForwardIterator __ret = __first; + + __first2 = __middle; + + while (__first2 != __last) + { + std::iter_swap(__first, __first2); + ++__first; + ++__first2; + if (__first == __middle) + __middle = __first2; + else if (__first2 == __last) + __first2 = __middle; + } + return __ret; + } + + + template + _BidirectionalIterator + __rotate(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + bidirectional_iterator_tag) + { + + + + + if (__first == __middle) + return __last; + else if (__last == __middle) + return __first; + + std::__reverse(__first, __middle, bidirectional_iterator_tag()); + std::__reverse(__middle, __last, bidirectional_iterator_tag()); + + while (__first != __middle && __middle != __last) + { + std::iter_swap(__first, --__last); + ++__first; + } + + if (__first == __middle) + { + std::__reverse(__middle, __last, bidirectional_iterator_tag()); + return __last; + } + else + { + std::__reverse(__first, __middle, bidirectional_iterator_tag()); + return __first; + } + } + + + template + _RandomAccessIterator + __rotate(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + + if (__first == __middle) + return __last; + else if (__last == __middle) + return __first; + + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _Distance; + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + + _Distance __n = __last - __first; + _Distance __k = __middle - __first; + + if (__k == __n - __k) + { + std::swap_ranges(__first, __middle, __middle); + return __middle; + } + + _RandomAccessIterator __p = __first; + _RandomAccessIterator __ret = __first + (__last - __middle); + + for (;;) + { + if (__k < __n - __k) + { + if (__is_pod(_ValueType) && __k == 1) + { + _ValueType __t = (*__p); + std::copy(__p + 1, __p + __n, __p); + *(__p + __n - 1) = (__t); + return __ret; + } + _RandomAccessIterator __q = __p + __k; + for (_Distance __i = 0; __i < __n - __k; ++ __i) + { + std::iter_swap(__p, __q); + ++__p; + ++__q; + } + __n %= __k; + if (__n == 0) + return __ret; + std::swap(__n, __k); + __k = __n - __k; + } + else + { + __k = __n - __k; + if (__is_pod(_ValueType) && __k == 1) + { + _ValueType __t = (*(__p + __n - 1)); + std::copy_backward(__p, __p + __n - 1, __p + __n); + *__p = (__t); + return __ret; + } + _RandomAccessIterator __q = __p + __n; + __p = __q - __k; + for (_Distance __i = 0; __i < __n - __k; ++ __i) + { + --__p; + --__q; + std::iter_swap(__p, __q); + } + __n %= __k; + if (__n == 0) + return __ret; + std::swap(__n, __k); + } + } + } +# 1429 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + rotate(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last) + { + + + + ; + ; + + return std::__rotate(__first, __middle, __last, + std::__iterator_category(__first)); + } + + } +# 1466 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, + _ForwardIterator __last, _OutputIterator __result) + { + + + + + ; + ; + + return std::copy(__first, __middle, + std::copy(__middle, __last, __result)); + } + + + template + _ForwardIterator + __partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, forward_iterator_tag) + { + if (__first == __last) + return __first; + + while (__pred(*__first)) + if (++__first == __last) + return __first; + + _ForwardIterator __next = __first; + + while (++__next != __last) + if (__pred(*__next)) + { + std::iter_swap(__first, __next); + ++__first; + } + + return __first; + } + + + template + _BidirectionalIterator + __partition(_BidirectionalIterator __first, _BidirectionalIterator __last, + _Predicate __pred, bidirectional_iterator_tag) + { + while (true) + { + while (true) + if (__first == __last) + return __first; + else if (__pred(*__first)) + ++__first; + else + break; + --__last; + while (true) + if (__first == __last) + return __first; + else if (!bool(__pred(*__last))) + --__last; + else + break; + std::iter_swap(__first, __last); + ++__first; + } + } +# 1543 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _ForwardIterator + __stable_partition_adaptive(_ForwardIterator __first, + _ForwardIterator __last, + _Predicate __pred, _Distance __len, + _Pointer __buffer, + _Distance __buffer_size) + { + if (__len == 1) + return __first; + + if (__len <= __buffer_size) + { + _ForwardIterator __result1 = __first; + _Pointer __result2 = __buffer; + + + + + *__result2 = (*__first); + ++__result2; + ++__first; + for (; __first != __last; ++__first) + if (__pred(__first)) + { + *__result1 = (*__first); + ++__result1; + } + else + { + *__result2 = (*__first); + ++__result2; + } + + std::copy(__buffer, __result2, __result1); + return __result1; + } + + _ForwardIterator __middle = __first; + std::advance(__middle, __len / 2); + _ForwardIterator __left_split = + std::__stable_partition_adaptive(__first, __middle, __pred, + __len / 2, __buffer, + __buffer_size); + + + + _Distance __right_len = __len - __len / 2; + _ForwardIterator __right_split = + std::__find_if_not_n(__middle, __right_len, __pred); + + if (__right_len) + __right_split = + std::__stable_partition_adaptive(__right_split, __last, __pred, + __right_len, + __buffer, __buffer_size); + + std::rotate(__left_split, __middle, __right_split); + std::advance(__left_split, std::distance(__middle, __right_split)); + return __left_split; + } + + template + _ForwardIterator + __stable_partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if_not(__first, __last, __pred); + + if (__first == __last) + return __first; + + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last); + return + std::__stable_partition_adaptive(__first, __last, __pred, + _DistanceType(__buf.requested_size()), + __buf.begin(), + _DistanceType(__buf.size())); + } +# 1646 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + stable_partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + ; + + return std::__stable_partition(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } + + + template + void + __heap_select(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, _Compare __comp) + { + std::__make_heap(__first, __middle, __comp); + for (_RandomAccessIterator __i = __middle; __i < __last; ++__i) + if (__comp(__i, __first)) + std::__pop_heap(__first, __middle, __i, __comp); + } + + + + template + _RandomAccessIterator + __partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last, + _Compare __comp) + { + typedef typename iterator_traits<_InputIterator>::value_type + _InputValueType; + typedef iterator_traits<_RandomAccessIterator> _RItTraits; + typedef typename _RItTraits::difference_type _DistanceType; + + if (__result_first == __result_last) + return __result_last; + _RandomAccessIterator __result_real_last = __result_first; + while (__first != __last && __result_real_last != __result_last) + { + *__result_real_last = *__first; + ++__result_real_last; + ++__first; + } + + std::__make_heap(__result_first, __result_real_last, __comp); + while (__first != __last) + { + if (__comp(__first, __result_first)) + std::__adjust_heap(__result_first, _DistanceType(0), + _DistanceType(__result_real_last + - __result_first), + _InputValueType(*__first), __comp); + ++__first; + } + std::__sort_heap(__result_first, __result_real_last, __comp); + return __result_real_last; + } +# 1732 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last) + { + typedef typename iterator_traits<_InputIterator>::value_type + _InputValueType; + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _OutputValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + + + + + + + + ; + ; + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 1780 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _RandomAccessIterator + partial_sort_copy(_InputIterator __first, _InputIterator __last, + _RandomAccessIterator __result_first, + _RandomAccessIterator __result_last, + _Compare __comp) + { + typedef typename iterator_traits<_InputIterator>::value_type + _InputValueType; + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _OutputValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + + + + + + + + + + + ; + ; + + return std::__partial_sort_copy(__first, __last, + __result_first, __result_last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + template + void + __unguarded_linear_insert(_RandomAccessIterator __last, + _Compare __comp) + { + typename iterator_traits<_RandomAccessIterator>::value_type + __val = (*__last); + _RandomAccessIterator __next = __last; + --__next; + while (__comp(__val, __next)) + { + *__last = (*__next); + __last = __next; + --__next; + } + *__last = (__val); + } + + + template + void + __insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__first == __last) return; + + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + if (__comp(__i, __first)) + { + typename iterator_traits<_RandomAccessIterator>::value_type + __val = (*__i); + std::copy_backward(__first, __i, __i + 1); + *__first = (__val); + } + else + std::__unguarded_linear_insert(__i, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + } + + + template + inline void + __unguarded_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + for (_RandomAccessIterator __i = __first; __i != __last; ++__i) + std::__unguarded_linear_insert(__i, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + + + + + + enum { _S_threshold = 16 }; + + + template + void + __final_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__last - __first > int(_S_threshold)) + { + std::__insertion_sort(__first, __first + int(_S_threshold), __comp); + std::__unguarded_insertion_sort(__first + int(_S_threshold), __last, + __comp); + } + else + std::__insertion_sort(__first, __last, __comp); + } + + + template + _RandomAccessIterator + __unguarded_partition(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _RandomAccessIterator __pivot, _Compare __comp) + { + while (true) + { + while (__comp(__first, __pivot)) + ++__first; + --__last; + while (__comp(__pivot, __last)) + --__last; + if (!(__first < __last)) + return __first; + std::iter_swap(__first, __last); + ++__first; + } + } + + + template + inline _RandomAccessIterator + __unguarded_partition_pivot(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + _RandomAccessIterator __mid = __first + (__last - __first) / 2; + std::__move_median_to_first(__first, __first + 1, __mid, __last - 1, + __comp); + return std::__unguarded_partition(__first + 1, __last, __first, __comp); + } + + template + inline void + __partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + _Compare __comp) + { + std::__heap_select(__first, __middle, __last, __comp); + std::__sort_heap(__first, __middle, __comp); + } + + + template + void + __introsort_loop(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Size __depth_limit, _Compare __comp) + { + while (__last - __first > int(_S_threshold)) + { + if (__depth_limit == 0) + { + std::__partial_sort(__first, __last, __last, __comp); + return; + } + --__depth_limit; + _RandomAccessIterator __cut = + std::__unguarded_partition_pivot(__first, __last, __comp); + std::__introsort_loop(__cut, __last, __depth_limit, __comp); + __last = __cut; + } + } + + + + template + inline void + __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + if (__first != __last) + { + std::__introsort_loop(__first, __last, + std::__lg(__last - __first) * 2, + __comp); + std::__final_insertion_sort(__first, __last, __comp); + } + } + + template + void + __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Size __depth_limit, + _Compare __comp) + { + while (__last - __first > 3) + { + if (__depth_limit == 0) + { + std::__heap_select(__first, __nth + 1, __last, __comp); + + std::iter_swap(__first, __nth); + return; + } + --__depth_limit; + _RandomAccessIterator __cut = + std::__unguarded_partition_pivot(__first, __last, __comp); + if (__cut <= __nth) + __first = __cut; + else + __last = __cut; + } + std::__insertion_sort(__first, __last, __comp); + } +# 2016 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + } + + template + _ForwardIterator + __upper_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(__val, __middle)) + __len = __half; + else + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + } + return __first; + } +# 2073 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + + ; + + return std::__upper_bound(__first, __last, __val, + __gnu_cxx::__ops::__val_less_iter()); + } +# 2105 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + upper_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + + + + ; + + return std::__upper_bound(__first, __last, __val, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } + + template + pair<_ForwardIterator, _ForwardIterator> + __equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, + _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it) + { + 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_it_val(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else if (__comp_val_it(__val, __middle)) + __len = __half; + else + { + _ForwardIterator __left + = std::__lower_bound(__first, __middle, __val, __comp_it_val); + std::advance(__first, __len); + _ForwardIterator __right + = std::__upper_bound(++__middle, __first, __val, __comp_val_it); + return pair<_ForwardIterator, _ForwardIterator>(__left, __right); + } + } + return pair<_ForwardIterator, _ForwardIterator>(__first, __first); + } +# 2179 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline pair<_ForwardIterator, _ForwardIterator> + equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + + + ; + ; + + return std::__equal_range(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val(), + __gnu_cxx::__ops::__val_less_iter()); + } +# 2216 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline pair<_ForwardIterator, _ForwardIterator> + equal_range(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + + + + + + ; + + ; + + return std::__equal_range(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp), + __gnu_cxx::__ops::__val_comp_iter(__comp)); + } +# 2252 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + bool + binary_search(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + + ; + ; + + _ForwardIterator __i + = std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + return __i != __last && !(__val < *__i); + } +# 2287 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + bool + binary_search(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + + + + ; + + ; + + _ForwardIterator __i + = std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + return __i != __last && !bool(__comp(__val, *__i)); + } + + + + + template + void + __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + *__result = (*__first2); + ++__first2; + } + else + { + *__result = (*__first1); + ++__first1; + } + ++__result; + } + if (__first1 != __last1) + std::copy(__first1, __last1, __result); + } + + + template + void + __move_merge_adaptive_backward(_BidirectionalIterator1 __first1, + _BidirectionalIterator1 __last1, + _BidirectionalIterator2 __first2, + _BidirectionalIterator2 __last2, + _BidirectionalIterator3 __result, + _Compare __comp) + { + if (__first1 == __last1) + { + std::copy_backward(__first2, __last2, __result); + return; + } + else if (__first2 == __last2) + return; + + --__last1; + --__last2; + while (true) + { + if (__comp(__last2, __last1)) + { + *--__result = (*__last1); + if (__first1 == __last1) + { + std::copy_backward(__first2, ++__last2, __result); + return; + } + --__last1; + } + else + { + *--__result = (*__last2); + if (__first2 == __last2) + return; + --__last2; + } + } + } + + + template + _BidirectionalIterator1 + __rotate_adaptive(_BidirectionalIterator1 __first, + _BidirectionalIterator1 __middle, + _BidirectionalIterator1 __last, + _Distance __len1, _Distance __len2, + _BidirectionalIterator2 __buffer, + _Distance __buffer_size) + { + _BidirectionalIterator2 __buffer_end; + if (__len1 > __len2 && __len2 <= __buffer_size) + { + if (__len2) + { + __buffer_end = std::copy(__middle, __last, __buffer); + std::copy_backward(__first, __middle, __last); + return std::copy(__buffer, __buffer_end, __first); + } + else + return __first; + } + else if (__len1 <= __buffer_size) + { + if (__len1) + { + __buffer_end = std::copy(__first, __middle, __buffer); + std::copy(__middle, __last, __first); + return std::copy_backward(__buffer, __buffer_end, __last); + } + else + return __last; + } + else + { + std::rotate(__first, __middle, __last); + std::advance(__first, std::distance(__middle, __last)); + return __first; + } + } + + + template + void + __merge_adaptive(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Distance __len1, _Distance __len2, + _Pointer __buffer, _Distance __buffer_size, + _Compare __comp) + { + if (__len1 <= __len2 && __len1 <= __buffer_size) + { + _Pointer __buffer_end = std::copy(__first, __middle, __buffer); + std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last, + __first, __comp); + } + else if (__len2 <= __buffer_size) + { + _Pointer __buffer_end = std::copy(__middle, __last, __buffer); + std::__move_merge_adaptive_backward(__first, __middle, __buffer, + __buffer_end, __last, __comp); + } + else + { + _BidirectionalIterator __first_cut = __first; + _BidirectionalIterator __second_cut = __middle; + _Distance __len11 = 0; + _Distance __len22 = 0; + if (__len1 > __len2) + { + __len11 = __len1 / 2; + std::advance(__first_cut, __len11); + __second_cut + = std::__lower_bound(__middle, __last, *__first_cut, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + __len22 = std::distance(__middle, __second_cut); + } + else + { + __len22 = __len2 / 2; + std::advance(__second_cut, __len22); + __first_cut + = std::__upper_bound(__first, __middle, *__second_cut, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + __len11 = std::distance(__first, __first_cut); + } + + _BidirectionalIterator __new_middle + = std::__rotate_adaptive(__first_cut, __middle, __second_cut, + __len1 - __len11, __len22, __buffer, + __buffer_size); + std::__merge_adaptive(__first, __first_cut, __new_middle, __len11, + __len22, __buffer, __buffer_size, __comp); + std::__merge_adaptive(__new_middle, __second_cut, __last, + __len1 - __len11, + __len2 - __len22, __buffer, + __buffer_size, __comp); + } + } + + + template + void + __merge_without_buffer(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Distance __len1, _Distance __len2, + _Compare __comp) + { + if (__len1 == 0 || __len2 == 0) + return; + + if (__len1 + __len2 == 2) + { + if (__comp(__middle, __first)) + std::iter_swap(__first, __middle); + return; + } + + _BidirectionalIterator __first_cut = __first; + _BidirectionalIterator __second_cut = __middle; + _Distance __len11 = 0; + _Distance __len22 = 0; + if (__len1 > __len2) + { + __len11 = __len1 / 2; + std::advance(__first_cut, __len11); + __second_cut + = std::__lower_bound(__middle, __last, *__first_cut, + __gnu_cxx::__ops::__iter_comp_val(__comp)); + __len22 = std::distance(__middle, __second_cut); + } + else + { + __len22 = __len2 / 2; + std::advance(__second_cut, __len22); + __first_cut + = std::__upper_bound(__first, __middle, *__second_cut, + __gnu_cxx::__ops::__val_comp_iter(__comp)); + __len11 = std::distance(__first, __first_cut); + } + + std::rotate(__first_cut, __middle, __second_cut); + _BidirectionalIterator __new_middle = __first_cut; + std::advance(__new_middle, std::distance(__middle, __second_cut)); + std::__merge_without_buffer(__first, __first_cut, __new_middle, + __len11, __len22, __comp); + std::__merge_without_buffer(__new_middle, __second_cut, __last, + __len1 - __len11, __len2 - __len22, __comp); + } + + template + void + __inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_BidirectionalIterator>::value_type + _ValueType; + typedef typename iterator_traits<_BidirectionalIterator>::difference_type + _DistanceType; + + if (__first == __middle || __middle == __last) + return; + + const _DistanceType __len1 = std::distance(__first, __middle); + const _DistanceType __len2 = std::distance(__middle, __last); + + typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf; + _TmpBuf __buf(__first, __last); + + if (__buf.begin() == 0) + std::__merge_without_buffer + (__first, __middle, __last, __len1, __len2, __comp); + else + std::__merge_adaptive + (__first, __middle, __last, __len1, __len2, __buf.begin(), + _DistanceType(__buf.size()), __comp); + } +# 2584 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last) + { + + + + + + ; + ; + + std::__inplace_merge(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 2624 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + inplace_merge(_BidirectionalIterator __first, + _BidirectionalIterator __middle, + _BidirectionalIterator __last, + _Compare __comp) + { + + + + + + + ; + ; + + std::__inplace_merge(__first, __middle, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + + template + _OutputIterator + __move_merge(_InputIterator __first1, _InputIterator __last1, + _InputIterator __first2, _InputIterator __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + *__result = (*__first2); + ++__first2; + } + else + { + *__result = (*__first1); + ++__first1; + } + ++__result; + } + return std::copy(__first2, __last2, std::copy(__first1, __last1, __result)) + + ; + } + + template + void + __merge_sort_loop(_RandomAccessIterator1 __first, + _RandomAccessIterator1 __last, + _RandomAccessIterator2 __result, _Distance __step_size, + _Compare __comp) + { + const _Distance __two_step = 2 * __step_size; + + while (__last - __first >= __two_step) + { + __result = std::__move_merge(__first, __first + __step_size, + __first + __step_size, + __first + __two_step, + __result, __comp); + __first += __two_step; + } + __step_size = std::min(_Distance(__last - __first), __step_size); + + std::__move_merge(__first, __first + __step_size, + __first + __step_size, __last, __result, __comp); + } + + template + void + __chunk_insertion_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Distance __chunk_size, _Compare __comp) + { + while (__last - __first >= __chunk_size) + { + std::__insertion_sort(__first, __first + __chunk_size, __comp); + __first += __chunk_size; + } + std::__insertion_sort(__first, __last, __comp); + } + + enum { _S_chunk_size = 7 }; + + template + void + __merge_sort_with_buffer(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Pointer __buffer, _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _Distance; + + const _Distance __len = __last - __first; + const _Pointer __buffer_last = __buffer + __len; + + _Distance __step_size = _S_chunk_size; + std::__chunk_insertion_sort(__first, __last, __step_size, __comp); + + while (__step_size < __len) + { + std::__merge_sort_loop(__first, __last, __buffer, + __step_size, __comp); + __step_size *= 2; + std::__merge_sort_loop(__buffer, __buffer_last, __first, + __step_size, __comp); + __step_size *= 2; + } + } + + template + void + __stable_sort_adaptive(_RandomAccessIterator __first, + _RandomAccessIterator __last, + _Pointer __buffer, _Distance __buffer_size, + _Compare __comp) + { + const _Distance __len = (__last - __first + 1) / 2; + const _RandomAccessIterator __middle = __first + __len; + if (__len > __buffer_size) + { + std::__stable_sort_adaptive(__first, __middle, __buffer, + __buffer_size, __comp); + std::__stable_sort_adaptive(__middle, __last, __buffer, + __buffer_size, __comp); + } + else + { + std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp); + std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp); + } + std::__merge_adaptive(__first, __middle, __last, + _Distance(__middle - __first), + _Distance(__last - __middle), + __buffer, __buffer_size, + __comp); + } + + + template + void + __inplace_stable_sort(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + if (__last - __first < 15) + { + std::__insertion_sort(__first, __last, __comp); + return; + } + _RandomAccessIterator __middle = __first + (__last - __first) / 2; + std::__inplace_stable_sort(__first, __middle, __comp); + std::__inplace_stable_sort(__middle, __last, __comp); + std::__merge_without_buffer(__first, __middle, __last, + __middle - __first, + __last - __middle, + __comp); + } +# 2795 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + bool + __includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first2, __first1)) + return false; + else if (__comp(__first1, __first2)) + ++__first1; + else + ++__first1, ++__first2; + + return __first2 == __last2; + } +# 2831 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline bool + includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + + + + ; + ; + + return std::__includes(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 2873 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline bool + includes(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _Compare __comp) + { + + + + + + + + + + ; + ; + + return std::__includes(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 2906 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + bool + __next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + if (__first == __last) + return false; + _BidirectionalIterator __i = __first; + ++__i; + if (__i == __last) + return false; + __i = __last; + --__i; + + for(;;) + { + _BidirectionalIterator __ii = __i; + --__i; + if (__comp(__i, __ii)) + { + _BidirectionalIterator __j = __last; + while (!__comp(__i, --__j)) + {} + std::iter_swap(__i, __j); + std::__reverse(__ii, __last, + std::__iterator_category(__first)); + return true; + } + if (__i == __first) + { + std::__reverse(__first, __last, + std::__iterator_category(__first)); + return false; + } + } + } +# 2955 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + + + + + + ; + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } +# 2986 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline bool + next_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + + + + + + + ; + + return std::__next_permutation + (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + bool + __prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + if (__first == __last) + return false; + _BidirectionalIterator __i = __first; + ++__i; + if (__i == __last) + return false; + __i = __last; + --__i; + + for(;;) + { + _BidirectionalIterator __ii = __i; + --__i; + if (__comp(__ii, __i)) + { + _BidirectionalIterator __j = __last; + while (!__comp(--__j, __i)) + {} + std::iter_swap(__i, __j); + std::__reverse(__ii, __last, + std::__iterator_category(__first)); + return true; + } + if (__i == __first) + { + std::__reverse(__first, __last, + std::__iterator_category(__first)); + return false; + } + } + } +# 3053 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last) + { + + + + + + ; + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 3084 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline bool + prev_permutation(_BidirectionalIterator __first, + _BidirectionalIterator __last, _Compare __comp) + { + + + + + + + ; + + return std::__prev_permutation(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + + + + template + _OutputIterator + __replace_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _Predicate __pred, const _Tp& __new_value) + { + for (; __first != __last; ++__first, ++__result) + if (__pred(__first)) + *__result = __new_value; + else + *__result = *__first; + return __result; + } +# 3133 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + replace_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + const _Tp& __old_value, const _Tp& __new_value) + { + + + + + + + ; + + return std::__replace_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__iter_equals_val(__old_value), + __new_value); + } +# 3167 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + replace_copy_if(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _Predicate __pred, const _Tp& __new_value) + { + + + + + + + ; + + return std::__replace_copy_if(__first, __last, __result, + __gnu_cxx::__ops::__pred_iter(__pred), + __new_value); + } + + template + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } +# 3743 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + + + +# 3759 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _Function + for_each(_InputIterator __first, _InputIterator __last, _Function __f) + { + + + ; + for (; __first != __last; ++__first) + __f(*__first); + return (__f); + } +# 3780 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _InputIterator + find(_InputIterator __first, _InputIterator __last, + const _Tp& __val) + { + + + + + ; + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__val)); + } +# 3804 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _InputIterator + find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred) + { + + + + + ; + + return std::__find_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 3835 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _InputIterator + find_first_of(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, _ForwardIterator __last2) + { + + + + + + + ; + ; + + for (; __first1 != __last1; ++__first1) + for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) + if (*__first1 == *__iter) + return __first1; + return __last1; + } +# 3875 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _InputIterator + find_first_of(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, _ForwardIterator __last2, + _BinaryPredicate __comp) + { + + + + + + + ; + ; + + for (; __first1 != __last1; ++__first1) + for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter) + if (__comp(*__first1, *__iter)) + return __first1; + return __last1; + } +# 3907 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + + return std::__adjacent_find(__first, __last, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 3932 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + adjacent_find(_ForwardIterator __first, _ForwardIterator __last, + _BinaryPredicate __binary_pred) + { + + + + + + ; + + return std::__adjacent_find(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } +# 3957 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline typename iterator_traits<_InputIterator>::difference_type + count(_InputIterator __first, _InputIterator __last, const _Tp& __value) + { + + + + + ; + + return std::__count_if(__first, __last, + __gnu_cxx::__ops::__iter_equals_val(__value)); + } +# 3980 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline typename iterator_traits<_InputIterator>::difference_type + count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + + + + + ; + + return std::__count_if(__first, __last, + __gnu_cxx::__ops::__pred_iter(__pred)); + } +# 4020 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2) + { + + + + + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 4059 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator1 + search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _ForwardIterator2 __last2, + _BinaryPredicate __predicate) + { + + + + + + + ; + ; + + return std::__search(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__predicate)); + } +# 4094 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, const _Tp& __val) + { + + + + + ; + + return std::__search_n(__first, __last, __count, + __gnu_cxx::__ops::__iter_equals_val(__val)); + } +# 4127 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + search_n(_ForwardIterator __first, _ForwardIterator __last, + _Integer __count, const _Tp& __val, + _BinaryPredicate __binary_pred) + { + + + + + ; + + return std::__search_n(__first, __last, __count, + __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val)); + } +# 4161 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _OutputIterator + transform(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, _UnaryOperation __unary_op) + { + + + + + + ; + + for (; __first != __last; ++__first, ++__result) + *__result = __unary_op(*__first); + return __result; + } +# 4198 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _OutputIterator + transform(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _OutputIterator __result, + _BinaryOperation __binary_op) + { + + + + + + + ; + + for (; __first1 != __last1; ++__first1, ++__first2, ++__result) + *__result = __binary_op(*__first1, *__first2); + return __result; + } +# 4231 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + void + replace(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __old_value, const _Tp& __new_value) + { + + + + + + + + ; + + for (; __first != __last; ++__first) + if (*__first == __old_value) + *__first = __new_value; + } +# 4263 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + void + replace_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred, const _Tp& __new_value) + { + + + + + + + + ; + + for (; __first != __last; ++__first) + if (__pred(*__first)) + *__first = __new_value; + } +# 4295 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + void + generate(_ForwardIterator __first, _ForwardIterator __last, + _Generator __gen) + { + + + + + ; + + for (; __first != __last; ++__first) + *__first = __gen(); + } +# 4326 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + _OutputIterator + generate_n(_OutputIterator __first, _Size __n, _Generator __gen) + { + + + + + + for (__decltype(__n + 0) __niter = __n; + __niter > 0; --__niter, ++__first) + *__first = __gen(); + return __first; + } +# 4362 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result) + { + + + + + + + ; + + if (__first == __last) + return __result; + return std::__unique_copy(__first, __last, __result, + __gnu_cxx::__ops::__iter_equal_to_iter(), + std::__iterator_category(__first), + std::__iterator_category(__result)); + } +# 4402 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + unique_copy(_InputIterator __first, _InputIterator __last, + _OutputIterator __result, + _BinaryPredicate __binary_pred) + { + + + + + ; + + if (__first == __last) + return __result; + return std::__unique_copy(__first, __last, __result, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred), + std::__iterator_category(__first), + std::__iterator_category(__result)); + } +# 4434 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + ; + + if (__first != __last) + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + + _RandomAccessIterator __j = __first + + std::rand() % ((__i - __first) + 1); + if (__i != __j) + std::iter_swap(__i, __j); + } + } +# 4468 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + void + random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last, + + + + _RandomNumberGenerator& __rand) + + { + + + + ; + + if (__first == __last) + return; + for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i) + { + _RandomAccessIterator __j = __first + __rand((__i - __first) + 1); + if (__i != __j) + std::iter_swap(__i, __j); + } + } +# 4508 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _ForwardIterator + partition(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + + + + + + ; + + return std::__partition(__first, __last, __pred, + std::__iterator_category(__first)); + } +# 4541 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last) + { + + + + + + ; + ; + + std::__partial_sort(__first, __middle, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4578 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + partial_sort(_RandomAccessIterator __first, + _RandomAccessIterator __middle, + _RandomAccessIterator __last, + _Compare __comp) + { + + + + + + + ; + ; + + std::__partial_sort(__first, __middle, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 4613 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last) + { + + + + + + ; + ; + + if (__first == __last || __nth == __last) + return; + + std::__introselect(__first, __nth, __last, + std::__lg(__last - __first) * 2, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4651 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, + _RandomAccessIterator __last, _Compare __comp) + { + + + + + + + ; + ; + + if (__first == __last || __nth == __last) + return; + + std::__introselect(__first, __nth, __last, + std::__lg(__last - __first) * 2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 4687 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter()); + } +# 4716 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + + + + ; + + std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + *__result = *__first2; + ++__first2; + } + else + { + *__result = *__first1; + ++__first1; + } + ++__result; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } +# 4776 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + + + + + + + + + + + ; + ; + + return std::__merge(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4824 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + merge(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + + + + + + + + + + + ; + ; + + return std::__merge(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + inline void + __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf; + _TmpBuf __buf(__first, __last); + + if (__buf.begin() == 0) + std::__inplace_stable_sort(__first, __last, __comp); + else + std::__stable_sort_adaptive(__first, __last, __buf.begin(), + _DistanceType(__buf.size()), __comp); + } +# 4886 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + + std::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 4919 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline void + stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + + + + ; + + std::__stable_sort(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first1, __first2)) + { + *__result = *__first1; + ++__first1; + } + else if (__comp(__first2, __first1)) + { + *__result = *__first2; + ++__first2; + } + else + { + *__result = *__first1; + ++__first1; + ++__first2; + } + ++__result; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } +# 4986 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + + + + + + + + + + + + + + ; + ; + + return std::__set_union(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5033 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_union(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + + + + + + + + + + + + + + ; + ; + + return std::__set_union(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first1, __first2)) + ++__first1; + else if (__comp(__first2, __first1)) + ++__first2; + else + { + *__result = *__first1; + ++__first1; + ++__first2; + ++__result; + } + return __result; + } +# 5101 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + + + + + + + + + + + + ; + ; + + return std::__set_intersection(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5147 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_intersection(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + + + + + + + + + + + + ; + ; + + return std::__set_intersection(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first1, __first2)) + { + *__result = *__first1; + ++__first1; + ++__result; + } + else if (__comp(__first2, __first1)) + ++__first2; + else + { + ++__first1; + ++__first2; + } + return std::copy(__first1, __last1, __result); + } +# 5217 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + + + + + + + + + + + + ; + ; + + return std::__set_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5265 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, _Compare __comp) + { + + + + + + + + + + + + ; + ; + + return std::__set_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + _OutputIterator + __set_symmetric_difference(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _OutputIterator __result, + _Compare __comp) + { + while (__first1 != __last1 && __first2 != __last2) + if (__comp(__first1, __first2)) + { + *__result = *__first1; + ++__first1; + ++__result; + } + else if (__comp(__first2, __first1)) + { + *__result = *__first2; + ++__first2; + ++__result; + } + else + { + ++__first1; + ++__first2; + } + return std::copy(__first2, __last2, + std::copy(__first1, __last1, __result)); + } +# 5341 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result) + { + + + + + + + + + + + + + + ; + ; + + return std::__set_symmetric_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5389 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + inline _OutputIterator + set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _OutputIterator __result, + _Compare __comp) + { + + + + + + + + + + + + + + ; + ; + + return std::__set_symmetric_difference(__first1, __last1, + __first2, __last2, __result, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + + _ForwardIterator + __min_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + while (++__first != __last) + if (__comp(__first, __result)) + __result = __first; + return __result; + } +# 5440 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + + _ForwardIterator + inline min_element(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + + return std::__min_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5464 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + min_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + + + + + + ; + + return std::__min_element(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + template + + _ForwardIterator + __max_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + if (__first == __last) return __first; + _ForwardIterator __result = __first; + while (++__first != __last) + if (__comp(__result, __first)) + __result = __first; + return __result; + } +# 5502 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + max_element(_ForwardIterator __first, _ForwardIterator __last) + { + + + + + ; + + return std::__max_element(__first, __last, + __gnu_cxx::__ops::__iter_less_iter()); + } +# 5526 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_algo.h" 3 + template + + inline _ForwardIterator + max_element(_ForwardIterator __first, _ForwardIterator __last, + _Compare __comp) + { + + + + + + ; + + return std::__max_element(__first, __last, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } + + +} +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/algorithm" 2 3 +# 69 "/usr/include/qt4/QtCore/qglobal.h" 2 3 4 +# 1035 "/usr/include/qt4/QtCore/qglobal.h" 3 4 + + + + + + + + + +typedef signed char qint8; +typedef unsigned char quint8; +typedef short qint16; +typedef unsigned short quint16; +typedef int qint32; +typedef unsigned int quint32; +# 1058 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +typedef long long qint64; +typedef unsigned long long quint64; + + +typedef qint64 qlonglong; +typedef quint64 qulonglong; +# 1091 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +template struct QIntegerForSize; +template <> struct QIntegerForSize<1> { typedef quint8 Unsigned; typedef qint8 Signed; }; +template <> struct QIntegerForSize<2> { typedef quint16 Unsigned; typedef qint16 Signed; }; +template <> struct QIntegerForSize<4> { typedef quint32 Unsigned; typedef qint32 Signed; }; +template <> struct QIntegerForSize<8> { typedef quint64 Unsigned; typedef qint64 Signed; }; +template struct QIntegerForSizeof: QIntegerForSize { }; +typedef QIntegerForSizeof::Unsigned quintptr; +typedef QIntegerForSizeof::Signed qptrdiff; + + + + + + +typedef unsigned char uchar; +typedef unsigned short ushort; +typedef unsigned int uint; +typedef unsigned long ulong; + +# 1292 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +typedef int QNoImplicitBoolCast; +# 1304 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +typedef double qreal; + + + + + + +template + inline T qAbs(const T &t) { return t >= 0 ? t : -t; } + + inline int qRound(qreal d) +{ return d >= qreal(0.0) ? int(d + qreal(0.5)) : int(d - int(d-1) + qreal(0.5)) + int(d-1); } + + + + + + inline qint64 qRound64(qreal d) +{ return d >= qreal(0.0) ? qint64(d + qreal(0.5)) : qint64(d - qreal(qint64(d-1)) + qreal(0.5)) + qint64(d-1); } + + +template + inline const T &qMin(const T &a, const T &b) { return (a < b) ? a : b; } +template + inline const T &qMax(const T &a, const T &b) { return (a < b) ? b : a; } +template + inline const T &qBound(const T &min, const T &val, const T &max) +{ return qMax(min, qMin(max, val)); } +# 1362 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +class QDataStream; +# 1387 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qfeatures.h" 1 3 4 +# 1388 "/usr/include/qt4/QtCore/qglobal.h" 2 3 4 +# 1624 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +inline void qt_noop(void) {} +# 1657 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +class QString; +class QSysInfo { +public: + enum Sizes { + WordSize = (sizeof(void *)<<3) + }; +# 1672 "/usr/include/qt4/QtCore/qglobal.h" 3 4 + enum Endian { + BigEndian, + LittleEndian + + + + + + + , ByteOrder = LittleEndian + + + + }; +# 1794 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +}; + + const char *qVersion(); + bool qSharedBuild(); +# 1868 "/usr/include/qt4/QtCore/qglobal.h" 3 4 + void qDebug(const char *, ...) + + __attribute__ ((format (printf, 1, 2))) + +; + + void qWarning(const char *, ...) + + __attribute__ ((format (printf, 1, 2))) + +; + +class QString; + QString qt_error_string(int errorCode = -1); + void qCritical(const char *, ...) + + __attribute__ ((format (printf, 1, 2))) + +; + void qFatal(const char *, ...) + + __attribute__ ((format (printf, 1, 2))) + +; + + + + + void qErrnoWarning(int code, const char *msg, ...); + void qErrnoWarning(const char *msg, ...); +# 1908 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +class QDebug; +class QNoDebug; + + inline QDebug qDebug(); + + inline QDebug qWarning(); + + inline QDebug qCritical(); +# 1934 "/usr/include/qt4/QtCore/qglobal.h" 3 4 + void qt_assert(const char *assertion, const char *file, int line); +# 1948 "/usr/include/qt4/QtCore/qglobal.h" 3 4 + void qt_assert_x(const char *where, const char *what, const char *file, int line); +# 1958 "/usr/include/qt4/QtCore/qglobal.h" 3 4 + void qt_check_pointer(const char *, int); + void qBadAlloc(); +# 1971 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +template +inline T *q_check_ptr(T *p) { do { if (!(p)) qBadAlloc(); } while (0); return p; } +# 1996 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +enum QtMsgType { QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg = QtCriticalMsg }; + + void qt_message_output(QtMsgType, const char *buf); + +typedef void (*QtMsgHandler)(QtMsgType, const char *); + QtMsgHandler qInstallMsgHandler(QtMsgHandler); +# 2050 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +template class QBasicAtomicPointer; + + +template +class QGlobalStatic +{ +public: + QBasicAtomicPointer pointer; + bool destroyed; +}; + + +template +class QGlobalStaticDeleter +{ +public: + QGlobalStatic &globalStatic; + QGlobalStaticDeleter(QGlobalStatic &_globalStatic) + : globalStatic(_globalStatic) + { } + + inline ~QGlobalStaticDeleter() + { + delete globalStatic.pointer; + globalStatic.pointer = 0; + globalStatic.destroyed = true; + } +}; +# 2128 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +class QBool +{ + bool b; + +public: + inline explicit QBool(bool B) : b(B) {} + inline operator const void *() const + { return b ? static_cast(this) : static_cast(0); } +}; + +inline bool operator==(QBool b1, bool b2) { return !b1 == !b2; } +inline bool operator==(bool b1, QBool b2) { return !b1 == !b2; } +inline bool operator==(QBool b1, QBool b2) { return !b1 == !b2; } +inline bool operator!=(QBool b1, bool b2) { return !b1 != !b2; } +inline bool operator!=(bool b1, QBool b2) { return !b1 != !b2; } +inline bool operator!=(QBool b1, QBool b2) { return !b1 != !b2; } + + static inline bool qFuzzyCompare(double p1, double p2) +{ + return (qAbs(p1 - p2) <= 0.000000000001 * qMin(qAbs(p1), qAbs(p2))); +} + + static inline bool qFuzzyCompare(float p1, float p2) +{ + return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2))); +} + + + + + static inline bool qFuzzyIsNull(double d) +{ + return qAbs(d) <= 0.000000000001; +} + + + + + static inline bool qFuzzyIsNull(float f) +{ + return qAbs(f) <= 0.00001f; +} + + + + + + +static inline bool qIsNull(double d) +{ + union U { + double d; + quint64 u; + }; + U val; + val.d = d; + return val.u == quint64(0); +} + + + + + + +static inline bool qIsNull(float f) +{ + union U { + float f; + quint32 u; + }; + U val; + val.f = f; + return val.u == 0u; +} +# 2232 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +template inline bool qIsDetached(T &) { return true; } + +template +class QTypeInfo +{ +public: + enum { + isPointer = false, + isComplex = true, + isStatic = true, + isLarge = (sizeof(T)>sizeof(void*)), + isDummy = false + }; +}; + +template +class QTypeInfo +{ +public: + enum { + isPointer = true, + isComplex = false, + isStatic = false, + isLarge = false, + isDummy = false + }; +}; +# 2268 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +enum { + Q_COMPLEX_TYPE = 0, + Q_PRIMITIVE_TYPE = 0x1, + Q_STATIC_TYPE = 0, + Q_MOVABLE_TYPE = 0x2, + Q_DUMMY_TYPE = 0x4 +}; +# 2295 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +template +inline void qSwap(T &value1, T &value2) +{ + + + + + + using std::swap; + swap(value1, value2); + +} +# 2338 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(bool)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "bool"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "char"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(signed char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "signed char"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uchar)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uchar"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(short)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "short"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ushort)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ushort"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(int)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "int"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uint)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uint"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ulong)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ulong"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(qint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "qint64"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(quint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "quint64"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(float)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "float"; } }; +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "double"; } }; + +template<> class QTypeInfo { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long double"; } }; + + + + + + + void *qMalloc(size_t size); + void qFree(void *ptr); + void *qRealloc(void *ptr, size_t size); + void *qMallocAligned(size_t size, size_t alignment); + void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment); + void qFreeAligned(void *ptr); + void *qMemCopy(void *dest, const void *src, size_t n); + void *qMemSet(void *dest, int c, size_t n); +# 2404 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +class QFlag +{ + int i; +public: + inline QFlag(int i); + inline operator int() const { return i; } +}; + +inline QFlag::QFlag(int ai) : i(ai) {} + +class QIncompatibleFlag +{ + int i; +public: + inline explicit QIncompatibleFlag(int i); + inline operator int() const { return i; } +}; + +inline QIncompatibleFlag::QIncompatibleFlag(int ai) : i(ai) {} + + + + +template +class QFlags +{ + typedef void **Zero; + int i; +public: + typedef Enum enum_type; + inline QFlags(const QFlags &f) : i(f.i) {} + inline QFlags(Enum f) : i(f) {} + inline QFlags(Zero = 0) : i(0) {} + inline QFlags(QFlag f) : i(f) {} + + inline QFlags &operator=(const QFlags &f) { i = f.i; return *this; } + inline QFlags &operator&=(int mask) { i &= mask; return *this; } + inline QFlags &operator&=(uint mask) { i &= mask; return *this; } + inline QFlags &operator|=(QFlags f) { i |= f.i; return *this; } + inline QFlags &operator|=(Enum f) { i |= f; return *this; } + inline QFlags &operator^=(QFlags f) { i ^= f.i; return *this; } + inline QFlags &operator^=(Enum f) { i ^= f; return *this; } + + inline operator int() const { return i; } + + inline QFlags operator|(QFlags f) const { return QFlags(Enum(i | f.i)); } + inline QFlags operator|(Enum f) const { return QFlags(Enum(i | f)); } + inline QFlags operator^(QFlags f) const { return QFlags(Enum(i ^ f.i)); } + inline QFlags operator^(Enum f) const { return QFlags(Enum(i ^ f)); } + inline QFlags operator&(int mask) const { return QFlags(Enum(i & mask)); } + inline QFlags operator&(uint mask) const { return QFlags(Enum(i & mask)); } + inline QFlags operator&(Enum f) const { return QFlags(Enum(i & f)); } + inline QFlags operator~() const { return QFlags(Enum(~i)); } + + inline bool operator!() const { return !i; } + + inline bool testFlag(Enum f) const { return (i & f) == f && (f != 0 || i == int(f) ); } +}; +# 2487 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +template +class QForeachContainer { +public: + inline QForeachContainer(const T& t) : c(t), brk(0), i(c.begin()), e(c.end()) { } + const T c; + int brk; + typename T::const_iterator i, e; +}; +# 2579 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +template static inline T *qGetPtrHelper(T *ptr) { return ptr; } +template static inline typename Wrapper::pointer qGetPtrHelper(const Wrapper &p) { return p.data(); } +# 2612 "/usr/include/qt4/QtCore/qglobal.h" 3 4 + QString qtTrId(const char *id, int n = -1); +# 2642 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +class QByteArray; + QByteArray qgetenv(const char *varName); + bool qputenv(const char *varName, const QByteArray& value); + +inline int qIntCast(double f) { return int(f); } +inline int qIntCast(float f) { return int(f); } + + + + + void qsrand(uint seed); + int qrand(); +# 2841 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +enum QtValidLicenseForCoreModule { LicensedCore = true }; + + +enum QtValidLicenseForGuiModule { LicensedGui = true }; + + +enum QtValidLicenseForNetworkModule { LicensedNetwork = true }; + + +enum QtValidLicenseForOpenGLModule { LicensedOpenGL = true }; + + +enum QtValidLicenseForOpenVGModule { LicensedOpenVG = true }; + + +enum QtValidLicenseForSqlModule { LicensedSql = true }; + + +enum QtValidLicenseForMultimediaModule { LicensedMultimedia = true }; + + +enum QtValidLicenseForXmlModule { LicensedXml = true }; + + +enum QtValidLicenseForXmlPatternsModule { LicensedXmlPatterns = true }; + + +enum QtValidLicenseForHelpModule { LicensedHelp = true }; + + +enum QtValidLicenseForScriptModule { LicensedScript = true }; + + +enum QtValidLicenseForScriptToolsModule { LicensedScriptTools = true }; + + +enum QtValidLicenseForQt3SupportLightModule { LicensedQt3SupportLight = true }; + + +enum QtValidLicenseForQt3SupportModule { LicensedQt3Support = true }; + + +enum QtValidLicenseForSvgModule { LicensedSvg = true }; + + +enum QtValidLicenseForDeclarativeModule { LicensedDeclarative = true }; + + +enum QtValidLicenseForActiveQtModule { LicensedActiveQt = true }; + + +enum QtValidLicenseForTestModule { LicensedTest = true }; + + +enum QtValidLicenseForDBusModule { LicensedDBus = true }; +# 2925 "/usr/include/qt4/QtCore/qglobal.h" 3 4 +namespace QtPrivate { + +template struct QEnableIf; +template struct QEnableIf { typedef T Type; }; +} + + + +# 46 "/usr/include/qt4/QtCore/qnamespace.h" 2 3 4 + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + + +namespace + + + +Qt { +# 104 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + enum GlobalColor { + color0, + color1, + black, + white, + darkGray, + gray, + lightGray, + red, + green, + blue, + cyan, + magenta, + yellow, + darkRed, + darkGreen, + darkBlue, + darkCyan, + darkMagenta, + darkYellow, + transparent + }; + + enum KeyboardModifier { + NoModifier = 0x00000000, + ShiftModifier = 0x02000000, + ControlModifier = 0x04000000, + AltModifier = 0x08000000, + MetaModifier = 0x10000000, + KeypadModifier = 0x20000000, + GroupSwitchModifier = 0x40000000, + + KeyboardModifierMask = 0xfe000000 + }; + typedef QFlags KeyboardModifiers; + + + enum Modifier { + META = Qt::MetaModifier, + SHIFT = Qt::ShiftModifier, + CTRL = Qt::ControlModifier, + ALT = Qt::AltModifier, + MODIFIER_MASK = KeyboardModifierMask, + UNICODE_ACCEL = 0x00000000 + }; + + enum MouseButton { + NoButton = 0x00000000, + LeftButton = 0x00000001, + RightButton = 0x00000002, + MidButton = 0x00000004, + MiddleButton = MidButton, + XButton1 = 0x00000008, + XButton2 = 0x00000010, + MouseButtonMask = 0x000000ff + }; + typedef QFlags MouseButtons; +# 174 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + enum Orientation { + Horizontal = 0x1, + Vertical = 0x2 + }; + + typedef QFlags Orientations; + + enum FocusPolicy { + NoFocus = 0, + TabFocus = 0x1, + ClickFocus = 0x2, + StrongFocus = TabFocus | ClickFocus | 0x8, + WheelFocus = StrongFocus | 0x4 + }; + + enum SortOrder { + AscendingOrder, + DescendingOrder + + + + + }; + + enum TileRule { + StretchTile, + RepeatTile, + RoundTile + }; + + + + + + enum AlignmentFlag { + AlignLeft = 0x0001, + AlignLeading = AlignLeft, + AlignRight = 0x0002, + AlignTrailing = AlignRight, + AlignHCenter = 0x0004, + AlignJustify = 0x0008, + AlignAbsolute = 0x0010, + AlignHorizontal_Mask = AlignLeft | AlignRight | AlignHCenter | AlignJustify | AlignAbsolute, + + AlignTop = 0x0020, + AlignBottom = 0x0040, + AlignVCenter = 0x0080, + AlignVertical_Mask = AlignTop | AlignBottom | AlignVCenter, + + AlignCenter = AlignVCenter | AlignHCenter + + + + }; + + typedef QFlags Alignment; + + enum TextFlag { + TextSingleLine = 0x0100, + TextDontClip = 0x0200, + TextExpandTabs = 0x0400, + TextShowMnemonic = 0x0800, + TextWordWrap = 0x1000, + TextWrapAnywhere = 0x2000, + TextDontPrint = 0x4000, + TextIncludeTrailingSpaces = 0x08000000, + TextHideMnemonic = 0x8000, + TextJustificationForced = 0x10000, + TextForceLeftToRight = 0x20000, + TextForceRightToLeft = 0x40000, + TextLongestVariant = 0x80000, + TextBypassShaping = 0x100000 +# 258 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + }; + + + + + enum TextElideMode { + ElideLeft, + ElideRight, + ElideMiddle, + ElideNone + }; + + enum WindowType { + Widget = 0x00000000, + Window = 0x00000001, + Dialog = 0x00000002 | Window, + Sheet = 0x00000004 | Window, + Drawer = 0x00000006 | Window, + Popup = 0x00000008 | Window, + Tool = 0x0000000a | Window, + ToolTip = 0x0000000c | Window, + SplashScreen = 0x0000000e | Window, + Desktop = 0x00000010 | Window, + SubWindow = 0x00000012, + + WindowType_Mask = 0x000000ff, + MSWindowsFixedSizeDialogHint = 0x00000100, + MSWindowsOwnDC = 0x00000200, + X11BypassWindowManagerHint = 0x00000400, + FramelessWindowHint = 0x00000800, + WindowTitleHint = 0x00001000, + WindowSystemMenuHint = 0x00002000, + WindowMinimizeButtonHint = 0x00004000, + WindowMaximizeButtonHint = 0x00008000, + WindowMinMaxButtonsHint = WindowMinimizeButtonHint | WindowMaximizeButtonHint, + WindowContextHelpButtonHint = 0x00010000, + WindowShadeButtonHint = 0x00020000, + WindowStaysOnTopHint = 0x00040000, + + + + + + + + CustomizeWindowHint = 0x02000000, + WindowStaysOnBottomHint = 0x04000000, + WindowCloseButtonHint = 0x08000000, + MacWindowToolBarButtonHint = 0x10000000, + BypassGraphicsProxyWidget = 0x20000000, + WindowOkButtonHint = 0x00080000, + WindowCancelButtonHint = 0x00100000, + WindowSoftkeysVisibleHint = 0x40000000, + WindowSoftkeysRespondHint = 0x80000000 +# 362 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + }; + + typedef QFlags WindowFlags; + + enum WindowState { + WindowNoState = 0x00000000, + WindowMinimized = 0x00000001, + WindowMaximized = 0x00000002, + WindowFullScreen = 0x00000004, + WindowActive = 0x00000008 + }; + + typedef QFlags WindowStates; + + enum WidgetAttribute { + WA_Disabled = 0, + WA_UnderMouse = 1, + WA_MouseTracking = 2, + WA_ContentsPropagated = 3, + WA_OpaquePaintEvent = 4, + WA_NoBackground = WA_OpaquePaintEvent, + WA_StaticContents = 5, + WA_LaidOut = 7, + WA_PaintOnScreen = 8, + WA_NoSystemBackground = 9, + WA_UpdatesDisabled = 10, + WA_Mapped = 11, + WA_MacNoClickThrough = 12, + WA_PaintOutsidePaintEvent = 13, + WA_InputMethodEnabled = 14, + WA_WState_Visible = 15, + WA_WState_Hidden = 16, + + WA_ForceDisabled = 32, + WA_KeyCompression = 33, + WA_PendingMoveEvent = 34, + WA_PendingResizeEvent = 35, + WA_SetPalette = 36, + WA_SetFont = 37, + WA_SetCursor = 38, + WA_NoChildEventsFromChildren = 39, + WA_WindowModified = 41, + WA_Resized = 42, + WA_Moved = 43, + WA_PendingUpdate = 44, + WA_InvalidSize = 45, + WA_MacBrushedMetal = 46, + WA_MacMetalStyle = WA_MacBrushedMetal, + WA_CustomWhatsThis = 47, + WA_LayoutOnEntireRect = 48, + WA_OutsideWSRange = 49, + WA_GrabbedShortcut = 50, + WA_TransparentForMouseEvents = 51, + WA_PaintUnclipped = 52, + WA_SetWindowIcon = 53, + WA_NoMouseReplay = 54, + WA_DeleteOnClose = 55, + WA_RightToLeft = 56, + WA_SetLayoutDirection = 57, + WA_NoChildEventsForParent = 58, + WA_ForceUpdatesDisabled = 59, + + WA_WState_Created = 60, + WA_WState_CompressKeys = 61, + WA_WState_InPaintEvent = 62, + WA_WState_Reparented = 63, + WA_WState_ConfigPending = 64, + WA_WState_Polished = 66, + WA_WState_DND = 67, + WA_WState_OwnSizePolicy = 68, + WA_WState_ExplicitShowHide = 69, + + WA_ShowModal = 70, + WA_MouseNoMask = 71, + WA_GroupLeader = 72, + WA_NoMousePropagation = 73, + WA_Hover = 74, + WA_InputMethodTransparent = 75, + WA_QuitOnClose = 76, + + WA_KeyboardFocusChange = 77, + + WA_AcceptDrops = 78, + WA_DropSiteRegistered = 79, + WA_ForceAcceptDrops = WA_DropSiteRegistered, + + WA_WindowPropagation = 80, + + WA_NoX11EventCompression = 81, + WA_TintedBackground = 82, + WA_X11OpenGLOverlay = 83, + WA_AlwaysShowToolTips = 84, + WA_MacOpaqueSizeGrip = 85, + WA_SetStyle = 86, + + WA_SetLocale = 87, + WA_MacShowFocusRect = 88, + + WA_MacNormalSize = 89, + WA_MacSmallSize = 90, + WA_MacMiniSize = 91, + + WA_LayoutUsesWidgetRect = 92, + WA_StyledBackground = 93, + WA_MSWindowsUseDirect3D = 94, + WA_CanHostQMdiSubWindowTitleBar = 95, + + WA_MacAlwaysShowToolWindow = 96, + + WA_StyleSheet = 97, + + WA_ShowWithoutActivating = 98, + + WA_X11BypassTransientForHint = 99, + + WA_NativeWindow = 100, + WA_DontCreateNativeAncestors = 101, + + WA_MacVariableSize = 102, + + WA_DontShowOnScreen = 103, + + + WA_X11NetWmWindowTypeDesktop = 104, + WA_X11NetWmWindowTypeDock = 105, + WA_X11NetWmWindowTypeToolBar = 106, + WA_X11NetWmWindowTypeMenu = 107, + WA_X11NetWmWindowTypeUtility = 108, + WA_X11NetWmWindowTypeSplash = 109, + WA_X11NetWmWindowTypeDialog = 110, + WA_X11NetWmWindowTypeDropDownMenu = 111, + WA_X11NetWmWindowTypePopupMenu = 112, + WA_X11NetWmWindowTypeToolTip = 113, + WA_X11NetWmWindowTypeNotification = 114, + WA_X11NetWmWindowTypeCombo = 115, + WA_X11NetWmWindowTypeDND = 116, + + WA_MacFrameworkScaled = 117, + + WA_SetWindowModality = 118, + WA_WState_WindowOpacitySet = 119, + WA_TranslucentBackground = 120, + + WA_AcceptTouchEvents = 121, + WA_WState_AcceptedTouchBeginEvent = 122, + WA_TouchPadAcceptSingleTouchEvents = 123, + + WA_MergeSoftkeys = 124, + WA_MergeSoftkeysRecursively = 125, + + + + + + + WA_LockPortraitOrientation = 128, + WA_LockLandscapeOrientation = 129, + WA_AutoOrientation = 130, +# 528 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + WA_X11DoNotAcceptFocus = 132, + WA_SymbianNoSystemRotation = 133, + WA_MacNoShadow = 134, + + + WA_AttributeCount + }; + + enum ApplicationAttribute + { + AA_ImmediateWidgetCreation = 0, + AA_MSWindowsUseDirect3DByDefault = 1, + AA_DontShowIconsInMenus = 2, + AA_NativeWindows = 3, + AA_DontCreateNativeWidgetSiblings = 4, + AA_MacPluginApplication = 5, + AA_DontUseNativeMenuBar = 6, + AA_MacDontSwapCtrlAndMeta = 7, + AA_S60DontConstructApplicationPanes = 8, + AA_S60DisablePartialScreenInputMode = 9, + AA_X11InitThreads = 10, + AA_CaptureMultimediaKeys = 11, + + + AA_AttributeCount + }; + + + + + + enum ImageConversionFlag { + ColorMode_Mask = 0x00000003, + AutoColor = 0x00000000, + ColorOnly = 0x00000003, + MonoOnly = 0x00000002, + + + AlphaDither_Mask = 0x0000000c, + ThresholdAlphaDither = 0x00000000, + OrderedAlphaDither = 0x00000004, + DiffuseAlphaDither = 0x00000008, + NoAlpha = 0x0000000c, + + Dither_Mask = 0x00000030, + DiffuseDither = 0x00000000, + OrderedDither = 0x00000010, + ThresholdDither = 0x00000020, + + + DitherMode_Mask = 0x000000c0, + AutoDither = 0x00000000, + PreferDither = 0x00000040, + AvoidDither = 0x00000080, + + NoOpaqueDetection = 0x00000100, + NoFormatConversion = 0x00000200 + }; + typedef QFlags ImageConversionFlags; + + enum BGMode { + TransparentMode, + OpaqueMode + }; +# 612 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + enum Key { + Key_Escape = 0x01000000, + Key_Tab = 0x01000001, + Key_Backtab = 0x01000002, + + + + Key_Backspace = 0x01000003, + + + + Key_Return = 0x01000004, + Key_Enter = 0x01000005, + Key_Insert = 0x01000006, + Key_Delete = 0x01000007, + Key_Pause = 0x01000008, + Key_Print = 0x01000009, + Key_SysReq = 0x0100000a, + Key_Clear = 0x0100000b, + Key_Home = 0x01000010, + Key_End = 0x01000011, + Key_Left = 0x01000012, + Key_Up = 0x01000013, + Key_Right = 0x01000014, + Key_Down = 0x01000015, + Key_PageUp = 0x01000016, + + + + Key_PageDown = 0x01000017, + + + + Key_Shift = 0x01000020, + Key_Control = 0x01000021, + Key_Meta = 0x01000022, + Key_Alt = 0x01000023, + Key_CapsLock = 0x01000024, + Key_NumLock = 0x01000025, + Key_ScrollLock = 0x01000026, + Key_F1 = 0x01000030, + Key_F2 = 0x01000031, + Key_F3 = 0x01000032, + Key_F4 = 0x01000033, + Key_F5 = 0x01000034, + Key_F6 = 0x01000035, + Key_F7 = 0x01000036, + Key_F8 = 0x01000037, + Key_F9 = 0x01000038, + Key_F10 = 0x01000039, + Key_F11 = 0x0100003a, + Key_F12 = 0x0100003b, + Key_F13 = 0x0100003c, + Key_F14 = 0x0100003d, + Key_F15 = 0x0100003e, + Key_F16 = 0x0100003f, + Key_F17 = 0x01000040, + Key_F18 = 0x01000041, + Key_F19 = 0x01000042, + Key_F20 = 0x01000043, + Key_F21 = 0x01000044, + Key_F22 = 0x01000045, + Key_F23 = 0x01000046, + Key_F24 = 0x01000047, + Key_F25 = 0x01000048, + Key_F26 = 0x01000049, + Key_F27 = 0x0100004a, + Key_F28 = 0x0100004b, + Key_F29 = 0x0100004c, + Key_F30 = 0x0100004d, + Key_F31 = 0x0100004e, + Key_F32 = 0x0100004f, + Key_F33 = 0x01000050, + Key_F34 = 0x01000051, + Key_F35 = 0x01000052, + Key_Super_L = 0x01000053, + Key_Super_R = 0x01000054, + Key_Menu = 0x01000055, + Key_Hyper_L = 0x01000056, + Key_Hyper_R = 0x01000057, + Key_Help = 0x01000058, + Key_Direction_L = 0x01000059, + Key_Direction_R = 0x01000060, + Key_Space = 0x20, + Key_Any = Key_Space, + Key_Exclam = 0x21, + Key_QuoteDbl = 0x22, + Key_NumberSign = 0x23, + Key_Dollar = 0x24, + Key_Percent = 0x25, + Key_Ampersand = 0x26, + Key_Apostrophe = 0x27, + Key_ParenLeft = 0x28, + Key_ParenRight = 0x29, + Key_Asterisk = 0x2a, + Key_Plus = 0x2b, + Key_Comma = 0x2c, + Key_Minus = 0x2d, + Key_Period = 0x2e, + Key_Slash = 0x2f, + Key_0 = 0x30, + Key_1 = 0x31, + Key_2 = 0x32, + Key_3 = 0x33, + Key_4 = 0x34, + Key_5 = 0x35, + Key_6 = 0x36, + Key_7 = 0x37, + Key_8 = 0x38, + Key_9 = 0x39, + Key_Colon = 0x3a, + Key_Semicolon = 0x3b, + Key_Less = 0x3c, + Key_Equal = 0x3d, + Key_Greater = 0x3e, + Key_Question = 0x3f, + Key_At = 0x40, + Key_A = 0x41, + Key_B = 0x42, + Key_C = 0x43, + Key_D = 0x44, + Key_E = 0x45, + Key_F = 0x46, + Key_G = 0x47, + Key_H = 0x48, + Key_I = 0x49, + Key_J = 0x4a, + Key_K = 0x4b, + Key_L = 0x4c, + Key_M = 0x4d, + Key_N = 0x4e, + Key_O = 0x4f, + Key_P = 0x50, + Key_Q = 0x51, + Key_R = 0x52, + Key_S = 0x53, + Key_T = 0x54, + Key_U = 0x55, + Key_V = 0x56, + Key_W = 0x57, + Key_X = 0x58, + Key_Y = 0x59, + Key_Z = 0x5a, + Key_BracketLeft = 0x5b, + Key_Backslash = 0x5c, + Key_BracketRight = 0x5d, + Key_AsciiCircum = 0x5e, + Key_Underscore = 0x5f, + Key_QuoteLeft = 0x60, + Key_BraceLeft = 0x7b, + Key_Bar = 0x7c, + Key_BraceRight = 0x7d, + Key_AsciiTilde = 0x7e, + + Key_nobreakspace = 0x0a0, + Key_exclamdown = 0x0a1, + Key_cent = 0x0a2, + Key_sterling = 0x0a3, + Key_currency = 0x0a4, + Key_yen = 0x0a5, + Key_brokenbar = 0x0a6, + Key_section = 0x0a7, + Key_diaeresis = 0x0a8, + Key_copyright = 0x0a9, + Key_ordfeminine = 0x0aa, + Key_guillemotleft = 0x0ab, + Key_notsign = 0x0ac, + Key_hyphen = 0x0ad, + Key_registered = 0x0ae, + Key_macron = 0x0af, + Key_degree = 0x0b0, + Key_plusminus = 0x0b1, + Key_twosuperior = 0x0b2, + Key_threesuperior = 0x0b3, + Key_acute = 0x0b4, + Key_mu = 0x0b5, + Key_paragraph = 0x0b6, + Key_periodcentered = 0x0b7, + Key_cedilla = 0x0b8, + Key_onesuperior = 0x0b9, + Key_masculine = 0x0ba, + Key_guillemotright = 0x0bb, + Key_onequarter = 0x0bc, + Key_onehalf = 0x0bd, + Key_threequarters = 0x0be, + Key_questiondown = 0x0bf, + Key_Agrave = 0x0c0, + Key_Aacute = 0x0c1, + Key_Acircumflex = 0x0c2, + Key_Atilde = 0x0c3, + Key_Adiaeresis = 0x0c4, + Key_Aring = 0x0c5, + Key_AE = 0x0c6, + Key_Ccedilla = 0x0c7, + Key_Egrave = 0x0c8, + Key_Eacute = 0x0c9, + Key_Ecircumflex = 0x0ca, + Key_Ediaeresis = 0x0cb, + Key_Igrave = 0x0cc, + Key_Iacute = 0x0cd, + Key_Icircumflex = 0x0ce, + Key_Idiaeresis = 0x0cf, + Key_ETH = 0x0d0, + Key_Ntilde = 0x0d1, + Key_Ograve = 0x0d2, + Key_Oacute = 0x0d3, + Key_Ocircumflex = 0x0d4, + Key_Otilde = 0x0d5, + Key_Odiaeresis = 0x0d6, + Key_multiply = 0x0d7, + Key_Ooblique = 0x0d8, + Key_Ugrave = 0x0d9, + Key_Uacute = 0x0da, + Key_Ucircumflex = 0x0db, + Key_Udiaeresis = 0x0dc, + Key_Yacute = 0x0dd, + Key_THORN = 0x0de, + Key_ssharp = 0x0df, +# 855 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + Key_division = 0x0f7, +# 865 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + Key_ydiaeresis = 0x0ff, + + + + + + + Key_AltGr = 0x01001103, + Key_Multi_key = 0x01001120, + Key_Codeinput = 0x01001137, + Key_SingleCandidate = 0x0100113c, + Key_MultipleCandidate = 0x0100113d, + Key_PreviousCandidate = 0x0100113e, + + + Key_Mode_switch = 0x0100117e, + + + + Key_Kanji = 0x01001121, + Key_Muhenkan = 0x01001122, + + Key_Henkan = 0x01001123, + Key_Romaji = 0x01001124, + Key_Hiragana = 0x01001125, + Key_Katakana = 0x01001126, + Key_Hiragana_Katakana = 0x01001127, + Key_Zenkaku = 0x01001128, + Key_Hankaku = 0x01001129, + Key_Zenkaku_Hankaku = 0x0100112a, + Key_Touroku = 0x0100112b, + Key_Massyo = 0x0100112c, + Key_Kana_Lock = 0x0100112d, + Key_Kana_Shift = 0x0100112e, + Key_Eisu_Shift = 0x0100112f, + Key_Eisu_toggle = 0x01001130, +# 910 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + Key_Hangul = 0x01001131, + Key_Hangul_Start = 0x01001132, + Key_Hangul_End = 0x01001133, + Key_Hangul_Hanja = 0x01001134, + Key_Hangul_Jamo = 0x01001135, + Key_Hangul_Romaja = 0x01001136, + + Key_Hangul_Jeonja = 0x01001138, + Key_Hangul_Banja = 0x01001139, + Key_Hangul_PreHanja = 0x0100113a, + Key_Hangul_PostHanja = 0x0100113b, + + + + Key_Hangul_Special = 0x0100113f, + + + + Key_Dead_Grave = 0x01001250, + Key_Dead_Acute = 0x01001251, + Key_Dead_Circumflex = 0x01001252, + Key_Dead_Tilde = 0x01001253, + Key_Dead_Macron = 0x01001254, + Key_Dead_Breve = 0x01001255, + Key_Dead_Abovedot = 0x01001256, + Key_Dead_Diaeresis = 0x01001257, + Key_Dead_Abovering = 0x01001258, + Key_Dead_Doubleacute = 0x01001259, + Key_Dead_Caron = 0x0100125a, + Key_Dead_Cedilla = 0x0100125b, + Key_Dead_Ogonek = 0x0100125c, + Key_Dead_Iota = 0x0100125d, + Key_Dead_Voiced_Sound = 0x0100125e, + Key_Dead_Semivoiced_Sound = 0x0100125f, + Key_Dead_Belowdot = 0x01001260, + Key_Dead_Hook = 0x01001261, + Key_Dead_Horn = 0x01001262, + + + Key_Back = 0x01000061, + Key_Forward = 0x01000062, + Key_Stop = 0x01000063, + Key_Refresh = 0x01000064, + Key_VolumeDown = 0x01000070, + Key_VolumeMute = 0x01000071, + Key_VolumeUp = 0x01000072, + Key_BassBoost = 0x01000073, + Key_BassUp = 0x01000074, + Key_BassDown = 0x01000075, + Key_TrebleUp = 0x01000076, + Key_TrebleDown = 0x01000077, + Key_MediaPlay = 0x01000080, + Key_MediaStop = 0x01000081, + Key_MediaPrevious = 0x01000082, + + + + Key_MediaNext = 0x01000083, + Key_MediaRecord = 0x01000084, + Key_MediaPause = 0x1000085, + Key_MediaTogglePlayPause = 0x1000086, + Key_HomePage = 0x01000090, + Key_Favorites = 0x01000091, + Key_Search = 0x01000092, + Key_Standby = 0x01000093, + Key_OpenUrl = 0x01000094, + Key_LaunchMail = 0x010000a0, + Key_LaunchMedia = 0x010000a1, + Key_Launch0 = 0x010000a2, + Key_Launch1 = 0x010000a3, + Key_Launch2 = 0x010000a4, + Key_Launch3 = 0x010000a5, + Key_Launch4 = 0x010000a6, + Key_Launch5 = 0x010000a7, + Key_Launch6 = 0x010000a8, + Key_Launch7 = 0x010000a9, + Key_Launch8 = 0x010000aa, + Key_Launch9 = 0x010000ab, + Key_LaunchA = 0x010000ac, + Key_LaunchB = 0x010000ad, + Key_LaunchC = 0x010000ae, + Key_LaunchD = 0x010000af, + Key_LaunchE = 0x010000b0, + Key_LaunchF = 0x010000b1, + Key_MonBrightnessUp = 0x010000b2, + Key_MonBrightnessDown = 0x010000b3, + Key_KeyboardLightOnOff = 0x010000b4, + Key_KeyboardBrightnessUp = 0x010000b5, + Key_KeyboardBrightnessDown = 0x010000b6, + Key_PowerOff = 0x010000b7, + Key_WakeUp = 0x010000b8, + Key_Eject = 0x010000b9, + Key_ScreenSaver = 0x010000ba, + Key_WWW = 0x010000bb, + Key_Memo = 0x010000bc, + Key_LightBulb = 0x010000bd, + Key_Shop = 0x010000be, + Key_History = 0x010000bf, + Key_AddFavorite = 0x010000c0, + Key_HotLinks = 0x010000c1, + Key_BrightnessAdjust = 0x010000c2, + Key_Finance = 0x010000c3, + Key_Community = 0x010000c4, + Key_AudioRewind = 0x010000c5, + Key_BackForward = 0x010000c6, + Key_ApplicationLeft = 0x010000c7, + Key_ApplicationRight = 0x010000c8, + Key_Book = 0x010000c9, + Key_CD = 0x010000ca, + Key_Calculator = 0x010000cb, + Key_ToDoList = 0x010000cc, + Key_ClearGrab = 0x010000cd, + Key_Close = 0x010000ce, + Key_Copy = 0x010000cf, + Key_Cut = 0x010000d0, + Key_Display = 0x010000d1, + Key_DOS = 0x010000d2, + Key_Documents = 0x010000d3, + Key_Excel = 0x010000d4, + Key_Explorer = 0x010000d5, + Key_Game = 0x010000d6, + Key_Go = 0x010000d7, + Key_iTouch = 0x010000d8, + Key_LogOff = 0x010000d9, + Key_Market = 0x010000da, + Key_Meeting = 0x010000db, + Key_MenuKB = 0x010000dc, + Key_MenuPB = 0x010000dd, + Key_MySites = 0x010000de, + Key_News = 0x010000df, + Key_OfficeHome = 0x010000e0, + Key_Option = 0x010000e1, + Key_Paste = 0x010000e2, + Key_Phone = 0x010000e3, + Key_Calendar = 0x010000e4, + Key_Reply = 0x010000e5, + Key_Reload = 0x010000e6, + Key_RotateWindows = 0x010000e7, + Key_RotationPB = 0x010000e8, + Key_RotationKB = 0x010000e9, + Key_Save = 0x010000ea, + Key_Send = 0x010000eb, + Key_Spell = 0x010000ec, + Key_SplitScreen = 0x010000ed, + Key_Support = 0x010000ee, + Key_TaskPane = 0x010000ef, + Key_Terminal = 0x010000f0, + Key_Tools = 0x010000f1, + Key_Travel = 0x010000f2, + Key_Video = 0x010000f3, + Key_Word = 0x010000f4, + Key_Xfer = 0x010000f5, + Key_ZoomIn = 0x010000f6, + Key_ZoomOut = 0x010000f7, + Key_Away = 0x010000f8, + Key_Messenger = 0x010000f9, + Key_WebCam = 0x010000fa, + Key_MailForward = 0x010000fb, + Key_Pictures = 0x010000fc, + Key_Music = 0x010000fd, + Key_Battery = 0x010000fe, + Key_Bluetooth = 0x010000ff, + Key_WLAN = 0x01000100, + Key_UWB = 0x01000101, + Key_AudioForward = 0x01000102, + Key_AudioRepeat = 0x01000103, + Key_AudioRandomPlay = 0x01000104, + Key_Subtitle = 0x01000105, + Key_AudioCycleTrack = 0x01000106, + Key_Time = 0x01000107, + Key_Hibernate = 0x01000108, + Key_View = 0x01000109, + Key_TopMenu = 0x0100010a, + Key_PowerDown = 0x0100010b, + Key_Suspend = 0x0100010c, + Key_ContrastAdjust = 0x0100010d, + + Key_LaunchG = 0x0100010e, + Key_LaunchH = 0x0100010f, + + Key_MediaLast = 0x0100ffff, + + + Key_Select = 0x01010000, + Key_Yes = 0x01010001, + Key_No = 0x01010002, + + + Key_Cancel = 0x01020001, + Key_Printer = 0x01020002, + Key_Execute = 0x01020003, + Key_Sleep = 0x01020004, + Key_Play = 0x01020005, + Key_Zoom = 0x01020006, + + + + + + Key_Context1 = 0x01100000, + Key_Context2 = 0x01100001, + Key_Context3 = 0x01100002, + Key_Context4 = 0x01100003, + Key_Call = 0x01100004, + Key_Hangup = 0x01100005, + Key_Flip = 0x01100006, + Key_ToggleCallHangup = 0x01100007, + Key_VoiceDial = 0x01100008, + Key_LastNumberRedial = 0x01100009, + + Key_Camera = 0x01100020, + Key_CameraFocus = 0x01100021, + + Key_unknown = 0x01ffffff + }; + + enum ArrowType { + NoArrow, + UpArrow, + DownArrow, + LeftArrow, + RightArrow + }; + + enum PenStyle { + NoPen, + SolidLine, + DashLine, + DotLine, + DashDotLine, + DashDotDotLine, + CustomDashLine + + , MPenStyle = 0x0f + + }; + + enum PenCapStyle { + FlatCap = 0x00, + SquareCap = 0x10, + RoundCap = 0x20, + MPenCapStyle = 0x30 + }; + + enum PenJoinStyle { + MiterJoin = 0x00, + BevelJoin = 0x40, + RoundJoin = 0x80, + SvgMiterJoin = 0x100, + MPenJoinStyle = 0x1c0 + }; + + enum BrushStyle { + NoBrush, + SolidPattern, + Dense1Pattern, + Dense2Pattern, + Dense3Pattern, + Dense4Pattern, + Dense5Pattern, + Dense6Pattern, + Dense7Pattern, + HorPattern, + VerPattern, + CrossPattern, + BDiagPattern, + FDiagPattern, + DiagCrossPattern, + LinearGradientPattern, + RadialGradientPattern, + ConicalGradientPattern, + TexturePattern = 24 + + + + }; + + enum SizeMode { + AbsoluteSize, + RelativeSize + }; +# 1252 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + enum UIEffect { + UI_General, + UI_AnimateMenu, + UI_FadeMenu, + UI_AnimateCombo, + UI_AnimateTooltip, + UI_FadeTooltip, + UI_AnimateToolBox + }; + + enum CursorShape { + ArrowCursor, + UpArrowCursor, + CrossCursor, + WaitCursor, + IBeamCursor, + SizeVerCursor, + SizeHorCursor, + SizeBDiagCursor, + SizeFDiagCursor, + SizeAllCursor, + BlankCursor, + SplitVCursor, + SplitHCursor, + PointingHandCursor, + ForbiddenCursor, + WhatsThisCursor, + BusyCursor, + OpenHandCursor, + ClosedHandCursor, + DragCopyCursor, + DragMoveCursor, + DragLinkCursor, + LastCursor = DragLinkCursor, + BitmapCursor = 24, + CustomCursor = 25 +# 1308 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + }; + + enum TextFormat { + PlainText, + RichText, + AutoText, + LogText + }; + + enum AspectRatioMode { + IgnoreAspectRatio, + KeepAspectRatio, + KeepAspectRatioByExpanding + + + + + + }; + + + + + + enum AnchorAttribute { + AnchorName, + AnchorHref + }; + + enum DockWidgetArea { + LeftDockWidgetArea = 0x1, + RightDockWidgetArea = 0x2, + TopDockWidgetArea = 0x4, + BottomDockWidgetArea = 0x8, + + DockWidgetArea_Mask = 0xf, + AllDockWidgetAreas = DockWidgetArea_Mask, + NoDockWidgetArea = 0 + }; + enum DockWidgetAreaSizes { + NDockWidgetAreas = 4 + }; + + typedef QFlags DockWidgetAreas; + + enum ToolBarArea { + LeftToolBarArea = 0x1, + RightToolBarArea = 0x2, + TopToolBarArea = 0x4, + BottomToolBarArea = 0x8, + + ToolBarArea_Mask = 0xf, + AllToolBarAreas = ToolBarArea_Mask, + NoToolBarArea = 0 + }; + + enum ToolBarAreaSizes { + NToolBarAreas = 4 + }; + + typedef QFlags ToolBarAreas; +# 1392 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + enum DateFormat { + TextDate, + ISODate, + SystemLocaleDate, + LocalDate = SystemLocaleDate, + LocaleDate, + SystemLocaleShortDate, + SystemLocaleLongDate, + DefaultLocaleShortDate, + DefaultLocaleLongDate + }; + + enum TimeSpec { + LocalTime, + UTC, + OffsetFromUTC + }; + + enum DayOfWeek { + Monday = 1, + Tuesday = 2, + Wednesday = 3, + Thursday = 4, + Friday = 5, + Saturday = 6, + Sunday = 7 + }; + + enum ScrollBarPolicy { + ScrollBarAsNeeded, + ScrollBarAlwaysOff, + ScrollBarAlwaysOn + }; +# 1451 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + enum CaseSensitivity { + CaseInsensitive, + CaseSensitive + }; + + enum Corner { + TopLeftCorner = 0x00000, + TopRightCorner = 0x00001, + BottomLeftCorner = 0x00002, + BottomRightCorner = 0x00003 + + + + + + + }; + + enum ConnectionType { + AutoConnection, + DirectConnection, + QueuedConnection, + AutoCompatConnection, + BlockingQueuedConnection, + UniqueConnection = 0x80 + }; + + enum ShortcutContext { + WidgetShortcut, + WindowShortcut, + ApplicationShortcut, + WidgetWithChildrenShortcut + }; + + enum FillRule { + OddEvenFill, + WindingFill + }; + + enum MaskMode { + MaskInColor, + MaskOutColor + }; + + enum ClipOperation { + NoClip, + ReplaceClip, + IntersectClip, + UniteClip + }; + + + enum ItemSelectionMode { + ContainsItemShape = 0x0, + IntersectsItemShape = 0x1, + ContainsItemBoundingRect = 0x2, + IntersectsItemBoundingRect = 0x3 + }; + + enum TransformationMode { + FastTransformation, + SmoothTransformation + }; + + enum Axis { + XAxis, + YAxis, + ZAxis + }; + + enum FocusReason { + MouseFocusReason, + TabFocusReason, + BacktabFocusReason, + ActiveWindowFocusReason, + PopupFocusReason, + ShortcutFocusReason, + MenuBarFocusReason, + OtherFocusReason, + NoFocusReason + }; + + enum ContextMenuPolicy { + NoContextMenu, + DefaultContextMenu, + ActionsContextMenu, + CustomContextMenu, + PreventContextMenu + }; + + enum InputMethodQuery { + ImMicroFocus, + ImFont, + ImCursorPosition, + ImSurroundingText, + ImCurrentSelection, + ImMaximumTextLength, + ImAnchorPosition + }; + + enum InputMethodHint { + ImhNone = 0x0, + ImhHiddenText = 0x1, + ImhNoAutoUppercase = 0x2, + ImhPreferNumbers = 0x4, + ImhPreferUppercase = 0x8, + ImhPreferLowercase = 0x10, + ImhNoPredictiveText = 0x20, + + ImhDigitsOnly = 0x10000, + ImhFormattedNumbersOnly = 0x20000, + ImhUppercaseOnly = 0x40000, + ImhLowercaseOnly = 0x80000, + ImhDialableCharactersOnly = 0x100000, + ImhEmailCharactersOnly = 0x200000, + ImhUrlCharactersOnly = 0x400000, + + ImhExclusiveInputMask = 0xffff0000 + }; + typedef QFlags InputMethodHints; + + enum ToolButtonStyle { + ToolButtonIconOnly, + ToolButtonTextOnly, + ToolButtonTextBesideIcon, + ToolButtonTextUnderIcon, + ToolButtonFollowStyle + }; + + enum LayoutDirection { + LeftToRight, + RightToLeft, + LayoutDirectionAuto + }; + + enum AnchorPoint { + AnchorLeft = 0, + AnchorHorizontalCenter, + AnchorRight, + AnchorTop, + AnchorVerticalCenter, + AnchorBottom + }; + + + + enum DropAction { + CopyAction = 0x1, + MoveAction = 0x2, + LinkAction = 0x4, + ActionMask = 0xff, + TargetMoveAction = 0x8002, + IgnoreAction = 0x0 + }; + typedef QFlags DropActions; + + enum CheckState { + Unchecked, + PartiallyChecked, + Checked + }; + + enum ItemDataRole { + DisplayRole = 0, + DecorationRole = 1, + EditRole = 2, + ToolTipRole = 3, + StatusTipRole = 4, + WhatsThisRole = 5, + + FontRole = 6, + TextAlignmentRole = 7, + BackgroundColorRole = 8, + BackgroundRole = 8, + TextColorRole = 9, + ForegroundRole = 9, + CheckStateRole = 10, + + AccessibleTextRole = 11, + AccessibleDescriptionRole = 12, + + SizeHintRole = 13, + InitialSortOrderRole = 14, + + DisplayPropertyRole = 27, + DecorationPropertyRole = 28, + ToolTipPropertyRole = 29, + StatusTipPropertyRole = 30, + WhatsThisPropertyRole = 31, + + UserRole = 32 + }; + + enum ItemFlag { + NoItemFlags = 0, + ItemIsSelectable = 1, + ItemIsEditable = 2, + ItemIsDragEnabled = 4, + ItemIsDropEnabled = 8, + ItemIsUserCheckable = 16, + ItemIsEnabled = 32, + ItemIsTristate = 64 + }; + typedef QFlags ItemFlags; + + enum MatchFlag { + MatchExactly = 0, + MatchContains = 1, + MatchStartsWith = 2, + MatchEndsWith = 3, + MatchRegExp = 4, + MatchWildcard = 5, + MatchFixedString = 8, + MatchCaseSensitive = 16, + MatchWrap = 32, + MatchRecursive = 64 + }; + typedef QFlags MatchFlags; + + + + + + + typedef unsigned long HANDLE; + + + + + + typedef WindowFlags WFlags; + + enum WindowModality { + NonModal, + WindowModal, + ApplicationModal + }; + + enum TextInteractionFlag { + NoTextInteraction = 0, + TextSelectableByMouse = 1, + TextSelectableByKeyboard = 2, + LinksAccessibleByMouse = 4, + LinksAccessibleByKeyboard = 8, + TextEditable = 16, + + TextEditorInteraction = TextSelectableByMouse | TextSelectableByKeyboard | TextEditable, + TextBrowserInteraction = TextSelectableByMouse | LinksAccessibleByMouse | LinksAccessibleByKeyboard + }; + typedef QFlags TextInteractionFlags; + + enum EventPriority { + HighEventPriority = 1, + NormalEventPriority = 0, + LowEventPriority = -1 + }; + + enum SizeHint { + MinimumSize, + PreferredSize, + MaximumSize, + MinimumDescent, + NSizeHints + }; + + enum WindowFrameSection { + NoSection, + LeftSection, + TopLeftSection, + TopSection, + TopRightSection, + RightSection, + BottomRightSection, + BottomSection, + BottomLeftSection, + TitleBarArea + }; + + enum Initialization { + Uninitialized + }; + + enum CoordinateSystem { + DeviceCoordinates, + LogicalCoordinates + }; + + enum TouchPointState { + TouchPointPressed = 0x01, + TouchPointMoved = 0x02, + TouchPointStationary = 0x04, + TouchPointReleased = 0x08, + TouchPointStateMask = 0x0f, + + TouchPointPrimary = 0x10 + }; + typedef QFlags TouchPointStates; + + + enum GestureState + { + NoGesture, + GestureStarted = 1, + GestureUpdated = 2, + GestureFinished = 3, + GestureCanceled = 4 + }; + + enum GestureType + { + TapGesture = 1, + TapAndHoldGesture = 2, + PanGesture = 3, + PinchGesture = 4, + SwipeGesture = 5, + + CustomGesture = 0x0100, + + LastGestureType = ~0u + }; + + enum GestureFlag + { + DontStartGestureOnChildren = 0x01, + ReceivePartialGestures = 0x02, + IgnoredGesturesPropagateToParent = 0x04 + }; + typedef QFlags GestureFlags; + + + enum NavigationMode + { + NavigationModeNone, + NavigationModeKeypadTabOrder, + NavigationModeKeypadDirectional, + NavigationModeCursorAuto, + NavigationModeCursorForceVisible + }; + + enum CursorMoveStyle { + LogicalMoveStyle, + VisualMoveStyle + }; +} + + + + + inline QFlags operator|(Qt::MouseButtons::enum_type f1, Qt::MouseButtons::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::MouseButtons::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MouseButtons::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::Orientations::enum_type f1, Qt::Orientations::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::Orientations::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Orientations::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::KeyboardModifiers::enum_type f1, Qt::KeyboardModifiers::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::KeyboardModifiers::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::KeyboardModifiers::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::WindowFlags::enum_type f1, Qt::WindowFlags::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::WindowFlags::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::Alignment::enum_type f1, Qt::Alignment::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::Alignment::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Alignment::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::ImageConversionFlags::enum_type f1, Qt::ImageConversionFlags::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::ImageConversionFlags::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ImageConversionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::DockWidgetAreas::enum_type f1, Qt::DockWidgetAreas::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::DockWidgetAreas::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DockWidgetAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::ToolBarAreas::enum_type f1, Qt::ToolBarAreas::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::ToolBarAreas::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ToolBarAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::WindowStates::enum_type f1, Qt::WindowStates::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::WindowStates::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::DropActions::enum_type f1, Qt::DropActions::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::DropActions::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DropActions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::ItemFlags::enum_type f1, Qt::ItemFlags::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::ItemFlags::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ItemFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::MatchFlags::enum_type f1, Qt::MatchFlags::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::MatchFlags::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MatchFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::TextInteractionFlags::enum_type f1, Qt::TextInteractionFlags::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::TextInteractionFlags::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TextInteractionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::InputMethodHints::enum_type f1, Qt::InputMethodHints::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::InputMethodHints::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::InputMethodHints::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + inline QFlags operator|(Qt::TouchPointStates::enum_type f1, Qt::TouchPointStates::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::TouchPointStates::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TouchPointStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + + inline QFlags operator|(Qt::GestureFlags::enum_type f1, Qt::GestureFlags::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(Qt::GestureFlags::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::GestureFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + + +typedef bool (*qInternalCallback)(void **); + +class QInternal { +public: + enum PaintDeviceFlags { + UnknownDevice = 0x00, + Widget = 0x01, + Pixmap = 0x02, + Image = 0x03, + Printer = 0x04, + Picture = 0x05, + Pbuffer = 0x06, + FramebufferObject = 0x07, + CustomRaster = 0x08, + MacQuartz = 0x09, + PaintBuffer = 0x0a, + OpenGL = 0x0b + }; + enum RelayoutType { + RelayoutNormal, + RelayoutDragging, + RelayoutDropped + }; + + + enum Callback { + ConnectCallback, + DisconnectCallback, + AdoptCurrentThread, + EventNotifyCallback, + LastCallback + }; + + enum InternalFunction { + CreateThreadForAdoption, + RefAdoptedThread, + DerefAdoptedThread, + SetCurrentThreadToMainThread, + SetQObjectSender, + GetQObjectSender, + ResetQObjectSender, + LastInternalFunction + }; + + enum DockPosition { + LeftDock, + RightDock, + TopDock, + BottomDock, + DockCount + }; + + static bool registerCallback(Callback, qInternalCallback); + static bool unregisterCallback(Callback, qInternalCallback); + + static bool activateCallbacks(Callback, void **); + static bool callFunction(InternalFunction func, void **); +}; +# 1885 "/usr/include/qt4/QtCore/qnamespace.h" 3 4 + + + +# 46 "/usr/include/qt4/QtCore/qobjectdefs.h" 2 3 4 + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QByteArray; + +class QString; +# 143 "/usr/include/qt4/QtCore/qobjectdefs.h" 3 4 +template +inline int qYouForgotTheQ_OBJECT_Macro(T, T) { return 0; } + +template +inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {} +# 217 "/usr/include/qt4/QtCore/qobjectdefs.h" 3 4 + const char *qFlagLocation(const char *method); +# 249 "/usr/include/qt4/QtCore/qobjectdefs.h" 3 4 +class QObject; +class QMetaMethod; +class QMetaEnum; +class QMetaProperty; +class QMetaClassInfo; + + +class QGenericArgument +{ +public: + inline QGenericArgument(const char *aName = 0, const void *aData = 0) + : _data(aData), _name(aName) {} + inline void *data() const { return const_cast(_data); } + inline const char *name() const { return _name; } + +private: + const void *_data; + const char *_name; +}; + +class QGenericReturnArgument: public QGenericArgument +{ +public: + inline QGenericReturnArgument(const char *aName = 0, void *aData = 0) + : QGenericArgument(aName, aData) + {} +}; + +template +class QArgument: public QGenericArgument +{ +public: + inline QArgument(const char *aName, const T &aData) + : QGenericArgument(aName, static_cast(&aData)) + {} +}; +template +class QArgument: public QGenericArgument +{ +public: + inline QArgument(const char *aName, T &aData) + : QGenericArgument(aName, static_cast(&aData)) + {} +}; + + +template +class QReturnArgument: public QGenericReturnArgument +{ +public: + inline QReturnArgument(const char *aName, T &aData) + : QGenericReturnArgument(aName, static_cast(&aData)) + {} +}; + +struct QMetaObject +{ + const char *className() const; + const QMetaObject *superClass() const; + + QObject *cast(QObject *obj) const; + const QObject *cast(const QObject *obj) const; + + + + QString tr(const char *s, const char *c) const; + QString trUtf8(const char *s, const char *c) const; + QString tr(const char *s, const char *c, int n) const; + QString trUtf8(const char *s, const char *c, int n) const; + + + int methodOffset() const; + int enumeratorOffset() const; + int propertyOffset() const; + int classInfoOffset() const; + + int constructorCount() const; + int methodCount() const; + int enumeratorCount() const; + int propertyCount() const; + int classInfoCount() const; + + int indexOfConstructor(const char *constructor) const; + int indexOfMethod(const char *method) const; + int indexOfSignal(const char *signal) const; + int indexOfSlot(const char *slot) const; + int indexOfEnumerator(const char *name) const; + int indexOfProperty(const char *name) const; + int indexOfClassInfo(const char *name) const; + + QMetaMethod constructor(int index) const; + QMetaMethod method(int index) const; + QMetaEnum enumerator(int index) const; + QMetaProperty property(int index) const; + QMetaClassInfo classInfo(int index) const; + QMetaProperty userProperty() const; + + static bool checkConnectArgs(const char *signal, const char *method); + static QByteArray normalizedSignature(const char *method); + static QByteArray normalizedType(const char *type); + + + static bool connect(const QObject *sender, int signal_index, + const QObject *receiver, int method_index, + int type = 0, int *types = 0); + + static bool disconnect(const QObject *sender, int signal_index, + const QObject *receiver, int method_index); + static bool disconnectOne(const QObject *sender, int signal_index, + const QObject *receiver, int method_index); + + static void connectSlotsByName(QObject *o); + + + static void activate(QObject *sender, int signal_index, void **argv); + static void activate(QObject *sender, int from_signal_index, int to_signal_index, void **argv); + static void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv); + static void activate(QObject *sender, const QMetaObject *, int from_local_signal_index, int to_local_signal_index, void **argv); + + + static void addGuard(QObject **ptr); + static void removeGuard(QObject **ptr); + static void changeGuard(QObject **ptr, QObject *o); + + static bool invokeMethod(QObject *obj, const char *member, + Qt::ConnectionType, + QGenericReturnArgument ret, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()); + + static inline bool invokeMethod(QObject *obj, const char *member, + QGenericReturnArgument ret, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) + { + return invokeMethod(obj, member, Qt::AutoConnection, ret, val0, val1, val2, val3, + val4, val5, val6, val7, val8, val9); + } + + static inline bool invokeMethod(QObject *obj, const char *member, + Qt::ConnectionType type, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) + { + return invokeMethod(obj, member, type, QGenericReturnArgument(), val0, val1, val2, + val3, val4, val5, val6, val7, val8, val9); + } + + static inline bool invokeMethod(QObject *obj, const char *member, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) + { + return invokeMethod(obj, member, Qt::AutoConnection, QGenericReturnArgument(), val0, + val1, val2, val3, val4, val5, val6, val7, val8, val9); + } + + QObject *newInstance(QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) const; + + enum Call { + InvokeMetaMethod, + ReadProperty, + WriteProperty, + ResetProperty, + QueryPropertyDesignable, + QueryPropertyScriptable, + QueryPropertyStored, + QueryPropertyEditable, + QueryPropertyUser, + CreateInstance + }; + + int static_metacall(Call, int, void **) const; + static int metacall(QObject *, Call, int, void **); + + + + + + struct { + const QMetaObject *superdata; + const char *stringdata; + const uint *data; + const void *extradata; + } d; +}; + +typedef const QMetaObject& (*QMetaObjectAccessor)(); + +struct QMetaObjectExtraData +{ + + + + const QMetaObject **objects; + + + typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **); + + StaticMetacallFunction static_metacall; +}; + +inline const char *QMetaObject::className() const +{ return d.stringdata; } + +inline const QMetaObject *QMetaObject::superClass() const +{ return d.superdata; } + + + + + + + + + +# 48 "/usr/include/qt4/QtCore/qobject.h" 2 3 4 +# 1 "/usr/include/qt4/QtCore/qstring.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qstring.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qchar.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qchar.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QString; + +struct QLatin1Char +{ +public: + inline explicit QLatin1Char(char c) : ch(c) {} + + + + + inline char toLatin1() const { return ch; } + inline ushort unicode() const { return ushort(uchar(ch)); } + + +private: + char ch; +}; + + +class QChar { +public: + QChar(); + + QChar(char c); + QChar(uchar c); + + QChar(QLatin1Char ch); + QChar(uchar c, uchar r); + inline QChar(ushort rc) : ucs(rc){} + QChar(short rc); + QChar(uint rc); + QChar(int rc); + enum SpecialCharacter { + Null = 0x0000, + Nbsp = 0x00a0, + ReplacementCharacter = 0xfffd, + ObjectReplacementCharacter = 0xfffc, + ByteOrderMark = 0xfeff, + ByteOrderSwapped = 0xfffe, + + + + + + + + ParagraphSeparator = 0x2029, + LineSeparator = 0x2028 + }; + QChar(SpecialCharacter sc); + + + + enum Category + { + NoCategory, + + Mark_NonSpacing, + Mark_SpacingCombining, + Mark_Enclosing, + + Number_DecimalDigit, + Number_Letter, + Number_Other, + + Separator_Space, + Separator_Line, + Separator_Paragraph, + + Other_Control, + Other_Format, + Other_Surrogate, + Other_PrivateUse, + Other_NotAssigned, + + Letter_Uppercase, + Letter_Lowercase, + Letter_Titlecase, + Letter_Modifier, + Letter_Other, + + Punctuation_Connector, + Punctuation_Dash, + Punctuation_Open, + Punctuation_Close, + Punctuation_InitialQuote, + Punctuation_FinalQuote, + Punctuation_Other, + + Symbol_Math, + Symbol_Currency, + Symbol_Modifier, + Symbol_Other, + + Punctuation_Dask = Punctuation_Dash + }; + + enum Direction + { + DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON, + DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN + }; + + enum Decomposition + { + NoDecomposition, + Canonical, + Font, + NoBreak, + Initial, + Medial, + Final, + Isolated, + Circle, + Super, + Sub, + Vertical, + Wide, + Narrow, + Small, + Square, + Compat, + Fraction + + + + + }; + + enum Joining + { + OtherJoining, Dual, Right, Center + }; + + enum CombiningClass + { + Combining_BelowLeftAttached = 200, + Combining_BelowAttached = 202, + Combining_BelowRightAttached = 204, + Combining_LeftAttached = 208, + Combining_RightAttached = 210, + Combining_AboveLeftAttached = 212, + Combining_AboveAttached = 214, + Combining_AboveRightAttached = 216, + + Combining_BelowLeft = 218, + Combining_Below = 220, + Combining_BelowRight = 222, + Combining_Left = 224, + Combining_Right = 226, + Combining_AboveLeft = 228, + Combining_Above = 230, + Combining_AboveRight = 232, + + Combining_DoubleBelow = 233, + Combining_DoubleAbove = 234, + Combining_IotaSubscript = 240 + }; + + enum UnicodeVersion { + Unicode_Unassigned, + Unicode_1_1, + Unicode_2_0, + Unicode_2_1_2, + Unicode_3_0, + Unicode_3_1, + Unicode_3_2, + Unicode_4_0, + Unicode_4_1, + Unicode_5_0 + }; + + + Category category() const; + Direction direction() const; + Joining joining() const; + bool hasMirrored() const; + unsigned char combiningClass() const; + + QChar mirroredChar() const; + QString decomposition() const; + Decomposition decompositionTag() const; + + int digitValue() const; + QChar toLower() const; + QChar toUpper() const; + QChar toTitleCase() const; + QChar toCaseFolded() const; + + UnicodeVersion unicodeVersion() const; + + + + + + + char toAscii() const; + inline char toLatin1() const; + inline ushort unicode() const { return ucs; } + + + inline ushort &unicode() { return const_cast(ucs); } + + + + + static QChar fromAscii(char c); + static QChar fromLatin1(char c); + + inline bool isNull() const { return ucs == 0; } + bool isPrint() const; + bool isPunct() const; + bool isSpace() const; + bool isMark() const; + bool isLetter() const; + bool isNumber() const; + bool isLetterOrNumber() const; + bool isDigit() const; + bool isSymbol() const; + inline bool isLower() const { return category() == Letter_Lowercase; } + inline bool isUpper() const { return category() == Letter_Uppercase; } + inline bool isTitleCase() const { return category() == Letter_Titlecase; } + + inline bool isHighSurrogate() const { + return ((ucs & 0xfc00) == 0xd800); + } + inline bool isLowSurrogate() const { + return ((ucs & 0xfc00) == 0xdc00); + } + + inline uchar cell() const { return uchar(ucs & 0xff); } + inline uchar row() const { return uchar((ucs>>8)&0xff); } + inline void setCell(uchar cell); + inline void setRow(uchar row); + + static inline bool isHighSurrogate(uint ucs4) { + return ((ucs4 & 0xfffffc00) == 0xd800); + } + static inline bool isLowSurrogate(uint ucs4) { + return ((ucs4 & 0xfffffc00) == 0xdc00); + } + static inline bool requiresSurrogates(uint ucs4) { + return (ucs4 >= 0x10000); + } + static inline uint surrogateToUcs4(ushort high, ushort low) { + return (uint(high)<<10) + low - 0x35fdc00; + } + static inline uint surrogateToUcs4(QChar high, QChar low) { + return (uint(high.ucs)<<10) + low.ucs - 0x35fdc00; + } + static inline ushort highSurrogate(uint ucs4) { + return ushort((ucs4>>10) + 0xd7c0); + } + static inline ushort lowSurrogate(uint ucs4) { + return ushort(ucs4%0x400 + 0xdc00); + } + + static Category category(uint ucs4); + static Category category(ushort ucs2); + static Direction direction(uint ucs4); + static Direction direction(ushort ucs2); + static Joining joining(uint ucs4); + static Joining joining(ushort ucs2); + static unsigned char combiningClass(uint ucs4); + static unsigned char combiningClass(ushort ucs2); + + static uint mirroredChar(uint ucs4); + static ushort mirroredChar(ushort ucs2); + static Decomposition decompositionTag(uint ucs4); + + static int digitValue(uint ucs4); + static int digitValue(ushort ucs2); + static uint toLower(uint ucs4); + static ushort toLower(ushort ucs2); + static uint toUpper(uint ucs4); + static ushort toUpper(ushort ucs2); + static uint toTitleCase(uint ucs4); + static ushort toTitleCase(ushort ucs2); + static uint toCaseFolded(uint ucs4); + static ushort toCaseFolded(ushort ucs2); + + static UnicodeVersion unicodeVersion(uint ucs4); + static UnicodeVersion unicodeVersion(ushort ucs2); + + static UnicodeVersion currentUnicodeVersion(); + + static QString decomposition(uint ucs4); +# 357 "/usr/include/qt4/QtCore/qchar.h" 3 4 +private: + + + + + ushort ucs; +} + + + +; + +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QChar)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QChar"; } }; + +inline QChar::QChar() : ucs(0) {} + + + + +inline char QChar::toLatin1() const { return ucs > 0xff ? '\0' : char(ucs); } + +inline QChar QChar::fromLatin1(char c) { return QChar(ushort(uchar(c))); } + +inline QChar::QChar(uchar c, uchar r) : ucs(ushort((r << 8) | c)){} +inline QChar::QChar(short rc) : ucs(ushort(rc)){} +inline QChar::QChar(uint rc) : ucs(ushort(rc & 0xffff)){} +inline QChar::QChar(int rc) : ucs(ushort(rc & 0xffff)){} +inline QChar::QChar(SpecialCharacter s) : ucs(ushort(s)) {} +inline QChar::QChar(QLatin1Char ch) : ucs(ch.unicode()) {} + +inline void QChar::setCell(uchar acell) +{ ucs = ushort((ucs & 0xff00) + acell); } +inline void QChar::setRow(uchar arow) +{ ucs = ushort((ushort(arow)<<8) + (ucs&0xff)); } + +inline bool operator==(QChar c1, QChar c2) { return c1.unicode() == c2.unicode(); } +inline bool operator!=(QChar c1, QChar c2) { return c1.unicode() != c2.unicode(); } +inline bool operator<=(QChar c1, QChar c2) { return c1.unicode() <= c2.unicode(); } +inline bool operator>=(QChar c1, QChar c2) { return c1.unicode() >= c2.unicode(); } +inline bool operator<(QChar c1, QChar c2) { return c1.unicode() < c2.unicode(); } +inline bool operator>(QChar c1, QChar c2) { return c1.unicode() > c2.unicode(); } + + + QDataStream &operator<<(QDataStream &, const QChar &); + QDataStream &operator>>(QDataStream &, QChar &); + + + + + +# 46 "/usr/include/qt4/QtCore/qstring.h" 2 3 4 +# 1 "/usr/include/qt4/QtCore/qbytearray.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qbytearray.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qatomic.h" 1 3 4 +# 46 "/usr/include/qt4/QtCore/qatomic.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qbasicatomic.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qbasicatomic.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QBasicAtomicInt +{ +public: +# 64 "/usr/include/qt4/QtCore/qbasicatomic.h" 3 4 + volatile int _q_value; + + + + inline bool operator==(int value) const + { + return _q_value == value; + } + + inline bool operator!=(int value) const + { + return _q_value != value; + } + + inline bool operator!() const + { + return _q_value == 0; + } + + inline operator int() const + { + return _q_value; + } + + inline QBasicAtomicInt &operator=(int value) + { + + + + _q_value = value; + return *this; + } + + + + static bool isReferenceCountingNative(); + static bool isReferenceCountingWaitFree(); + + bool ref(); + bool deref(); + + static bool isTestAndSetNative(); + static bool isTestAndSetWaitFree(); + + bool testAndSetRelaxed(int expectedValue, int newValue); + bool testAndSetAcquire(int expectedValue, int newValue); + bool testAndSetRelease(int expectedValue, int newValue); + bool testAndSetOrdered(int expectedValue, int newValue); + + static bool isFetchAndStoreNative(); + static bool isFetchAndStoreWaitFree(); + + int fetchAndStoreRelaxed(int newValue); + int fetchAndStoreAcquire(int newValue); + int fetchAndStoreRelease(int newValue); + int fetchAndStoreOrdered(int newValue); + + static bool isFetchAndAddNative(); + static bool isFetchAndAddWaitFree(); + + int fetchAndAddRelaxed(int valueToAdd); + int fetchAndAddAcquire(int valueToAdd); + int fetchAndAddRelease(int valueToAdd); + int fetchAndAddOrdered(int valueToAdd); +}; + +template +class QBasicAtomicPointer +{ +public: +# 148 "/usr/include/qt4/QtCore/qbasicatomic.h" 3 4 + T * volatile _q_value; + + + + inline bool operator==(T *value) const + { + return _q_value == value; + } + + inline bool operator!=(T *value) const + { + return !operator==(value); + } + + inline bool operator!() const + { + return operator==(0); + } + + inline operator T *() const + { + return _q_value; + } + + inline T *operator->() const + { + return _q_value; + } + + inline QBasicAtomicPointer &operator=(T *value) + { + + + + _q_value = value; + return *this; + } + + + + static bool isTestAndSetNative(); + static bool isTestAndSetWaitFree(); + + bool testAndSetRelaxed(T *expectedValue, T *newValue); + bool testAndSetAcquire(T *expectedValue, T *newValue); + bool testAndSetRelease(T *expectedValue, T *newValue); + bool testAndSetOrdered(T *expectedValue, T *newValue); + + static bool isFetchAndStoreNative(); + static bool isFetchAndStoreWaitFree(); + + T *fetchAndStoreRelaxed(T *newValue); + T *fetchAndStoreAcquire(T *newValue); + T *fetchAndStoreRelease(T *newValue); + T *fetchAndStoreOrdered(T *newValue); + + static bool isFetchAndAddNative(); + static bool isFetchAndAddWaitFree(); + + T *fetchAndAddRelaxed(qptrdiff valueToAdd); + T *fetchAndAddAcquire(qptrdiff valueToAdd); + T *fetchAndAddRelease(qptrdiff valueToAdd); + T *fetchAndAddOrdered(qptrdiff valueToAdd); +}; +# 221 "/usr/include/qt4/QtCore/qbasicatomic.h" 3 4 + + + + + + +# 1 "/usr/include/qt4/QtCore/qatomic_arch.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qatomic_arch.h" 3 4 + +# 88 "/usr/include/qt4/QtCore/qatomic_arch.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qatomic_x86_64.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qatomic_x86_64.h" 3 4 + + + + + + + +inline bool QBasicAtomicInt::isReferenceCountingNative() +{ return true; } +inline bool QBasicAtomicInt::isReferenceCountingWaitFree() +{ return true; } + + + + +inline bool QBasicAtomicInt::isTestAndSetNative() +{ return true; } +inline bool QBasicAtomicInt::isTestAndSetWaitFree() +{ return true; } + + + + +inline bool QBasicAtomicInt::isFetchAndStoreNative() +{ return true; } +inline bool QBasicAtomicInt::isFetchAndStoreWaitFree() +{ return true; } + + + + +inline bool QBasicAtomicInt::isFetchAndAddNative() +{ return true; } +inline bool QBasicAtomicInt::isFetchAndAddWaitFree() +{ return true; } + + + + +template +inline bool QBasicAtomicPointer::isTestAndSetNative() +{ return true; } +template +inline bool QBasicAtomicPointer::isTestAndSetWaitFree() +{ return true; } + + + + +template +inline bool QBasicAtomicPointer::isFetchAndStoreNative() +{ return true; } +template +inline bool QBasicAtomicPointer::isFetchAndStoreWaitFree() +{ return true; } + + + + +template +inline bool QBasicAtomicPointer::isFetchAndAddNative() +{ return true; } +template +inline bool QBasicAtomicPointer::isFetchAndAddWaitFree() +{ return true; } + + + +inline bool QBasicAtomicInt::ref() +{ + unsigned char ret; + asm volatile("lock\n" + "incl %0\n" + "setne %1" + : "=m" (_q_value), "=qm" (ret) + : "m" (_q_value) + : "memory"); + return ret != 0; +} + +inline bool QBasicAtomicInt::deref() +{ + unsigned char ret; + asm volatile("lock\n" + "decl %0\n" + "setne %1" + : "=m" (_q_value), "=qm" (ret) + : "m" (_q_value) + : "memory"); + return ret != 0; +} + +inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue) +{ + unsigned char ret; + asm volatile("lock\n" + "cmpxchgl %3,%2\n" + "sete %1\n" + : "=a" (newValue), "=qm" (ret), "+m" (_q_value) + : "r" (newValue), "0" (expectedValue) + : "memory"); + return ret != 0; +} + +inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) +{ + asm volatile("xchgl %0,%1" + : "=r" (newValue), "+m" (_q_value) + : "0" (newValue) + : "memory"); + return newValue; +} + +inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) +{ + asm volatile("lock\n" + "xaddl %0,%1" + : "=r" (valueToAdd), "+m" (_q_value) + : "0" (valueToAdd) + : "memory"); + return valueToAdd; +} + +template +inline bool QBasicAtomicPointer::testAndSetOrdered(T *expectedValue, T *newValue) +{ + unsigned char ret; + asm volatile("lock\n" + "cmpxchg %3,%2\n" + "sete %1\n" + : "=a" (newValue), "=qm" (ret), "+m" (_q_value) + : "r" (newValue), "0" (expectedValue) + : "memory"); + return ret != 0; +} + +template +inline T *QBasicAtomicPointer::fetchAndStoreOrdered(T *newValue) +{ + asm volatile("xchg %0,%1" + : "=r" (newValue), "+m" (_q_value) + : "0" (newValue) + : "memory"); + return newValue; +} + +template +inline T *QBasicAtomicPointer::fetchAndAddOrdered(qptrdiff valueToAdd) +{ + asm volatile("lock\n" + "xadd %0,%1" + : "=r" (valueToAdd), "+m" (_q_value) + : "0" (valueToAdd * sizeof(T)) + : "memory"); + return reinterpret_cast(valueToAdd); +} +# 260 "/usr/include/qt4/QtCore/qatomic_x86_64.h" 3 4 +inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +template +inline bool QBasicAtomicPointer::testAndSetRelaxed(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +inline bool QBasicAtomicPointer::testAndSetAcquire(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +inline bool QBasicAtomicPointer::testAndSetRelease(T *expectedValue, T *newValue) +{ + return testAndSetOrdered(expectedValue, newValue); +} + +template +inline T *QBasicAtomicPointer::fetchAndStoreRelaxed(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +inline T *QBasicAtomicPointer::fetchAndStoreAcquire(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +inline T *QBasicAtomicPointer::fetchAndStoreRelease(T *newValue) +{ + return fetchAndStoreOrdered(newValue); +} + +template +inline T *QBasicAtomicPointer::fetchAndAddRelaxed(qptrdiff valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +template +inline T *QBasicAtomicPointer::fetchAndAddAcquire(qptrdiff valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + +template +inline T *QBasicAtomicPointer::fetchAndAddRelease(qptrdiff valueToAdd) +{ + return fetchAndAddOrdered(valueToAdd); +} + + + + +# 89 "/usr/include/qt4/QtCore/qatomic_arch.h" 2 3 4 +# 101 "/usr/include/qt4/QtCore/qatomic_arch.h" 3 4 + +# 228 "/usr/include/qt4/QtCore/qbasicatomic.h" 2 3 4 +# 47 "/usr/include/qt4/QtCore/qatomic.h" 2 3 4 + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + + +class QAtomicInt : public QBasicAtomicInt +{ +public: + inline QAtomicInt(int value = 0) + { + + + + _q_value = value; + } + inline QAtomicInt(const QAtomicInt &other) + { + + + + _q_value = other._q_value; + } + + inline QAtomicInt &operator=(int value) + { + (void) QBasicAtomicInt::operator=(value); + return *this; + } + + inline QAtomicInt &operator=(const QAtomicInt &other) + { + (void) QBasicAtomicInt::operator=(other); + return *this; + } +# 121 "/usr/include/qt4/QtCore/qatomic.h" 3 4 +}; + + +template +class QAtomicPointer : public QBasicAtomicPointer +{ +public: + inline QAtomicPointer(T *value = 0) + { + + + + QBasicAtomicPointer::_q_value = value; + } + inline QAtomicPointer(const QAtomicPointer &other) + { + + + + QBasicAtomicPointer::_q_value = other._q_value; + } + + inline QAtomicPointer &operator=(T *value) + { + (void) QBasicAtomicPointer::operator=(value); + return *this; + } + + inline QAtomicPointer &operator=(const QAtomicPointer &other) + { + (void) QBasicAtomicPointer::operator=(other); + return *this; + } +# 186 "/usr/include/qt4/QtCore/qatomic.h" 3 4 +}; + + + + + + + +template +inline void qAtomicAssign(T *&d, T *x) +{ + if (d == x) + return; + x->ref.ref(); + if (!d->ref.deref()) + delete d; + d = x; +} +# 213 "/usr/include/qt4/QtCore/qatomic.h" 3 4 +template +inline void qAtomicDetach(T *&d) +{ + if (d->ref == 1) + return; + T *x = d; + d = new T(*d); + if (!x->ref.deref()) + delete x; +} + + + +# 46 "/usr/include/qt4/QtCore/qbytearray.h" 2 3 4 + + +# 1 "/usr/include/string.h" 1 3 4 +# 27 "/usr/include/string.h" 3 4 +extern "C" { + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 33 "/usr/include/string.h" 2 3 4 +# 44 "/usr/include/string.h" 3 4 + + +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 94 "/usr/include/string.h" 3 4 +} + + + + + + + + + + +extern "C++" void *rawmemchr (void *__s, int __c) + throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) + throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + + + +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (2))); + +# 166 "/usr/include/string.h" 3 4 +extern int strcoll_l (const char *__s1, const char *__s2, __locale_t __l) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4))); + + + + +extern char *strdup (const char *__s) + throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 210 "/usr/include/string.h" 3 4 + + + +extern "C++" +{ +extern char *strchr (char *__s, int __c) + throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 233 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 260 "/usr/include/string.h" 3 4 +} + + + + + + + + + + +extern "C++" char *strchrnul (char *__s, int __c) + throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + + + +extern size_t strcspn (const char *__s, const char *__reject) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 312 "/usr/include/string.h" 3 4 +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 339 "/usr/include/string.h" 3 4 +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + throw () __attribute__ ((__nonnull__ (2))); + + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + throw () __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + throw () __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 381 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))); + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern size_t strlen (const char *__s) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + +extern char *strerror (int __errnum) throw (); + +# 437 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + throw () __attribute__ ((__nonnull__ (2))) ; + + + + + +extern char *strerror_l (int __errnum, __locale_t __l) throw (); + + + + + +extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern char *index (char *__s, int __c) + throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *index (const char *__s, int __c) + throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 486 "/usr/include/string.h" 3 4 +} + + + + + + + +extern "C++" +{ +extern char *rindex (char *__s, int __c) + throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *rindex (const char *__s, int __c) + throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 514 "/usr/include/string.h" 3 4 +} + + + + + + + +extern int ffs (int __i) throw () __attribute__ ((__const__)); + + + + +extern int ffsl (long int __l) throw () __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + throw () __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, + __locale_t __loc) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, __locale_t __loc) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) throw (); + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + throw () __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int strverscmp (const char *__s1, const char *__s2) + throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" char *basename (char *__filename) + throw () __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + throw () __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 643 "/usr/include/string.h" 3 4 +} +# 49 "/usr/include/qt4/QtCore/qbytearray.h" 2 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stdarg.h" 1 3 4 +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stdarg.h" 3 4 +typedef __gnuc_va_list va_list; +# 50 "/usr/include/qt4/QtCore/qbytearray.h" 2 3 4 +# 67 "/usr/include/qt4/QtCore/qbytearray.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + + + + + + char *qstrdup(const char *); + +inline uint qstrlen(const char *str) +{ return str ? uint(strlen(str)) : 0; } + +inline uint qstrnlen(const char *str, uint maxlen) +{ + uint length = 0; + if (str) { + while (length < maxlen && *str++) + length++; + } + return length; +} + + char *qstrcpy(char *dst, const char *src); + char *qstrncpy(char *dst, const char *src, uint len); + + int qstrcmp(const char *str1, const char *str2); + int qstrcmp(const QByteArray &str1, const QByteArray &str2); + int qstrcmp(const QByteArray &str1, const char *str2); +static inline int qstrcmp(const char *str1, const QByteArray &str2) +{ return -qstrcmp(str2, str1); } + +inline int qstrncmp(const char *str1, const char *str2, uint len) +{ + return (str1 && str2) ? strncmp(str1, str2, len) + : (str1 ? 1 : (str2 ? -1 : 0)); +} + int qstricmp(const char *, const char *); + int qstrnicmp(const char *, const char *, uint len); + + + int qvsnprintf(char *str, size_t n, const char *fmt, va_list ap); + int qsnprintf(char *str, size_t n, const char *fmt, ...); +# 128 "/usr/include/qt4/QtCore/qbytearray.h" 3 4 + quint16 qChecksum(const char *s, uint len); + +class QByteRef; +class QString; +class QDataStream; +template class QList; + +class QByteArray +{ +private: + struct Data { + QBasicAtomicInt ref; + int alloc, size; + + + + char *data; + char array[1]; + }; + +public: + inline QByteArray(); + QByteArray(const char *); + QByteArray(const char *, int size); + QByteArray(int size, char c); + QByteArray(int size, Qt::Initialization); + inline QByteArray(const QByteArray &); + inline ~QByteArray(); + + QByteArray &operator=(const QByteArray &); + QByteArray &operator=(const char *str); + + + + + + inline void swap(QByteArray &other) { qSwap(d, other.d); } + + inline int size() const; + bool isEmpty() const; + void resize(int size); + + QByteArray &fill(char c, int size = -1); + + int capacity() const; + void reserve(int size); + void squeeze(); + + + operator const char *() const; + operator const void *() const; + + char *data(); + const char *data() const; + inline const char *constData() const; + inline void detach(); + bool isDetached() const; + inline bool isSharedWith(const QByteArray &other) const { return d == other.d; } + void clear(); + + + + + + + char at(int i) const; + char operator[](int i) const; + char operator[](uint i) const; + + QByteRef operator[](int i); + QByteRef operator[](uint i); + + int indexOf(char c, int from = 0) const; + int indexOf(const char *c, int from = 0) const; + int indexOf(const QByteArray &a, int from = 0) const; + int lastIndexOf(char c, int from = -1) const; + int lastIndexOf(const char *c, int from = -1) const; + int lastIndexOf(const QByteArray &a, int from = -1) const; + + QBool contains(char c) const; + QBool contains(const char *a) const; + QBool contains(const QByteArray &a) const; + int count(char c) const; + int count(const char *a) const; + int count(const QByteArray &a) const; + + QByteArray left(int len) const; + QByteArray right(int len) const; + QByteArray mid(int index, int len = -1) const; + + bool startsWith(const QByteArray &a) const; + bool startsWith(char c) const; + bool startsWith(const char *c) const; + + bool endsWith(const QByteArray &a) const; + bool endsWith(char c) const; + bool endsWith(const char *c) const; + + void truncate(int pos); + void chop(int n); + + QByteArray toLower() const; + QByteArray toUpper() const; + + QByteArray trimmed() const; + QByteArray simplified() const; + QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const; + QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const; +# 244 "/usr/include/qt4/QtCore/qbytearray.h" 3 4 + QByteArray &prepend(char c); + QByteArray &prepend(const char *s); + QByteArray &prepend(const char *s, int len); + QByteArray &prepend(const QByteArray &a); + QByteArray &append(char c); + QByteArray &append(const char *s); + QByteArray &append(const char *s, int len); + QByteArray &append(const QByteArray &a); + QByteArray &insert(int i, char c); + QByteArray &insert(int i, const char *s); + QByteArray &insert(int i, const char *s, int len); + QByteArray &insert(int i, const QByteArray &a); + QByteArray &remove(int index, int len); + QByteArray &replace(int index, int len, const char *s); + QByteArray &replace(int index, int len, const char *s, int alen); + QByteArray &replace(int index, int len, const QByteArray &s); + QByteArray &replace(char before, const char *after); + QByteArray &replace(char before, const QByteArray &after); + QByteArray &replace(const char *before, const char *after); + QByteArray &replace(const char *before, int bsize, const char *after, int asize); + QByteArray &replace(const QByteArray &before, const QByteArray &after); + QByteArray &replace(const QByteArray &before, const char *after); + QByteArray &replace(const char *before, const QByteArray &after); + QByteArray &replace(char before, char after); + QByteArray &operator+=(char c); + QByteArray &operator+=(const char *s); + QByteArray &operator+=(const QByteArray &a); + + QList split(char sep) const; + + QByteArray repeated(int times) const; + + + QByteArray &append(const QString &s); + QByteArray &insert(int i, const QString &s); + QByteArray &replace(const QString &before, const char *after); + QByteArray &replace(char c, const QString &after); + QByteArray &replace(const QString &before, const QByteArray &after); + + QByteArray &operator+=(const QString &s); + int indexOf(const QString &s, int from = 0) const; + int lastIndexOf(const QString &s, int from = -1) const; + + + inline bool operator==(const QString &s2) const; + inline bool operator!=(const QString &s2) const; + inline bool operator<(const QString &s2) const; + inline bool operator>(const QString &s2) const; + inline bool operator<=(const QString &s2) const; + inline bool operator>=(const QString &s2) const; + + + short toShort(bool *ok = 0, int base = 10) const; + ushort toUShort(bool *ok = 0, int base = 10) const; + int toInt(bool *ok = 0, int base = 10) const; + uint toUInt(bool *ok = 0, int base = 10) const; + long toLong(bool *ok = 0, int base = 10) const; + ulong toULong(bool *ok = 0, int base = 10) const; + qlonglong toLongLong(bool *ok = 0, int base = 10) const; + qulonglong toULongLong(bool *ok = 0, int base = 10) const; + float toFloat(bool *ok = 0) const; + double toDouble(bool *ok = 0) const; + QByteArray toBase64() const; + QByteArray toHex() const; + QByteArray toPercentEncoding(const QByteArray &exclude = QByteArray(), + const QByteArray &include = QByteArray(), + char percent = '%') const; + + QByteArray &setNum(short, int base = 10); + QByteArray &setNum(ushort, int base = 10); + QByteArray &setNum(int, int base = 10); + QByteArray &setNum(uint, int base = 10); + QByteArray &setNum(qlonglong, int base = 10); + QByteArray &setNum(qulonglong, int base = 10); + QByteArray &setNum(float, char f = 'g', int prec = 6); + QByteArray &setNum(double, char f = 'g', int prec = 6); + QByteArray &setRawData(const char *a, uint n); + + static QByteArray number(int, int base = 10); + static QByteArray number(uint, int base = 10); + static QByteArray number(qlonglong, int base = 10); + static QByteArray number(qulonglong, int base = 10); + static QByteArray number(double, char f = 'g', int prec = 6); + static QByteArray fromRawData(const char *, int size); + static QByteArray fromBase64(const QByteArray &base64); + static QByteArray fromHex(const QByteArray &hexEncoded); + static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%'); + + + typedef char *iterator; + typedef const char *const_iterator; + typedef iterator Iterator; + typedef const_iterator ConstIterator; + iterator begin(); + const_iterator begin() const; + const_iterator constBegin() const; + iterator end(); + const_iterator end() const; + const_iterator constEnd() const; + + + typedef const char & const_reference; + typedef char & reference; + typedef char value_type; + void push_back(char c); + void push_back(const char *c); + void push_back(const QByteArray &a); + void push_front(char c); + void push_front(const char *c); + void push_front(const QByteArray &a); + + inline int count() const { return d->size; } + int length() const { return d->size; } + bool isNull() const; +# 382 "/usr/include/qt4/QtCore/qbytearray.h" 3 4 +private: + operator QNoImplicitBoolCast() const; + static Data shared_null; + static Data shared_empty; + Data *d; + QByteArray(Data *dd, int , int ) : d(dd) {} + void realloc(int alloc); + void expand(int i); + QByteArray nulTerminated() const; + + friend class QByteRef; + friend class QString; + friend QByteArray qUncompress(const uchar *data, int nbytes); +public: + typedef Data * DataPtr; + inline DataPtr &data_ptr() { return d; } +}; + +inline QByteArray::QByteArray(): d(&shared_null) { d->ref.ref(); } +inline QByteArray::~QByteArray() { if (!d->ref.deref()) qFree(d); } +inline int QByteArray::size() const +{ return d->size; } +# 413 "/usr/include/qt4/QtCore/qbytearray.h" 3 4 +inline char QByteArray::at(int i) const +{ qt_noop(); return d->data[i]; } +inline char QByteArray::operator[](int i) const +{ qt_noop(); return d->data[i]; } +inline char QByteArray::operator[](uint i) const +{ qt_noop(); return d->data[i]; } + + +inline bool QByteArray::isEmpty() const +{ return d->size == 0; } + +inline QByteArray::operator const char *() const +{ return d->data; } +inline QByteArray::operator const void *() const +{ return d->data; } + +inline char *QByteArray::data() +{ detach(); return d->data; } +inline const char *QByteArray::data() const +{ return d->data; } +inline const char *QByteArray::constData() const +{ return d->data; } +inline void QByteArray::detach() +{ if (d->ref != 1 || d->data != d->array) realloc(d->size); } +inline bool QByteArray::isDetached() const +{ return d->ref == 1; } +inline QByteArray::QByteArray(const QByteArray &a) : d(a.d) +{ d->ref.ref(); } + + + + + +inline int QByteArray::capacity() const +{ return d->alloc; } + +inline void QByteArray::reserve(int asize) +{ if (d->ref != 1 || asize > d->alloc) realloc(asize); } + +inline void QByteArray::squeeze() +{ if (d->size < d->alloc) realloc(d->size); } + +class QByteRef { + QByteArray &a; + int i; + inline QByteRef(QByteArray &array, int idx) + : a(array),i(idx) {} + friend class QByteArray; +public: + + + + + inline operator char() const + { return i < a.d->size ? a.d->data[i] : char(0); } + + inline QByteRef &operator=(char c) + { if (i >= a.d->size) a.expand(i); else a.detach(); + a.d->data[i] = c; return *this; } + inline QByteRef &operator=(const QByteRef &c) + { if (i >= a.d->size) a.expand(i); else a.detach(); + a.d->data[i] = c.a.d->data[c.i]; return *this; } + inline bool operator==(char c) const + { return a.d->data[i] == c; } + inline bool operator!=(char c) const + { return a.d->data[i] != c; } + inline bool operator>(char c) const + { return a.d->data[i] > c; } + inline bool operator>=(char c) const + { return a.d->data[i] >= c; } + inline bool operator<(char c) const + { return a.d->data[i] < c; } + inline bool operator<=(char c) const + { return a.d->data[i] <= c; } +}; + +inline QByteRef QByteArray::operator[](int i) +{ qt_noop(); return QByteRef(*this, i); } +inline QByteRef QByteArray::operator[](uint i) +{ return QByteRef(*this, i); } +inline QByteArray::iterator QByteArray::begin() +{ detach(); return d->data; } +inline QByteArray::const_iterator QByteArray::begin() const +{ return d->data; } +inline QByteArray::const_iterator QByteArray::constBegin() const +{ return d->data; } +inline QByteArray::iterator QByteArray::end() +{ detach(); return d->data + d->size; } +inline QByteArray::const_iterator QByteArray::end() const +{ return d->data + d->size; } +inline QByteArray::const_iterator QByteArray::constEnd() const +{ return d->data + d->size; } +inline QByteArray &QByteArray::operator+=(char c) +{ return append(c); } +inline QByteArray &QByteArray::operator+=(const char *s) +{ return append(s); } +inline QByteArray &QByteArray::operator+=(const QByteArray &a) +{ return append(a); } +inline void QByteArray::push_back(char c) +{ append(c); } +inline void QByteArray::push_back(const char *c) +{ append(c); } +inline void QByteArray::push_back(const QByteArray &a) +{ append(a); } +inline void QByteArray::push_front(char c) +{ prepend(c); } +inline void QByteArray::push_front(const char *c) +{ prepend(c); } +inline void QByteArray::push_front(const QByteArray &a) +{ prepend(a); } +inline QBool QByteArray::contains(const QByteArray &a) const +{ return QBool(indexOf(a) != -1); } +inline QBool QByteArray::contains(char c) const +{ return QBool(indexOf(c) != -1); } +inline bool operator==(const QByteArray &a1, const QByteArray &a2) +{ return (a1.size() == a2.size()) && (memcmp(a1.constData(), a2.constData(), a1.size())==0); } +inline bool operator==(const QByteArray &a1, const char *a2) +{ return a2 ? qstrcmp(a1,a2) == 0 : a1.isEmpty(); } +inline bool operator==(const char *a1, const QByteArray &a2) +{ return a1 ? qstrcmp(a1,a2) == 0 : a2.isEmpty(); } +inline bool operator!=(const QByteArray &a1, const QByteArray &a2) +{ return !(a1==a2); } +inline bool operator!=(const QByteArray &a1, const char *a2) +{ return a2 ? qstrcmp(a1,a2) != 0 : !a1.isEmpty(); } +inline bool operator!=(const char *a1, const QByteArray &a2) +{ return a1 ? qstrcmp(a1,a2) != 0 : !a2.isEmpty(); } +inline bool operator<(const QByteArray &a1, const QByteArray &a2) +{ return qstrcmp(a1, a2) < 0; } + inline bool operator<(const QByteArray &a1, const char *a2) +{ return qstrcmp(a1, a2) < 0; } +inline bool operator<(const char *a1, const QByteArray &a2) +{ return qstrcmp(a1, a2) < 0; } +inline bool operator<=(const QByteArray &a1, const QByteArray &a2) +{ return qstrcmp(a1, a2) <= 0; } +inline bool operator<=(const QByteArray &a1, const char *a2) +{ return qstrcmp(a1, a2) <= 0; } +inline bool operator<=(const char *a1, const QByteArray &a2) +{ return qstrcmp(a1, a2) <= 0; } +inline bool operator>(const QByteArray &a1, const QByteArray &a2) +{ return qstrcmp(a1, a2) > 0; } +inline bool operator>(const QByteArray &a1, const char *a2) +{ return qstrcmp(a1, a2) > 0; } +inline bool operator>(const char *a1, const QByteArray &a2) +{ return qstrcmp(a1, a2) > 0; } +inline bool operator>=(const QByteArray &a1, const QByteArray &a2) +{ return qstrcmp(a1, a2) >= 0; } +inline bool operator>=(const QByteArray &a1, const char *a2) +{ return qstrcmp(a1, a2) >= 0; } +inline bool operator>=(const char *a1, const QByteArray &a2) +{ return qstrcmp(a1, a2) >= 0; } + +inline const QByteArray operator+(const QByteArray &a1, const QByteArray &a2) +{ return QByteArray(a1) += a2; } +inline const QByteArray operator+(const QByteArray &a1, const char *a2) +{ return QByteArray(a1) += a2; } +inline const QByteArray operator+(const QByteArray &a1, char a2) +{ return QByteArray(a1) += a2; } +inline const QByteArray operator+(const char *a1, const QByteArray &a2) +{ return QByteArray(a1) += a2; } +inline const QByteArray operator+(char a1, const QByteArray &a2) +{ return QByteArray(&a1, 1) += a2; } + +inline QBool QByteArray::contains(const char *c) const +{ return QBool(indexOf(c) != -1); } +inline QByteArray &QByteArray::replace(char before, const char *c) +{ return replace(&before, 1, c, qstrlen(c)); } +inline QByteArray &QByteArray::replace(const QByteArray &before, const char *c) +{ return replace(before.constData(), before.size(), c, qstrlen(c)); } +inline QByteArray &QByteArray::replace(const char *before, const char *after) +{ return replace(before, qstrlen(before), after, qstrlen(after)); } + +inline QByteArray &QByteArray::setNum(short n, int base) +{ return setNum(qlonglong(n), base); } +inline QByteArray &QByteArray::setNum(ushort n, int base) +{ return setNum(qulonglong(n), base); } +inline QByteArray &QByteArray::setNum(int n, int base) +{ return setNum(qlonglong(n), base); } +inline QByteArray &QByteArray::setNum(uint n, int base) +{ return setNum(qulonglong(n), base); } +inline QByteArray &QByteArray::setNum(float n, char f, int prec) +{ return setNum(double(n),f,prec); } + + + + QDataStream &operator<<(QDataStream &, const QByteArray &); + QDataStream &operator>>(QDataStream &, QByteArray &); + + + + QByteArray qCompress(const uchar* data, int nbytes, int compressionLevel = -1); + QByteArray qUncompress(const uchar* data, int nbytes); +inline QByteArray qCompress(const QByteArray& data, int compressionLevel = -1) +{ return qCompress(reinterpret_cast(data.constData()), data.size(), compressionLevel); } +inline QByteArray qUncompress(const QByteArray& data) +{ return qUncompress(reinterpret_cast(data.constData()), data.size()); } + + +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QByteArray)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QByteArray"; } }; +template <> inline bool qIsDetached(QByteArray &t) { return t.isDetached(); } template <> inline void qSwap(QByteArray &value1, QByteArray &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QByteArray>(::QByteArray &value1, ::QByteArray &value2) { swap(value1.data_ptr(), value2.data_ptr()); } } + + + + +# 47 "/usr/include/qt4/QtCore/qstring.h" 2 3 4 + + + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 1 3 4 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 3 4 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stringfwd.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stringfwd.h" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stringfwd.h" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + + template + struct char_traits; + + template<> struct char_traits; + + + template<> struct char_traits; +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stringfwd.h" 3 +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_string; + + + typedef basic_string string; + + + + typedef basic_string wstring; +# 90 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stringfwd.h" 3 +} + + + + +} +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/char_traits.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/char_traits.h" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/char_traits.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/postypes.h" 1 3 +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/postypes.h" 3 + +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/postypes.h" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/include/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-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 357 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/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 (); + +extern wchar_t *wcsncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + throw (); + + +extern wchar_t *wcscat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) throw (); + +extern wchar_t *wcsncat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + throw (); + + +extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) + throw () __attribute__ ((__pure__)); + +extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + throw () __attribute__ ((__pure__)); + + + + +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 (); + + + + + +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__)); +# 306 "/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 (); + +# 405 "/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 (); +# 530 "/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 () ; +# 680 "/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 () ; +# 736 "/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); + +# 801 "/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); +# 827 "/usr/include/wchar.h" 3 4 +extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); +extern wint_t putwchar_unlocked (wchar_t __wc); +# 837 "/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 (); +# 891 "/usr/include/wchar.h" 3 4 +} +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 2 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 3 +namespace std +{ + using ::mbstate_t; +} +# 135 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 3 + +} + + + + + + + +namespace __gnu_cxx +{ + + + + + + using ::wcstold; +# 257 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 3 + using ::wcstoll; + using ::wcstoull; + +} + +namespace std +{ + using ::__gnu_cxx::wcstold; + using ::__gnu_cxx::wcstoll; + using ::__gnu_cxx::wcstoull; +} +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/postypes.h" 2 3 +# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/postypes.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 88 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/postypes.h" 3 + typedef long streamoff; +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/postypes.h" 3 + typedef ptrdiff_t streamsize; +# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/postypes.h" 3 + template + class fpos + { + private: + streamoff _M_off; + _StateT _M_state; + + public: + + + + + fpos() + : _M_off(0), _M_state() { } +# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 streampos; + + typedef fpos wstreampos; +# 239 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/postypes.h" 3 + +} +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/char_traits.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 3 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwchar" 2 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/char_traits.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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(__c); } + + static int_type + to_int_type(const char_type& __c) + { return static_cast(__c); } + + static bool + eq_int_type(const int_type& __c1, const int_type& __c2) + { return __c1 == __c2; } + + static int_type + eof() + { return static_cast(-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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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) + { 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) + { return static_cast(__builtin_memchr(__s, __a, __n)); } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { return static_cast(__builtin_memmove(__s1, __s2, __n)); } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { return static_cast(__builtin_memcpy(__s1, __s2, __n)); } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { return static_cast(__builtin_memset(__s, __a, __n)); } + + static char_type + to_char_type(const int_type& __c) + { return static_cast(__c); } + + + + static int_type + to_int_type(const char_type& __c) + { return static_cast(static_cast(__c)); } + + static bool + eq_int_type(const int_type& __c1, const int_type& __c2) + { return __c1 == __c2; } + + static int_type + eof() + { return static_cast(-1); } + + static int_type + not_eof(const int_type& __c) + { return (__c == eof()) ? 0 : __c; } + }; + + + + + template<> + struct char_traits + { + 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) + { 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) + { return wmemchr(__s, __a, __n); } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { return wmemmove(__s1, __s2, __n); } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { return wmemcpy(__s1, __s2, __n); } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { 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((0xffffffffu)); } + + static int_type + not_eof(const int_type& __c) + { return eq_int_type(__c, eof()) ? 0 : __c; } + }; + + + +} +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/localefwd.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/localefwd.h" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/localefwd.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++locale.h" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/c++locale.h" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/clocale" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/clocale" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/clocale" 3 + + +# 1 "/usr/include/locale.h" 1 3 4 +# 28 "/usr/include/locale.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 29 "/usr/include/locale.h" 2 3 4 +# 1 "/usr/include/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/clocale" 2 3 +# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/clocale" 3 +namespace std +{ + using ::lconv; + using ::setlocale; + using ::localeconv; +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/localefwd.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iosfwd" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iosfwd" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iosfwd" 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iosfwd" 3 + class ios_base; + + template > + class basic_ios; + + template > + class basic_streambuf; + + template > + class basic_istream; + + template > + class basic_ostream; + + template > + class basic_iostream; + + +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringbuf; + + template, + typename _Alloc = allocator<_CharT> > + class basic_istringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_ostringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringstream; + +} + + template > + class basic_filebuf; + + template > + class basic_ifstream; + + template > + class basic_ofstream; + + template > + class basic_fstream; + + template > + class istreambuf_iterator; + + template > + 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 wios; + + + typedef basic_streambuf wstreambuf; + + + typedef basic_istream wistream; + + + typedef basic_ostream wostream; + + + typedef basic_iostream wiostream; + + + typedef basic_stringbuf wstringbuf; + + + typedef basic_istringstream wistringstream; + + + typedef basic_ostringstream wostringstream; + + + typedef basic_stringstream wstringstream; + + + typedef basic_filebuf wfilebuf; + + + typedef basic_ifstream wifstream; + + + typedef basic_ofstream wofstream; + + + typedef basic_fstream wfstream; + + + + +} +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/localefwd.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cctype" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cctype" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cctype" 3 + + +# 1 "/usr/include/ctype.h" 1 3 4 +# 28 "/usr/include/ctype.h" 3 4 +extern "C" { +# 46 "/usr/include/ctype.h" 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cctype" 2 3 +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/localefwd.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; + + template + class ctype_byname; + + + class codecvt_base; + template + class codecvt; + template<> class codecvt; + + template<> class codecvt; + + template + class codecvt_byname; + + + + template > + class num_get; + template > + 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 > + class time_get; + template > + class time_get_byname; +} + template > + class time_put; + template > + class time_put_byname; + + + class money_base; +namespace __cxx11 { + template > + class money_get; + template > + class money_put; +} +namespace __cxx11 { + template + class moneypunct; + template + class moneypunct_byname; +} + + + class messages_base; +namespace __cxx11 { + template + class messages; + template + class messages_byname; +} + + +} +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ostream_insert.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ostream_insert.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ostream_insert.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/cxxabi_forced.h" 1 3 +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/cxxabi_forced.h" 3 + +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ostream_insert.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + 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 + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 2 3 + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_function.h" 1 3 +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_function.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_function.h" 3 + template + struct unary_function + { + + typedef _Arg argument_type; + + + typedef _Result result_type; + }; + + + + + template + struct binary_function + { + + typedef _Arg1 first_argument_type; + + + typedef _Arg2 second_argument_type; + + + typedef _Result result_type; + }; +# 166 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_function.h" 3 + template + class unary_negate + : public unary_function + { + 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 + { + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_function.h" 3 + template + 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 + inline pointer_to_unary_function<_Arg, _Result> + ptr_fun(_Result (*__x)(_Arg)) + { return pointer_to_unary_function<_Arg, _Result>(__x); } + + + template + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_function.h" 3 + template + 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 + class const_mem_fun_t : public unary_function + { + 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 + 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 + 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 + 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 + class const_mem_fun1_t : public binary_function + { + 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 + 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 + 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 + inline mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)()) + { return mem_fun_t<_Ret, _Tp>(__f); } + + template + inline const_mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)() const) + { return const_mem_fun_t<_Ret, _Tp>(__f); } + + template + inline mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)()) + { return mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + 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 + inline mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + 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 + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/backward/binders.h" 1 3 +# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/backward/binders.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 107 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/backward/binders.h" 3 + template + class binder1st + : public unary_function + { + 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 + 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 + { + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_function.h" 2 3 +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/range_access.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/range_access.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/range_access.h" 3 +# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/atomicity.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/atomicity.h" 3 + +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/atomicity.h" 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/gthr.h" 1 3 +# 30 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/gthr.h" 3 +#pragma GCC visibility push(default) +# 148 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/gthr.h" 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 29 "/usr/include/sched.h" 2 3 4 + + + + + +# 1 "/usr/include/time.h" 1 3 4 +# 35 "/usr/include/sched.h" 2 3 4 +# 43 "/usr/include/sched.h" 3 4 +# 1 "/usr/include/bits/sched.h" 1 3 4 +# 72 "/usr/include/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/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/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-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 38 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 88 "/usr/include/bits/time.h" 3 4 +# 1 "/usr/include/bits/timex.h" 1 3 4 +# 25 "/usr/include/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/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 +# 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/bits/setjmp.h" 1 3 4 +# 26 "/usr/include/bits/setjmp.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 27 "/usr/include/bits/setjmp.h" 2 3 4 + + + + +typedef long int __jmp_buf[8]; +# 28 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/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 +}; +# 116 "/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 +}; +# 157 "/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 + +}; +# 192 "/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 + +}; +# 230 "/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))); +# 496 "/usr/include/pthread.h" 3 4 +extern int pthread_once (pthread_once_t *__once_control, + void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); +# 508 "/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__)); +# 542 "/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); } +}; +# 744 "/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))); +# 808 "/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))); +# 890 "/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))); +# 1002 "/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))); +# 1046 "/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))); +# 1113 "/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))); +# 1147 "/usr/include/pthread.h" 3 4 +extern int pthread_atfork (void (*__prepare) (void), + void (*__parent) (void), + void (*__child) (void)) throw (); +# 1161 "/usr/include/pthread.h" 3 4 +} +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3 +# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create"))); +# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/gthr.h" 2 3 + + +#pragma GCC visibility pop +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ext/atomicity.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3 +# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/atomic_word.h" 3 +typedef int _Atomic_word; +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +namespace __cxx11 { +# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + 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 iterator; + typedef __gnu_cxx::__normal_iterator + const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + + + static const size_type npos = static_cast(-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 + 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 + void + _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type) + { _M_construct_aux_2(static_cast(__beg), __end); } + + void + _M_construct_aux_2(size_type __req, _CharT __c) + { _M_construct(__req, __c); } + + template + void + _M_construct(_InIterator __beg, _InIterator __end) + { + typedef typename std::__is_integer<_InIterator>::__type _Integral; + _M_construct_aux(__beg, __end, _Integral()); + } + + + template + void + _M_construct(_InIterator __beg, _InIterator __end, + std::input_iterator_tag); + + + + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()(__s, _M_data()) + || less()(_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 + 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()); } +# 411 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 427 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 445 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); } +# 533 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + + 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); } +# 569 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + basic_string& + operator=(_CharT __c) + { + this->assign(1, __c); + return *this; + } +# 611 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 711 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; } +# 740 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + void + resize(size_type __n, _CharT __c); +# 753 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + void + resize(size_type __n) + { this->resize(__n, _CharT()); } +# 776 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + capacity() const + { + return _M_is_local() ? size_type(_S_local_capacity) + : _M_allocated_capacity; + } +# 800 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; } +# 829 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + const_reference + operator[] (size_type __pos) const + { + ; + return _M_data()[__pos]; + } +# 846 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + reference + operator[](size_type __pos) + { + + + ; + + ; + return _M_data()[__pos]; + } +# 867 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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]; + } +# 888 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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]; + } +# 939 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; + } +# 980 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + basic_string& + append(const basic_string& __str) + { return _M_append(__str._M_data(), __str.size()); } +# 997 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); + } +# 1039 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + basic_string& + append(size_type __n, _CharT __c) + { return _M_replace_aux(this->size(), size_type(0), __n, __c); } +# 1066 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + + 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; + } +# 1129 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); } +# 1145 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + basic_string& + assign(const _CharT* __s, size_type __n) + { + ; + return _M_replace(size_type(0), this->size(), __s, __n); + } +# 1161 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + basic_string& + assign(const _CharT* __s) + { + ; + return _M_replace(size_type(0), this->size(), __s, + traits_type::length(__s)); + } +# 1178 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + basic_string& + assign(size_type __n, _CharT __c) + { return _M_replace_aux(size_type(0), this->size(), __n, __c); } +# 1194 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + + basic_string& + assign(_InputIterator __first, _InputIterator __last) + { return this->replace(begin(), end(), __first, __last); } +# 1249 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + void + insert(iterator __p, size_type __n, _CharT __c) + { this->replace(__p, __p, __n, __c); } +# 1292 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + void + insert(iterator __p, _InputIterator __beg, _InputIterator __end) + { this->replace(__p, __p, __beg, __end); } +# 1325 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 1348 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); } +# 1371 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); } +# 1390 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 1414 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); } +# 1432 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); + } +# 1456 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; + } +# 1472 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); + } +# 1491 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); + } +# 1529 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 1551 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); } +# 1576 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); + } +# 1601 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 1625 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); } +# 1643 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 1663 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); + } +# 1685 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 1706 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); + } +# 1744 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + + + + 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); + } +# 1827 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + private: + template + 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 + 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: +# 1865 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + copy(_CharT* __s, size_type __n, size_type __pos = 0) const; +# 1875 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + void + swap(basic_string& __s) ; +# 1885 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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(); } +# 1918 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find(const _CharT* __s, size_type __pos, size_type __n) const; +# 1931 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 1946 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 1963 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find(_CharT __c, size_type __pos = 0) const ; +# 1976 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 1993 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + rfind(const _CharT* __s, size_type __pos, size_type __n) const; +# 2006 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 2023 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + rfind(_CharT __c, size_type __pos = npos) const ; +# 2037 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 2054 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; +# 2067 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 2086 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find_first_of(_CharT __c, size_type __pos = 0) const + { return this->find(__c, __pos); } +# 2101 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 2118 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; +# 2131 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 2150 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find_last_of(_CharT __c, size_type __pos = npos) const + { return this->rfind(__c, __pos); } +# 2164 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 2181 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find_first_not_of(const _CharT* __s, size_type __pos, + size_type __n) const; +# 2195 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 2212 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find_first_not_of(_CharT __c, size_type __pos = 0) const + ; +# 2227 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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()); } +# 2244 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find_last_not_of(const _CharT* __s, size_type __pos, + size_type __n) const; +# 2258 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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)); + } +# 2275 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + size_type + find_last_not_of(_CharT __c, size_type __pos = npos) const + ; +# 2291 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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); } +# 2310 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; + } +# 2342 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + int + compare(size_type __pos, size_type __n, const basic_string& __str) const; +# 2368 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + int + compare(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2) const; +# 2386 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + int + compare(const _CharT* __s) const; +# 2410 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + int + compare(size_type __pos, size_type __n1, const _CharT* __s) const; +# 2437 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + int + compare(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) const; + }; +} +# 4779 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + 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 + basic_string<_CharT,_Traits,_Alloc> + operator+(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Alloc>& __rhs); + + + + + + + + template + basic_string<_CharT,_Traits,_Alloc> + operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); + + + + + + + + template + 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 + 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; + } +# 4900 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + 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 + inline bool + operator==(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) == 0; } + + + + + + + + template + inline bool + operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) == 0; } +# 4946 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + inline bool + operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return !(__lhs == __rhs); } + + + + + + + + template + inline bool + operator!=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return !(__lhs == __rhs); } + + + + + + + + template + inline bool + operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return !(__lhs == __rhs); } +# 4983 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + inline bool + operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __lhs.compare(__rhs) < 0; } + + + + + + + + template + inline bool + operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) < 0; } + + + + + + + + template + inline bool + operator<(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) > 0; } +# 5020 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + inline bool + operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __lhs.compare(__rhs) > 0; } + + + + + + + + template + inline bool + operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) > 0; } + + + + + + + + template + inline bool + operator>(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) < 0; } +# 5057 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + inline bool + operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __lhs.compare(__rhs) <= 0; } + + + + + + + + template + inline bool + operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) <= 0; } + + + + + + + + template + inline bool + operator<=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) >= 0; } +# 5094 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + inline bool + operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __lhs.compare(__rhs) >= 0; } + + + + + + + + template + inline bool + operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) >= 0; } + + + + + + + + template + inline bool + operator>=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) <= 0; } +# 5131 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + inline void + swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, + basic_string<_CharT, _Traits, _Alloc>& __rhs) + { __lhs.swap(__rhs); } +# 5150 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + 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); +# 5168 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + 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()); + } +# 5191 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); +# 5208 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template + 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')); } +# 5230 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.h" 3 + template<> + basic_istream& + getline(basic_istream& __in, basic_string& __str, + char __delim); + + + template<> + basic_istream& + getline(basic_istream& __in, basic_string& __str, + wchar_t __delim); + + + +} +# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.tcc" 1 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.tcc" 3 + +# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + const typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>::npos; + + template + void + basic_string<_CharT, _Traits, _Alloc>:: + swap(basic_string& __s) + { + if (this == &__s) + return; + + + + + std::__alloc_swap::_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 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 + 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 + 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(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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_string.tcc" 3 + template + 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 + 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; + } + + template + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find(const _CharT* __s, size_type __pos, size_type __n) const + { + ; + const size_type __size = this->size(); + const _CharT* __data = _M_data(); + + 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 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 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 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 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 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 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 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 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 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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; + extern template + basic_istream& + operator>>(basic_istream&, wstring&); + extern template + basic_ostream& + operator<<(basic_ostream&, const wstring&); + extern template + basic_istream& + getline(basic_istream&, wstring&, wchar_t); + extern template + basic_istream& + getline(basic_istream&, wstring&); + + + + +} +# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/string" 2 3 +# 55 "/usr/include/qt4/QtCore/qstring.h" 2 3 4 + + + +typedef std::basic_string QStdWString; +# 69 "/usr/include/qt4/QtCore/qstring.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QCharRef; +class QRegExp; +class QStringList; +class QTextCodec; +class QLatin1String; +class QStringRef; +template class QVector; + +class QString +{ +public: + inline QString(); + QString(const QChar *unicode, int size); + explicit QString(const QChar *unicode); + QString(QChar c); + QString(int size, QChar c); + inline QString(const QLatin1String &latin1); + inline QString(const QString &); + inline ~QString(); + QString &operator=(QChar c); + QString &operator=(const QString &); + inline QString &operator=(const QLatin1String &); + + + + + inline void swap(QString &other) { qSwap(d, other.d); } + inline int size() const { return d->size; } + inline int count() const { return d->size; } + inline int length() const; + inline bool isEmpty() const; + void resize(int size); + + QString &fill(QChar c, int size = -1); + void truncate(int pos); + void chop(int n); + + int capacity() const; + inline void reserve(int size); + inline void squeeze() { if (d->size < d->alloc || d->ref != 1) realloc(); d->capacity = 0;} + + inline const QChar *unicode() const; + inline QChar *data(); + inline const QChar *data() const; + inline const QChar *constData() const; + + inline void detach(); + inline bool isDetached() const; + inline bool isSharedWith(const QString &other) const { return d == other.d; } + void clear(); + + inline const QChar at(int i) const; + const QChar operator[](int i) const; + QCharRef operator[](int i); + const QChar operator[](uint i) const; + QCharRef operator[](uint i); + + QString arg(qlonglong a, int fieldwidth=0, int base=10, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(qulonglong a, int fieldwidth=0, int base=10, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(long a, int fieldwidth=0, int base=10, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(ulong a, int fieldwidth=0, int base=10, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(int a, int fieldWidth = 0, int base = 10, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(uint a, int fieldWidth = 0, int base = 10, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(short a, int fieldWidth = 0, int base = 10, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(ushort a, int fieldWidth = 0, int base = 10, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(char a, int fieldWidth = 0, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(QChar a, int fieldWidth = 0, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(const QString &a, int fieldWidth = 0, + const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); + QString arg(const QString &a1, const QString &a2) const __attribute__ ((warn_unused_result)); + QString arg(const QString &a1, const QString &a2, const QString &a3) const __attribute__ ((warn_unused_result)); + QString arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4) const __attribute__ ((warn_unused_result)); + QString arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5) const __attribute__ ((warn_unused_result)); + QString arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5, const QString &a6) const __attribute__ ((warn_unused_result)); + QString arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5, const QString &a6, + const QString &a7) const __attribute__ ((warn_unused_result)); + QString arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5, const QString &a6, + const QString &a7, const QString &a8) const __attribute__ ((warn_unused_result)); + QString arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5, const QString &a6, + const QString &a7, const QString &a8, const QString &a9) const __attribute__ ((warn_unused_result)); + + QString &vsprintf(const char *format, va_list ap) + + __attribute__ ((format (printf, 2, 0))) + + ; + QString &sprintf(const char *format, ...) + + __attribute__ ((format (printf, 2, 3))) + + ; + + int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int indexOf(const QLatin1String &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int indexOf(const QStringRef &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int lastIndexOf(const QLatin1String &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int lastIndexOf(const QStringRef &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + + inline QBool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + inline QBool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + inline QBool contains(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + + + int indexOf(const QRegExp &, int from = 0) const; + int lastIndexOf(const QRegExp &, int from = -1) const; + inline QBool contains(const QRegExp &rx) const { return QBool(indexOf(rx) != -1); } + int count(const QRegExp &) const; + + int indexOf(QRegExp &, int from = 0) const; + int lastIndexOf(QRegExp &, int from = -1) const; + inline QBool contains(QRegExp &rx) const { return QBool(indexOf(rx) != -1); } + + + enum SectionFlag { + SectionDefault = 0x00, + SectionSkipEmpty = 0x01, + SectionIncludeLeadingSep = 0x02, + SectionIncludeTrailingSep = 0x04, + SectionCaseInsensitiveSeps = 0x08 + }; + typedef QFlags SectionFlags; + + QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const; + QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const; + + QString section(const QRegExp ®, int start, int end = -1, SectionFlags flags = SectionDefault) const; + + + QString left(int n) const __attribute__ ((warn_unused_result)); + QString right(int n) const __attribute__ ((warn_unused_result)); + QString mid(int position, int n = -1) const __attribute__ ((warn_unused_result)); + QStringRef leftRef(int n) const __attribute__ ((warn_unused_result)); + QStringRef rightRef(int n) const __attribute__ ((warn_unused_result)); + QStringRef midRef(int position, int n = -1) const __attribute__ ((warn_unused_result)); + + bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool startsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool endsWith(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + + QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const __attribute__ ((warn_unused_result)); + QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const __attribute__ ((warn_unused_result)); + + QString toLower() const __attribute__ ((warn_unused_result)); + QString toUpper() const __attribute__ ((warn_unused_result)); + QString toCaseFolded() const __attribute__ ((warn_unused_result)); + + QString trimmed() const __attribute__ ((warn_unused_result)); + QString simplified() const __attribute__ ((warn_unused_result)); + + QString &insert(int i, QChar c); + QString &insert(int i, const QChar *uc, int len); + inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); } + QString &insert(int i, const QLatin1String &s); + QString &append(QChar c); + QString &append(const QString &s); + QString &append(const QStringRef &s); + QString &append(const QLatin1String &s); + inline QString &prepend(QChar c) { return insert(0, c); } + inline QString &prepend(const QString &s) { return insert(0, s); } + inline QString &prepend(const QLatin1String &s) { return insert(0, s); } + + inline QString &operator+=(QChar c) { + if (d->ref != 1 || d->size + 1 > d->alloc) + realloc(grow(d->size + 1)); + d->data[d->size++] = c.unicode(); + d->data[d->size] = '\0'; + return *this; + } + + inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); } + inline QString &operator+=(const QString &s) { return append(s); } + inline QString &operator+=(const QStringRef &s) { return append(s); } + inline QString &operator+=(const QLatin1String &s) { return append(s); } + + QString &remove(int i, int len); + QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive); + QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive); + QString &replace(int i, int len, QChar after); + QString &replace(int i, int len, const QChar *s, int slen); + QString &replace(int i, int len, const QString &after); + QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive); + QString &replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive); + QString &replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); + QString &replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); + QString &replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); + QString &replace(const QString &before, const QString &after, + Qt::CaseSensitivity cs = Qt::CaseSensitive); + QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); + QString &replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); + + QString &replace(const QRegExp &rx, const QString &after); + inline QString &remove(const QRegExp &rx) + { return replace(rx, QString()); } + + + enum SplitBehavior { KeepEmptyParts, SkipEmptyParts }; + + QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts, + Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((warn_unused_result)); + QStringList split(const QChar &sep, SplitBehavior behavior = KeepEmptyParts, + Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((warn_unused_result)); + + QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const __attribute__ ((warn_unused_result)); + + + enum NormalizationForm { + NormalizationForm_D, + NormalizationForm_C, + NormalizationForm_KD, + NormalizationForm_KC + }; + QString normalized(NormalizationForm mode) const __attribute__ ((warn_unused_result)); + QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const __attribute__ ((warn_unused_result)); + + QString repeated(int times) const; + + const ushort *utf16() const; + + QByteArray toAscii() const __attribute__ ((warn_unused_result)); + QByteArray toLatin1() const __attribute__ ((warn_unused_result)); + QByteArray toUtf8() const __attribute__ ((warn_unused_result)); + QByteArray toLocal8Bit() const __attribute__ ((warn_unused_result)); + QVector toUcs4() const __attribute__ ((warn_unused_result)); + + static QString fromAscii(const char *, int size = -1); + static QString fromLatin1(const char *, int size = -1); + static QString fromUtf8(const char *, int size = -1); + static QString fromLocal8Bit(const char *, int size = -1); + static QString fromUtf16(const ushort *, int size = -1); + static QString fromUcs4(const uint *, int size = -1); + static QString fromRawData(const QChar *, int size); + + int toWCharArray(wchar_t *array) const; + static QString fromWCharArray(const wchar_t *, int size = -1); + + QString &setRawData(const QChar *unicode, int size); + QString &setUnicode(const QChar *unicode, int size); + inline QString &setUtf16(const ushort *utf16, int size); + + + int compare(const QString &s) const; + int compare(const QString &s, Qt::CaseSensitivity cs) const; + + int compare(const QLatin1String &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + + + static inline int compare(const QString &s1, const QString &s2) + { return s1.compare(s2); } + static inline int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs) + { return s1.compare(s2, cs); } + + static inline int compare(const QString& s1, const QLatin1String &s2, + Qt::CaseSensitivity cs = Qt::CaseSensitive) + { return s1.compare(s2, cs); } + static inline int compare(const QLatin1String& s1, const QString &s2, + Qt::CaseSensitivity cs = Qt::CaseSensitive) + { return -s2.compare(s1, cs); } + + int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + static int compare(const QString &s1, const QStringRef &s2, + Qt::CaseSensitivity = Qt::CaseSensitive); + + int localeAwareCompare(const QString& s) const; + static int localeAwareCompare(const QString& s1, const QString& s2) + { return s1.localeAwareCompare(s2); } + + int localeAwareCompare(const QStringRef &s) const; + static int localeAwareCompare(const QString& s1, const QStringRef& s2); + + short toShort(bool *ok=0, int base=10) const; + ushort toUShort(bool *ok=0, int base=10) const; + int toInt(bool *ok=0, int base=10) const; + uint toUInt(bool *ok=0, int base=10) const; + long toLong(bool *ok=0, int base=10) const; + ulong toULong(bool *ok=0, int base=10) const; + qlonglong toLongLong(bool *ok=0, int base=10) const; + qulonglong toULongLong(bool *ok=0, int base=10) const; + float toFloat(bool *ok=0) const; + double toDouble(bool *ok=0) const; + + QString &setNum(short, int base=10); + QString &setNum(ushort, int base=10); + QString &setNum(int, int base=10); + QString &setNum(uint, int base=10); + QString &setNum(long, int base=10); + QString &setNum(ulong, int base=10); + QString &setNum(qlonglong, int base=10); + QString &setNum(qulonglong, int base=10); + QString &setNum(float, char f='g', int prec=6); + QString &setNum(double, char f='g', int prec=6); + + static QString number(int, int base=10); + static QString number(uint, int base=10); + static QString number(long, int base=10); + static QString number(ulong, int base=10); + static QString number(qlonglong, int base=10); + static QString number(qulonglong, int base=10); + static QString number(double, char f='g', int prec=6); + + bool operator==(const QString &s) const; + bool operator<(const QString &s) const; + inline bool operator>(const QString &s) const { return s < *this; } + inline bool operator!=(const QString &s) const { return !operator==(s); } + inline bool operator<=(const QString &s) const { return !operator>(s); } + inline bool operator>=(const QString &s) const { return !operator<(s); } + + bool operator==(const QLatin1String &s) const; + bool operator<(const QLatin1String &s) const; + bool operator>(const QLatin1String &s) const; + inline bool operator!=(const QLatin1String &s) const { return !operator==(s); } + inline bool operator<=(const QLatin1String &s) const { return !operator>(s); } + inline bool operator>=(const QLatin1String &s) const { return !operator<(s); } + + + + inline QString(const char *ch) : d(fromAscii_helper(ch)) + {} + inline QString(const QByteArray &a) + : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size()))) + {} + inline QString &operator=(const char *ch) + { return (*this = fromAscii(ch)); } + inline QString &operator=(const QByteArray &a) + { return (*this = fromAscii(a.constData(), qstrnlen(a.constData(), a.size()))); } + inline QString &operator=(char c) + { return (*this = QChar::fromAscii(c)); } + + + inline QString &prepend(const char *s) + { return prepend(QString::fromAscii(s)); } + inline QString &prepend(const QByteArray &s) + { return prepend(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); } + inline QString &append(const char *s) + { return append(QString::fromAscii(s)); } + inline QString &append(const QByteArray &s) + { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); } + inline QString &operator+=(const char *s) + { return append(QString::fromAscii(s)); } + inline QString &operator+=(const QByteArray &s) + { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); } + inline QString &operator+=(char c) + { return append(QChar::fromAscii(c)); } + + inline bool operator==(const char *s) const; + inline bool operator!=(const char *s) const; + inline bool operator<(const char *s) const; + inline bool operator<=(const char *s2) const; + inline bool operator>(const char *s2) const; + inline bool operator>=(const char *s2) const; + + inline bool operator==(const QByteArray &s) const; + inline bool operator!=(const QByteArray &s) const; + inline bool operator<(const QByteArray &s) const + { return *this < QString::fromAscii(s.constData(), s.size()); } + inline bool operator>(const QByteArray &s) const + { return *this > QString::fromAscii(s.constData(), s.size()); } + inline bool operator<=(const QByteArray &s) const + { return *this <= QString::fromAscii(s.constData(), s.size()); } + inline bool operator>=(const QByteArray &s) const + { return *this >= QString::fromAscii(s.constData(), s.size()); } + + + typedef QChar *iterator; + typedef const QChar *const_iterator; + typedef iterator Iterator; + typedef const_iterator ConstIterator; + iterator begin(); + const_iterator begin() const; + const_iterator constBegin() const; + iterator end(); + const_iterator end() const; + const_iterator constEnd() const; + + + typedef const QChar & const_reference; + typedef QChar & reference; + typedef QChar value_type; + inline void push_back(QChar c) { append(c); } + inline void push_back(const QString &s) { append(s); } + inline void push_front(QChar c) { prepend(c); } + inline void push_front(const QString &s) { prepend(s); } + + + static inline QString fromStdString(const std::string &s); + inline std::string toStdString() const; + + + + + + static inline QString fromStdWString(const QStdWString &s); + inline QStdWString toStdWString() const; + + + + + + struct Null { }; + static const Null null; + inline QString(const Null &): d(&shared_null) { d->ref.ref(); } + inline QString &operator=(const Null &) { *this = QString(); return *this; } + inline bool isNull() const { return d == &shared_null; } +# 588 "/usr/include/qt4/QtCore/qstring.h" 3 4 + bool isSimpleText() const { if (!d->clean) updateProperties(); return d->simpletext; } + bool isRightToLeft() const; + + QString(int size, Qt::Initialization); + +private: +# 603 "/usr/include/qt4/QtCore/qstring.h" 3 4 + struct Data { + QBasicAtomicInt ref; + int alloc, size; + ushort *data; + ushort clean : 1; + ushort simpletext : 1; + ushort righttoleft : 1; + ushort asciiCache : 1; + ushort capacity : 1; + ushort reserved : 11; + + ushort array[1]; + }; + static Data shared_null; + static Data shared_empty; + Data *d; + QString(Data *dd, int ) : d(dd) {} + + static QTextCodec *codecForCStrings; + + static int grow(int); + static void free(Data *); + void realloc(); + void realloc(int alloc); + void expand(int i); + void updateProperties() const; + QString multiArg(int numArgs, const QString **args) const; + static int compare_helper(const QChar *data1, int length1, + const QChar *data2, int length2, + Qt::CaseSensitivity cs = Qt::CaseSensitive); + static int compare_helper(const QChar *data1, int length1, + QLatin1String s2, + Qt::CaseSensitivity cs = Qt::CaseSensitive); + static int localeAwareCompare_helper(const QChar *data1, int length1, + const QChar *data2, int length2); + static Data *fromLatin1_helper(const char *str, int size = -1); + static Data *fromAscii_helper(const char *str, int size = -1); + void replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen); + friend class QCharRef; + friend class QCFString; + friend class QTextCodec; + friend class QStringRef; + friend struct QAbstractConcatenable; + friend inline bool qStringComparisonHelper(const QString &s1, const char *s2); + friend inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2); +public: + typedef Data * DataPtr; + inline DataPtr &data_ptr() { return d; } +}; + + +class QLatin1String +{ +public: + inline explicit QLatin1String(const char *s) : chars(s) {} + inline QLatin1String &operator=(const QLatin1String &other) + { chars = other.chars; return *this; } + + inline const char *latin1() const { return chars; } + + inline bool operator==(const QString &s) const + { return s == *this; } + inline bool operator!=(const QString &s) const + { return s != *this; } + inline bool operator>(const QString &s) const + { return s < *this; } + inline bool operator<(const QString &s) const + { return s > *this; } + inline bool operator>=(const QString &s) const + { return s <= *this; } + inline bool operator<=(const QString &s) const + { return s >= *this; } + + inline bool operator==(const char *s) const + { return QString::fromAscii(s) == *this; } + inline bool operator!=(const char *s) const + { return QString::fromAscii(s) != *this; } + inline bool operator<(const char *s) const + { return QString::fromAscii(s) > *this; } + inline bool operator>(const char *s) const + { return QString::fromAscii(s) < *this; } + inline bool operator<=(const char *s) const + { return QString::fromAscii(s) >= *this; } + inline bool operator>=(const char *s) const + { return QString::fromAscii(s) <= *this; } +private: + const char *chars; +}; + + + +inline QString::QString(const QLatin1String &aLatin1) : d(fromLatin1_helper(aLatin1.latin1())) +{ } +inline int QString::length() const +{ return d->size; } +inline const QChar QString::at(int i) const +{ qt_noop(); return d->data[i]; } +inline const QChar QString::operator[](int i) const +{ qt_noop(); return d->data[i]; } +inline const QChar QString::operator[](uint i) const +{ qt_noop(); return d->data[i]; } +inline bool QString::isEmpty() const +{ return d->size == 0; } +inline const QChar *QString::unicode() const +{ return reinterpret_cast(d->data); } +inline const QChar *QString::data() const +{ return reinterpret_cast(d->data); } +inline QChar *QString::data() +{ detach(); return reinterpret_cast(d->data); } +inline const QChar *QString::constData() const +{ return reinterpret_cast(d->data); } +inline void QString::detach() +{ if (d->ref != 1 || d->data != d->array) realloc(); } +inline bool QString::isDetached() const +{ return d->ref == 1; } +inline QString &QString::operator=(const QLatin1String &s) +{ + *this = fromLatin1(s.latin1()); + return *this; +} +inline void QString::clear() +{ if (!isNull()) *this = QString(); } +inline QString::QString(const QString &other) : d(other.d) +{ qt_noop(); d->ref.ref(); } +inline int QString::capacity() const +{ return d->alloc; } +inline QString &QString::setNum(short n, int base) +{ return setNum(qlonglong(n), base); } +inline QString &QString::setNum(ushort n, int base) +{ return setNum(qulonglong(n), base); } +inline QString &QString::setNum(int n, int base) +{ return setNum(qlonglong(n), base); } +inline QString &QString::setNum(uint n, int base) +{ return setNum(qulonglong(n), base); } +inline QString &QString::setNum(long n, int base) +{ return setNum(qlonglong(n), base); } +inline QString &QString::setNum(ulong n, int base) +{ return setNum(qulonglong(n), base); } +inline QString &QString::setNum(float n, char f, int prec) +{ return setNum(double(n),f,prec); } +inline QString QString::arg(int a, int fieldWidth, int base, const QChar &fillChar) const +{ return arg(qlonglong(a), fieldWidth, base, fillChar); } +inline QString QString::arg(uint a, int fieldWidth, int base, const QChar &fillChar) const +{ return arg(qulonglong(a), fieldWidth, base, fillChar); } +inline QString QString::arg(long a, int fieldWidth, int base, const QChar &fillChar) const +{ return arg(qlonglong(a), fieldWidth, base, fillChar); } +inline QString QString::arg(ulong a, int fieldWidth, int base, const QChar &fillChar) const +{ return arg(qulonglong(a), fieldWidth, base, fillChar); } +inline QString QString::arg(short a, int fieldWidth, int base, const QChar &fillChar) const +{ return arg(qlonglong(a), fieldWidth, base, fillChar); } +inline QString QString::arg(ushort a, int fieldWidth, int base, const QChar &fillChar) const +{ return arg(qulonglong(a), fieldWidth, base, fillChar); } +inline QString QString::arg(const QString &a1, const QString &a2) const +{ const QString *args[2] = { &a1, &a2 }; return multiArg(2, args); } +inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3) const +{ const QString *args[3] = { &a1, &a2, &a3 }; return multiArg(3, args); } +inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4) const +{ const QString *args[4] = { &a1, &a2, &a3, &a4 }; return multiArg(4, args); } +inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5) const +{ const QString *args[5] = { &a1, &a2, &a3, &a4, &a5 }; return multiArg(5, args); } +inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5, const QString &a6) const +{ const QString *args[6] = { &a1, &a2, &a3, &a4, &a5, &a6 }; return multiArg(6, args); } +inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5, const QString &a6, + const QString &a7) const +{ const QString *args[7] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7 }; return multiArg(7, args); } +inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5, const QString &a6, + const QString &a7, const QString &a8) const +{ const QString *args[8] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8 }; return multiArg(8, args); } +inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, + const QString &a4, const QString &a5, const QString &a6, + const QString &a7, const QString &a8, const QString &a9) const +{ const QString *args[9] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9 }; return multiArg(9, args); } + +inline QString QString::section(QChar asep, int astart, int aend, SectionFlags aflags) const +{ return section(QString(asep), astart, aend, aflags); } + + +class QCharRef { + QString &s; + int i; + inline QCharRef(QString &str, int idx) + : s(str),i(idx) {} + friend class QString; +public: + + + + + inline operator QChar() const + { return i < s.d->size ? s.d->data[i] : 0; } + inline QCharRef &operator=(const QChar &c) + { if (i >= s.d->size) s.expand(i); else s.detach(); + s.d->data[i] = c.unicode(); return *this; } + + + + inline QCharRef &operator=(char c) + { return operator=(QChar::fromAscii(c)); } + inline QCharRef &operator=(uchar c) + { return operator=(QChar::fromAscii(c)); } + + inline QCharRef &operator=(const QCharRef &c) { return operator=(QChar(c)); } + inline QCharRef &operator=(ushort rc) { return operator=(QChar(rc)); } + inline QCharRef &operator=(short rc) { return operator=(QChar(rc)); } + inline QCharRef &operator=(uint rc) { return operator=(QChar(rc)); } + inline QCharRef &operator=(int rc) { return operator=(QChar(rc)); } + + + inline bool isNull() const { return QChar(*this).isNull(); } + inline bool isPrint() const { return QChar(*this).isPrint(); } + inline bool isPunct() const { return QChar(*this).isPunct(); } + inline bool isSpace() const { return QChar(*this).isSpace(); } + inline bool isMark() const { return QChar(*this).isMark(); } + inline bool isLetter() const { return QChar(*this).isLetter(); } + inline bool isNumber() const { return QChar(*this).isNumber(); } + inline bool isLetterOrNumber() { return QChar(*this).isLetterOrNumber(); } + inline bool isDigit() const { return QChar(*this).isDigit(); } + inline bool isLower() const { return QChar(*this).isLower(); } + inline bool isUpper() const { return QChar(*this).isUpper(); } + inline bool isTitleCase() const { return QChar(*this).isTitleCase(); } + + inline int digitValue() const { return QChar(*this).digitValue(); } + QChar toLower() const { return QChar(*this).toLower(); } + QChar toUpper() const { return QChar(*this).toUpper(); } + QChar toTitleCase () const { return QChar(*this).toTitleCase(); } + + QChar::Category category() const { return QChar(*this).category(); } + QChar::Direction direction() const { return QChar(*this).direction(); } + QChar::Joining joining() const { return QChar(*this).joining(); } + bool hasMirrored() const { return QChar(*this).hasMirrored(); } + QChar mirroredChar() const { return QChar(*this).mirroredChar(); } + QString decomposition() const { return QChar(*this).decomposition(); } + QChar::Decomposition decompositionTag() const { return QChar(*this).decompositionTag(); } + uchar combiningClass() const { return QChar(*this).combiningClass(); } + + QChar::UnicodeVersion unicodeVersion() const { return QChar(*this).unicodeVersion(); } + + inline uchar cell() const { return QChar(*this).cell(); } + inline uchar row() const { return QChar(*this).row(); } + inline void setCell(uchar cell); + inline void setRow(uchar row); + + + + + + + char toAscii() const { return QChar(*this).toAscii(); } + char toLatin1() const { return QChar(*this).toLatin1(); } + ushort unicode() const { return QChar(*this).unicode(); } + + ushort& unicode() { return s.data()[i].unicode(); } +# 873 "/usr/include/qt4/QtCore/qstring.h" 3 4 +}; + +inline void QCharRef::setRow(uchar arow) { QChar(*this).setRow(arow); } +inline void QCharRef::setCell(uchar acell) { QChar(*this).setCell(acell); } + + +inline QString::QString() : d(&shared_null) { d->ref.ref(); } +inline QString::~QString() { if (!d->ref.deref()) free(d); } +inline void QString::reserve(int asize) { if (d->ref != 1 || asize > d->alloc) realloc(asize); d->capacity = 1;} +inline QString &QString::setUtf16(const ushort *autf16, int asize) +{ return setUnicode(reinterpret_cast(autf16), asize); } +inline QCharRef QString::operator[](int i) +{ qt_noop(); return QCharRef(*this, i); } +inline QCharRef QString::operator[](uint i) +{ return QCharRef(*this, i); } +inline QString::iterator QString::begin() +{ detach(); return reinterpret_cast(d->data); } +inline QString::const_iterator QString::begin() const +{ return reinterpret_cast(d->data); } +inline QString::const_iterator QString::constBegin() const +{ return reinterpret_cast(d->data); } +inline QString::iterator QString::end() +{ detach(); return reinterpret_cast(d->data + d->size); } +inline QString::const_iterator QString::end() const +{ return reinterpret_cast(d->data + d->size); } +inline QString::const_iterator QString::constEnd() const +{ return reinterpret_cast(d->data + d->size); } +inline QBool QString::contains(const QString &s, Qt::CaseSensitivity cs) const +{ return QBool(indexOf(s, 0, cs) != -1); } +inline QBool QString::contains(const QStringRef &s, Qt::CaseSensitivity cs) const +{ return QBool(indexOf(s, 0, cs) != -1); } +inline QBool QString::contains(QChar c, Qt::CaseSensitivity cs) const +{ return QBool(indexOf(c, 0, cs) != -1); } + + +inline bool operator==(QString::Null, QString::Null) { return true; } +inline bool operator==(QString::Null, const QString &s) { return s.isNull(); } +inline bool operator==(const QString &s, QString::Null) { return s.isNull(); } +inline bool operator!=(QString::Null, QString::Null) { return false; } +inline bool operator!=(QString::Null, const QString &s) { return !s.isNull(); } +inline bool operator!=(const QString &s, QString::Null) { return !s.isNull(); } + + +inline bool qStringComparisonHelper(const QString &s1, const char *s2) +{ + + if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2)); + + return (s1 == QLatin1String(s2)); +} +inline bool QString::operator==(const char *s) const +{ return qStringComparisonHelper(*this, s); } +inline bool QString::operator!=(const char *s) const +{ return !qStringComparisonHelper(*this, s); } +inline bool QString::operator<(const char *s) const +{ return *this < QString::fromAscii(s); } +inline bool QString::operator>(const char *s) const +{ return *this > QString::fromAscii(s); } +inline bool QString::operator<=(const char *s) const +{ return *this <= QString::fromAscii(s); } +inline bool QString::operator>=(const char *s) const +{ return *this >= QString::fromAscii(s); } + +inline bool operator==(const char *s1, const QString &s2) +{ return qStringComparisonHelper(s2, s1); } +inline bool operator!=(const char *s1, const QString &s2) +{ return !qStringComparisonHelper(s2, s1); } +inline bool operator<(const char *s1, const QString &s2) +{ return (QString::fromAscii(s1) < s2); } +inline bool operator>(const char *s1, const QString &s2) +{ return (QString::fromAscii(s1) > s2); } +inline bool operator<=(const char *s1, const QString &s2) +{ return (QString::fromAscii(s1) <= s2); } +inline bool operator>=(const char *s1, const QString &s2) +{ return (QString::fromAscii(s1) >= s2); } + +inline bool operator==(const char *s1, const QLatin1String &s2) +{ return QString::fromAscii(s1) == s2; } +inline bool operator!=(const char *s1, const QLatin1String &s2) +{ return QString::fromAscii(s1) != s2; } +inline bool operator<(const char *s1, const QLatin1String &s2) +{ return (QString::fromAscii(s1) < s2); } +inline bool operator>(const char *s1, const QLatin1String &s2) +{ return (QString::fromAscii(s1) > s2); } +inline bool operator<=(const char *s1, const QLatin1String &s2) +{ return (QString::fromAscii(s1) <= s2); } +inline bool operator>=(const char *s1, const QLatin1String &s2) +{ return (QString::fromAscii(s1) >= s2); } + +inline bool operator==(const QLatin1String &s1, const QLatin1String &s2) +{ return (qstrcmp(s1.latin1(), s2.latin1()) == 0); } +inline bool operator!=(const QLatin1String &s1, const QLatin1String &s2) +{ return (qstrcmp(s1.latin1(), s2.latin1()) != 0); } +inline bool operator<(const QLatin1String &s1, const QLatin1String &s2) +{ return (qstrcmp(s1.latin1(), s2.latin1()) < 0); } +inline bool operator<=(const QLatin1String &s1, const QLatin1String &s2) +{ return (qstrcmp(s1.latin1(), s2.latin1()) <= 0); } +inline bool operator>(const QLatin1String &s1, const QLatin1String &s2) +{ return (qstrcmp(s1.latin1(), s2.latin1()) > 0); } +inline bool operator>=(const QLatin1String &s1, const QLatin1String &s2) +{ return (qstrcmp(s1.latin1(), s2.latin1()) >= 0); } + + +inline bool QString::operator==(const QByteArray &s) const +{ return qStringComparisonHelper(*this, s.constData()); } +inline bool QString::operator!=(const QByteArray &s) const +{ return !qStringComparisonHelper(*this, s.constData()); } + +inline bool QByteArray::operator==(const QString &s) const +{ return qStringComparisonHelper(s, constData()); } +inline bool QByteArray::operator!=(const QString &s) const +{ return !qStringComparisonHelper(s, constData()); } +inline bool QByteArray::operator<(const QString &s) const +{ return QString::fromAscii(constData(), size()) < s; } +inline bool QByteArray::operator>(const QString &s) const +{ return QString::fromAscii(constData(), size()) > s; } +inline bool QByteArray::operator<=(const QString &s) const +{ return QString::fromAscii(constData(), size()) <= s; } +inline bool QByteArray::operator>=(const QString &s) const +{ return QString::fromAscii(constData(), size()) >= s; } + + + +inline QByteArray &QByteArray::append(const QString &s) +{ return append(s.toAscii()); } +inline QByteArray &QByteArray::insert(int i, const QString &s) +{ return insert(i, s.toAscii()); } +inline QByteArray &QByteArray::replace(char c, const QString &after) +{ return replace(c, after.toAscii()); } +inline QByteArray &QByteArray::replace(const QString &before, const char *after) +{ return replace(before.toAscii(), after); } +inline QByteArray &QByteArray::replace(const QString &before, const QByteArray &after) +{ return replace(before.toAscii(), after); } +inline QByteArray &QByteArray::operator+=(const QString &s) +{ return operator+=(s.toAscii()); } +inline int QByteArray::indexOf(const QString &s, int from) const +{ return indexOf(s.toAscii(), from); } +inline int QByteArray::lastIndexOf(const QString &s, int from) const +{ return lastIndexOf(s.toAscii(), from); } +# 1021 "/usr/include/qt4/QtCore/qstring.h" 3 4 +inline const QString operator+(const QString &s1, const QString &s2) +{ QString t(s1); t += s2; return t; } +inline const QString operator+(const QString &s1, QChar s2) +{ QString t(s1); t += s2; return t; } +inline const QString operator+(QChar s1, const QString &s2) +{ QString t(s1); t += s2; return t; } + +inline const QString operator+(const QString &s1, const char *s2) +{ QString t(s1); t += QString::fromAscii(s2); return t; } +inline const QString operator+(const char *s1, const QString &s2) +{ QString t = QString::fromAscii(s1); t += s2; return t; } +inline const QString operator+(char c, const QString &s) +{ QString t = s; t.prepend(QChar::fromAscii(c)); return t; } +inline const QString operator+(const QString &s, char c) +{ QString t = s; t += QChar::fromAscii(c); return t; } +inline const QString operator+(const QByteArray &ba, const QString &s) +{ QString t = QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); t += s; return t; } +inline const QString operator+(const QString &s, const QByteArray &ba) +{ QString t(s); t += QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); return t; } + + + + +inline std::string QString::toStdString() const +{ const QByteArray asc = toAscii(); return std::string(asc.constData(), asc.length()); } + +inline QString QString::fromStdString(const std::string &s) +{ return fromAscii(s.data(), int(s.size())); } + + +inline QStdWString QString::toStdWString() const +{ + QStdWString str; + str.resize(length()); + + + + + + + + str.resize(toWCharArray(&(*str.begin()))); + return str; +} +inline QString QString::fromStdWString(const QStdWString &s) +{ return fromWCharArray(s.data(), int(s.size())); } +# 1080 "/usr/include/qt4/QtCore/qstring.h" 3 4 + QDataStream &operator<<(QDataStream &, const QString &); + QDataStream &operator>>(QDataStream &, QString &); +# 1094 "/usr/include/qt4/QtCore/qstring.h" 3 4 +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QString)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QString"; } }; +template <> inline bool qIsDetached(QString &t) { return t.isDetached(); } template <> inline void qSwap(QString &value1, QString &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QString>(::QString &value1, ::QString &value2) { swap(value1.data_ptr(), value2.data_ptr()); } } + inline QFlags operator|(QString::SectionFlags::enum_type f1, QString::SectionFlags::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(QString::SectionFlags::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QString::SectionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + + +class QStringRef { + const QString *m_string; + int m_position; + int m_size; +public: + inline QStringRef():m_string(0), m_position(0), m_size(0){} + inline QStringRef(const QString *string, int position, int size); + inline QStringRef(const QString *string); + inline QStringRef(const QStringRef &other) + :m_string(other.m_string), m_position(other.m_position), m_size(other.m_size) + {} + + inline ~QStringRef(){} + inline const QString *string() const { return m_string; } + inline int position() const { return m_position; } + inline int size() const { return m_size; } + inline int count() const { return m_size; } + inline int length() const { return m_size; } + + inline QStringRef &operator=(const QStringRef &other) { + m_string = other.m_string; m_position = other.m_position; + m_size = other.m_size; return *this; + } + + int indexOf(const QString &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int indexOf(QChar ch, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int indexOf(QLatin1String str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int indexOf(const QStringRef &str, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int lastIndexOf(const QString &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int lastIndexOf(QChar ch, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int lastIndexOf(QLatin1String str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int lastIndexOf(const QStringRef &str, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + + inline QBool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + inline QBool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + inline QBool contains(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + inline QBool contains(const QStringRef &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + + int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int count(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + + bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool startsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool startsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool startsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + + bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool endsWith(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool endsWith(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + bool endsWith(const QStringRef &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + + inline QStringRef &operator=(const QString *string); + + inline const QChar *unicode() const { + if (!m_string) + return reinterpret_cast(QString::shared_null.data); + return m_string->unicode() + m_position; + } + inline const QChar *data() const { return unicode(); } + inline const QChar *constData() const { return unicode(); } + + QByteArray toAscii() const __attribute__ ((warn_unused_result)); + QByteArray toLatin1() const __attribute__ ((warn_unused_result)); + QByteArray toUtf8() const __attribute__ ((warn_unused_result)); + QByteArray toLocal8Bit() const __attribute__ ((warn_unused_result)); + QVector toUcs4() const __attribute__ ((warn_unused_result)); + + inline void clear() { m_string = 0; m_position = m_size = 0; } + QString toString() const; + inline bool isEmpty() const { return m_size == 0; } + inline bool isNull() const { return m_string == 0 || m_string->isNull(); } + + QStringRef appendTo(QString *string) const; + + inline const QChar at(int i) const + { qt_noop(); return m_string->at(i + m_position); } + + int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + int compare(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; + static int compare(const QStringRef &s1, const QString &s2, + Qt::CaseSensitivity = Qt::CaseSensitive); + static int compare(const QStringRef &s1, const QStringRef &s2, + Qt::CaseSensitivity = Qt::CaseSensitive); + static int compare(const QStringRef &s1, QLatin1String s2, + Qt::CaseSensitivity cs = Qt::CaseSensitive); + + int localeAwareCompare(const QString &s) const; + int localeAwareCompare(const QStringRef &s) const; + static int localeAwareCompare(const QStringRef &s1, const QString &s2); + static int localeAwareCompare(const QStringRef &s1, const QStringRef &s2); +}; + +inline QStringRef &QStringRef::operator=(const QString *aString) +{ m_string = aString; m_position = 0; m_size = aString?aString->size():0; return *this; } + +inline QStringRef::QStringRef(const QString *aString, int aPosition, int aSize) + :m_string(aString), m_position(aPosition), m_size(aSize){} + +inline QStringRef::QStringRef(const QString *aString) + :m_string(aString), m_position(0), m_size(aString?aString->size() : 0){} + + bool operator==(const QStringRef &s1,const QStringRef &s2); +inline bool operator!=(const QStringRef &s1,const QStringRef &s2) +{ return !(s1 == s2); } + bool operator==(const QString &s1,const QStringRef &s2); +inline bool operator!=(const QString &s1,const QStringRef &s2) +{ return !(s1 == s2); } +inline bool operator==(const QStringRef &s1,const QString &s2) +{ return s2 == s1; } +inline bool operator!=(const QStringRef &s1,const QString &s2) +{ return s2 != s1; } + bool operator==(const QLatin1String &s1, const QStringRef &s2); +inline bool operator!=(const QLatin1String &s1,const QStringRef &s2) +{ return !(s1 == s2); } +inline bool operator==(const QStringRef &s1,const QLatin1String &s2) +{ return s2 == s1; } +inline bool operator!=(const QStringRef &s1,const QLatin1String &s2) +{ return s2 != s1; } + + bool operator<(const QStringRef &s1,const QStringRef &s2); +inline bool operator>(const QStringRef &s1, const QStringRef &s2) +{ return s2 < s1; } +inline bool operator<=(const QStringRef &s1, const QStringRef &s2) +{ return !(s1 > s2); } +inline bool operator>=(const QStringRef &s1, const QStringRef &s2) +{ return !(s1 < s2); } + +inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2) +{ + + if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2)); + + return (s1 == QLatin1String(s2)); +} + +inline bool operator==(const char *s1, const QStringRef &s2) +{ return qStringComparisonHelper(s2, s1); } +inline bool operator==(const QStringRef &s1, const char *s2) +{ return qStringComparisonHelper(s1, s2); } +inline bool operator!=(const char *s1, const QStringRef &s2) +{ return !qStringComparisonHelper(s2, s1); } +inline bool operator!=(const QStringRef &s1, const char *s2) +{ return !qStringComparisonHelper(s1, s2); } + +inline int QString::compare(const QStringRef &s, Qt::CaseSensitivity cs) const +{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); } +inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs) +{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); } +inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const +{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); } +inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const +{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); } +inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const +{ return QString::compare_helper(constData(), length(), s, cs); } +inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs) +{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); } +inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs) +{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); } +inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs) +{ return QString::compare_helper(s1.constData(), s1.length(), s2, cs); } + +inline int QString::localeAwareCompare(const QStringRef &s) const +{ return localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); } +inline int QString::localeAwareCompare(const QString& s1, const QStringRef& s2) +{ return localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); } +inline int QStringRef::localeAwareCompare(const QString &s) const +{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); } +inline int QStringRef::localeAwareCompare(const QStringRef &s) const +{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); } +inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QString &s2) +{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); } +inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QStringRef &s2) +{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); } + +inline QBool QStringRef::contains(const QString &s, Qt::CaseSensitivity cs) const +{ return QBool(indexOf(s, 0, cs) != -1); } +inline QBool QStringRef::contains(QLatin1String s, Qt::CaseSensitivity cs) const +{ return QBool(indexOf(s, 0, cs) != -1); } +inline QBool QStringRef::contains(QChar c, Qt::CaseSensitivity cs) const +{ return QBool(indexOf(c, 0, cs) != -1); } +inline QBool QStringRef::contains(const QStringRef &s, Qt::CaseSensitivity cs) const +{ return QBool(indexOf(s, 0, cs) != -1); } + + + + + + +# 49 "/usr/include/qt4/QtCore/qobject.h" 2 3 4 + +# 1 "/usr/include/qt4/QtCore/qlist.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qlist.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qiterator.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qiterator.h" 3 4 + +# 79 "/usr/include/qt4/QtCore/qiterator.h" 3 4 + + +typedef QtValidLicenseForCoreModule QtCoreModule; +# 223 "/usr/include/qt4/QtCore/qiterator.h" 3 4 + + + +# 46 "/usr/include/qt4/QtCore/qlist.h" 2 3 4 + +# 1 "/usr/include/qt4/QtCore/qalgorithms.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qalgorithms.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + + + + + +namespace QAlgorithmsPrivate { + +template + void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan); +template +inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy); + +template + void qStableSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan); +template +inline void qStableSortHelper(RandomAccessIterator, RandomAccessIterator, const T &); + +template + RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan); +template + RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan); +template + RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan); + +} + +template +inline OutputIterator qCopy(InputIterator begin, InputIterator end, OutputIterator dest) +{ + while (begin != end) + *dest++ = *begin++; + return dest; +} + +template +inline BiIterator2 qCopyBackward(BiIterator1 begin, BiIterator1 end, BiIterator2 dest) +{ + while (begin != end) + *--dest = *--end; + return dest; +} + +template +inline bool qEqual(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2) +{ + for (; first1 != last1; ++first1, ++first2) + if (!(*first1 == *first2)) + return false; + return true; +} + +template +inline void qFill(ForwardIterator first, ForwardIterator last, const T &val) +{ + for (; first != last; ++first) + *first = val; +} + +template +inline void qFill(Container &container, const T &val) +{ + qFill(container.begin(), container.end(), val); +} + +template +inline InputIterator qFind(InputIterator first, InputIterator last, const T &val) +{ + while (first != last && !(*first == val)) + ++first; + return first; +} + +template +inline typename Container::const_iterator qFind(const Container &container, const T &val) +{ + return qFind(container.constBegin(), container.constEnd(), val); +} + +template +inline void qCount(InputIterator first, InputIterator last, const T &value, Size &n) +{ + for (; first != last; ++first) + if (*first == value) + ++n; +} + +template +inline void qCount(const Container &container, const T &value, Size &n) +{ + qCount(container.constBegin(), container.constEnd(), value, n); +} +# 155 "/usr/include/qt4/QtCore/qalgorithms.h" 3 4 +template +class qLess +{ +public: + inline bool operator()(const T &t1, const T &t2) const + { + return (t1 < t2); + } +}; + +template +class qGreater +{ +public: + inline bool operator()(const T &t1, const T &t2) const + { + return (t2 < t1); + } +}; + + +template +inline void qSort(RandomAccessIterator start, RandomAccessIterator end) +{ + if (start != end) + QAlgorithmsPrivate::qSortHelper(start, end, *start); +} + +template +inline void qSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan) +{ + if (start != end) + QAlgorithmsPrivate::qSortHelper(start, end, *start, lessThan); +} + +template +inline void qSort(Container &c) +{ + + + + + if (!c.empty()) + QAlgorithmsPrivate::qSortHelper(c.begin(), c.end(), *c.begin()); +} + +template +inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end) +{ + if (start != end) + QAlgorithmsPrivate::qStableSortHelper(start, end, *start); +} + +template +inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan) +{ + if (start != end) + QAlgorithmsPrivate::qStableSortHelper(start, end, *start, lessThan); +} + +template +inline void qStableSort(Container &c) +{ + + + + + if (!c.empty()) + QAlgorithmsPrivate::qStableSortHelper(c.begin(), c.end(), *c.begin()); +} + +template + RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value) +{ + + + + RandomAccessIterator middle; + int n = end - begin; + int half; + + while (n > 0) { + half = n >> 1; + middle = begin + half; + if (*middle < value) { + begin = middle + 1; + n -= half + 1; + } else { + n = half; + } + } + return begin; +} + +template + RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) +{ + return QAlgorithmsPrivate::qLowerBoundHelper(begin, end, value, lessThan); +} + +template + typename Container::const_iterator qLowerBound(const Container &container, const T &value) +{ + return QAlgorithmsPrivate::qLowerBoundHelper(container.constBegin(), container.constEnd(), value, qLess()); +} + +template + RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value) +{ + + RandomAccessIterator middle; + int n = end - begin; + int half; + + while (n > 0) { + half = n >> 1; + middle = begin + half; + if (value < *middle) { + n = half; + } else { + begin = middle + 1; + n -= half + 1; + } + } + return begin; +} + +template + RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) +{ + return QAlgorithmsPrivate::qUpperBoundHelper(begin, end, value, lessThan); +} + +template + typename Container::const_iterator qUpperBound(const Container &container, const T &value) +{ + return QAlgorithmsPrivate::qUpperBoundHelper(container.constBegin(), container.constEnd(), value, qLess()); +} + +template + RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value) +{ + + RandomAccessIterator it = qLowerBound(begin, end, value); + + if (it == end || value < *it) + return end; + + return it; +} + +template + RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) +{ + return QAlgorithmsPrivate::qBinaryFindHelper(begin, end, value, lessThan); +} + +template + typename Container::const_iterator qBinaryFind(const Container &container, const T &value) +{ + return QAlgorithmsPrivate::qBinaryFindHelper(container.constBegin(), container.constEnd(), value, qLess()); +} + +template + void qDeleteAll(ForwardIterator begin, ForwardIterator end) +{ + while (begin != end) { + delete *begin; + ++begin; + } +} + +template +inline void qDeleteAll(const Container &c) +{ + qDeleteAll(c.begin(), c.end()); +} + + + + + +namespace QAlgorithmsPrivate { + +template + void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan) +{ +top: + int span = int(end - start); + if (span < 2) + return; + + --end; + RandomAccessIterator low = start, high = end - 1; + RandomAccessIterator pivot = start + span / 2; + + if (lessThan(*end, *start)) + qSwap(*end, *start); + if (span == 2) + return; + + if (lessThan(*pivot, *start)) + qSwap(*pivot, *start); + if (lessThan(*end, *pivot)) + qSwap(*end, *pivot); + if (span == 3) + return; + + qSwap(*pivot, *end); + + while (low < high) { + while (low < high && lessThan(*low, *end)) + ++low; + + while (high > low && lessThan(*end, *high)) + --high; + + if (low < high) { + qSwap(*low, *high); + ++low; + --high; + } else { + break; + } + } + + if (lessThan(*low, *end)) + ++low; + + qSwap(*end, *low); + qSortHelper(start, low, t, lessThan); + + start = low + 1; + ++end; + goto top; +} + +template +inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy) +{ + qSortHelper(begin, end, dummy, qLess()); +} + +template + void qReverse(RandomAccessIterator begin, RandomAccessIterator end) +{ + --end; + while (begin < end) + qSwap(*begin++, *end--); +} + +template + void qRotate(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end) +{ + qReverse(begin, middle); + qReverse(middle, end); + qReverse(begin, end); +} + +template + void qMerge(RandomAccessIterator begin, RandomAccessIterator pivot, RandomAccessIterator end, T &t, LessThan lessThan) +{ + const int len1 = pivot - begin; + const int len2 = end - pivot; + + if (len1 == 0 || len2 == 0) + return; + + if (len1 + len2 == 2) { + if (lessThan(*(begin + 1), *(begin))) + qSwap(*begin, *(begin + 1)); + return; + } + + RandomAccessIterator firstCut; + RandomAccessIterator secondCut; + int len2Half; + if (len1 > len2) { + const int len1Half = len1 / 2; + firstCut = begin + len1Half; + secondCut = qLowerBound(pivot, end, *firstCut, lessThan); + len2Half = secondCut - pivot; + } else { + len2Half = len2 / 2; + secondCut = pivot + len2Half; + firstCut = qUpperBound(begin, pivot, *secondCut, lessThan); + } + + qRotate(firstCut, pivot, secondCut); + const RandomAccessIterator newPivot = firstCut + len2Half; + qMerge(begin, firstCut, newPivot, t, lessThan); + qMerge(newPivot, secondCut, end, t, lessThan); +} + +template + void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &t, LessThan lessThan) +{ + const int span = end - begin; + if (span < 2) + return; + + const RandomAccessIterator middle = begin + span / 2; + qStableSortHelper(begin, middle, t, lessThan); + qStableSortHelper(middle, end, t, lessThan); + qMerge(begin, middle, end, t, lessThan); +} + +template +inline void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy) +{ + qStableSortHelper(begin, end, dummy, qLess()); +} + +template + RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) +{ + RandomAccessIterator middle; + int n = int(end - begin); + int half; + + while (n > 0) { + half = n >> 1; + middle = begin + half; + if (lessThan(*middle, value)) { + begin = middle + 1; + n -= half + 1; + } else { + n = half; + } + } + return begin; +} + + +template + RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) +{ + RandomAccessIterator middle; + int n = end - begin; + int half; + + while (n > 0) { + half = n >> 1; + middle = begin + half; + if (lessThan(value, *middle)) { + n = half; + } else { + begin = middle + 1; + n -= half + 1; + } + } + return begin; +} + +template + RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) +{ + RandomAccessIterator it = qLowerBoundHelper(begin, end, value, lessThan); + + if (it == end || lessThan(value, *it)) + return end; + + return it; +} + +} + + + + +# 48 "/usr/include/qt4/QtCore/qlist.h" 2 3 4 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iterator" 1 3 4 +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iterator" 3 4 + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iterator" 3 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ios" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ios" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ios" 3 + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + class locale + { + public: + + + typedef int category; + + + class facet; + class id; + class _Impl; + + friend class facet; + friend class _Impl; + + template + friend bool + has_facet(const locale&) throw(); + + template + friend const _Facet& + use_facet(const locale&); + + template + friend struct __use_cache; +# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + locale() throw(); +# 126 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + locale(const locale& __other) throw(); +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + explicit + locale(const char* __s); +# 151 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + locale(const locale& __base, const char* __s, category __cat); +# 192 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + locale(const locale& __base, const locale& __add, category __cat); +# 205 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + template + locale(const locale& __other, _Facet* __f); + + + ~locale() throw(); +# 219 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + const locale& + operator=(const locale& __other) throw(); +# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + template + locale + combine(const locale& __other) const; + + + + + + + __attribute ((__abi_tag__ ("cxx11"))) + string + name() const; +# 254 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + template + bool + operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, + const basic_string<_Char, _Traits, _Alloc>& __s2) const; +# 298 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + class locale::id + { + private: + friend class locale; + friend class locale::_Impl; + + template + friend const _Facet& + use_facet(const locale&); + + template + 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 + friend bool + has_facet(const locale&) throw(); + + template + friend const _Facet& + use_facet(const locale&); + + template + 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 + void + _M_init_facet(_Facet* __facet) + { _M_install_facet(&_Facet::id, __facet); } + + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + explicit + collate(size_t __refs = 0) + : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) + { } +# 673 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + string_type + transform(const _CharT* __lo, const _CharT* __hi) const + { return this->do_transform(__lo, __hi); } +# 723 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + virtual int + do_compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const; +# 766 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 3 + virtual string_type + do_transform(const _CharT* __lo, const _CharT* __hi) const; +# 779 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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::_M_compare(const wchar_t*, const wchar_t*) const throw(); + + template<> + size_t + collate::_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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.tcc" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.tcc" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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(__facets[__i])); + + + + } +# 130 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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(*__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 >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + extern template class collate; + extern template class collate_byname; + + extern template + const collate& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + + +} +# 843 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_classes.h" 2 3 +# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 2 3 + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/stdexcept" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/stdexcept" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + }; + + 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 + }; + + 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 + }; + + 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 + }; +# 222 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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: +# 249 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error + { + public: + explicit + failure(const string& __str); +# 263 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + virtual + ~failure() throw(); + + virtual const char* + what() const throw(); + }; +# 317 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; +# 392 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; +# 423 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; +# 455 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; +# 481 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + enum event + { + erase_event, + imbue_event, + copyfmt_event + }; +# 498 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + typedef void (*event_callback) (event __e, ios_base& __b, int __i); +# 510 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; } +# 623 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + fmtflags + flags(fmtflags __fmtfl) + { + fmtflags __old = _M_flags; + _M_flags = __fmtfl; + return __old; + } +# 639 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + fmtflags + setf(fmtflags __fmtfl) + { + fmtflags __old = _M_flags; + _M_flags |= __fmtfl; + return __old; + } +# 656 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; } +# 682 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; + } +# 733 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + static bool + sync_with_stdio(bool __sync = true); +# 745 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + locale + imbue(const locale& __loc) throw(); +# 756 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + locale + getloc() const + { return _M_ios_locale; } +# 767 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + const locale& + _M_getloc() const + { return _M_ios_locale; } +# 786 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + static int + xalloc() throw(); +# 802 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; + } +# 823 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; + } +# 840 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + virtual ~ios_base(); + + protected: + ios_base() throw (); + + + + + private: + ios_base(const ios_base&); + + ios_base& + operator=(const ios_base&); +# 867 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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; + } +# 1070 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ios_base.h" 3 + +} +# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ios" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + streamsize + __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, + basic_streambuf<_CharT, _Traits>*, bool&); +# 119 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + template + 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 __streambuf_type; + + + friend class basic_ios; + friend class basic_istream; + friend class basic_ostream; + friend class istreambuf_iterator; + friend class ostreambuf_iterator; + + friend streamsize + __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + _CharT2*>::__type + __copy_move_a2(istreambuf_iterator<_CharT2>, + istreambuf_iterator<_CharT2>, _CharT2*); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + istreambuf_iterator<_CharT2> >::__type + find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + const _CharT2&); + + template + friend basic_istream<_CharT2, _Traits2>& + operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*); + + template + friend basic_istream<_CharT2, _Traits2>& + operator>>(basic_istream<_CharT2, _Traits2>&, + basic_string<_CharT2, _Traits2, _Alloc>&); + + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + locale + pubimbue(const locale& __loc) + { + locale __tmp(this->getloc()); + this->imbue(__loc); + _M_buf_locale = __loc; + return __tmp; + } +# 225 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + locale + getloc() const + { return _M_buf_locale; } +# 238 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + basic_streambuf* + pubsetbuf(char_type* __s, streamsize __n) + { return this->setbuf(__s, __n); } +# 250 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + streamsize + in_avail() + { + const streamsize __ret = this->egptr() - this->gptr(); + return __ret ? __ret : this->showmanyc(); + } +# 297 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + streamsize + sgetn(char_type* __s, streamsize __n) + { return this->xsgetn(__s, __n); } +# 371 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + streamsize + sputn(const char_type* __s, streamsize __n) + { return this->xsputn(__s, __n); } + + protected: +# 463 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + void + gbump(int __n) { _M_in_cur += __n; } +# 508 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + void + pbump(int __n) { _M_out_cur += __n; } +# 554 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + void + setp(char_type* __pbeg, char_type* __pend) + { + _M_out_beg = _M_out_cur = __pbeg; + _M_out_end = __pend; + } +# 575 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + virtual void + imbue(const locale& __loc) + { } +# 590 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + virtual basic_streambuf* + setbuf(char_type*, streamsize) + { return this; } +# 601 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + virtual int + sync() { return 0; } +# 648 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + virtual streamsize + showmanyc() { return 0; } +# 664 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + virtual streamsize + xsgetn(char_type* __s, streamsize __n); +# 686 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + virtual int_type + underflow() + { return traits_type::eof(); } +# 699 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + virtual int_type + pbackfail(int_type __c = traits_type::eof()) + { return traits_type::eof(); } +# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + virtual streamsize + xsputn(const char_type* __s, streamsize __n); +# 767 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + virtual int_type + overflow(int_type __c = traits_type::eof()) + { return traits_type::eof(); } + + + + public: +# 782 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + }; +# 836 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 3 + template<> + streamsize + __copy_streambufs_eof(basic_streambuf* __sbin, + basic_streambuf* __sbout, bool& __ineof); + + template<> + streamsize + __copy_streambufs_eof(basic_streambuf* __sbin, + basic_streambuf* __sbout, bool& __ineof); + + + +} + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/streambuf.tcc" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/streambuf.tcc" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/streambuf.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + 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 + 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 + 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 + 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; + extern template + streamsize + __copy_streambufs(basic_streambuf*, + basic_streambuf*); + extern template + streamsize + __copy_streambufs_eof(basic_streambuf*, + basic_streambuf*, bool&); + + + + +} +# 851 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/streambuf" 2 3 +# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ios" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwctype" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwctype" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwctype" 3 +# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cwctype" 2 3 +# 80 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cctype" 1 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cctype" 3 + +# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/cctype" 3 +# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 2 3 + + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/streambuf_iterator.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/streambuf_iterator.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/streambuf_iterator.h" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/streambuf_iterator.h" 3 + template + class istreambuf_iterator + : public iterator + + { + 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 + 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 + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + _CharT2*>::__type + __copy_move_a2(istreambuf_iterator<_CharT2>, + istreambuf_iterator<_CharT2>, _CharT2*); + + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + inline bool + operator==(const istreambuf_iterator<_CharT, _Traits>& __a, + const istreambuf_iterator<_CharT, _Traits>& __b) + { return __a.equal(__b); } + + template + inline bool + operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, + const istreambuf_iterator<_CharT, _Traits>& __b) + { return !__a.equal(__b); } + + + template + class ostreambuf_iterator + : public iterator + { + public: + + + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_streambuf<_CharT, _Traits> streambuf_type; + typedef basic_ostream<_CharT, _Traits> ostream_type; + + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + ostreambuf_iterator<_CharT2> >::__type + copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + ostreambuf_iterator<_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 + 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 + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + template + class __ctype_abstract_base : public locale::facet, public ctype_base + { + public: + + + typedef _CharT char_type; +# 168 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + bool + is(mask __m, char_type __c) const + { return this->do_is(__m, __c); } +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } +# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } +# 275 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + char_type + widen(char __c) const + { return this->do_widen(__c); } +# 311 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + char + narrow(char_type __c, char __dfault) const + { return this->do_narrow(__c, __dfault); } +# 352 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual bool + do_is(mask __m, char_type __c) const = 0; +# 396 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const = 0; +# 469 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const = 0; +# 485 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const = 0; +# 502 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const = 0; +# 521 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const = 0; +# 542 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0; +# 563 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const = 0; +# 588 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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(-1)]; + mutable char _M_narrow[1 + static_cast(-1)]; + mutable char _M_narrow_ok; + + + public: + + static locale::id id; + + static const size_t table_size = 1 + static_cast(-1); +# 717 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + explicit + ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); +# 730 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + explicit + ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, + size_t __refs = 0); +# 743 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + inline bool + is(mask __m, char __c) const; +# 758 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + inline const char* + is(const char* __lo, const char* __hi, mask* __vec) const; +# 772 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + inline const char* + scan_is(mask __m, const char* __lo, const char* __hi) const; +# 786 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + inline const char* + scan_not(mask __m, const char* __lo, const char* __hi) const; +# 801 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } +# 818 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } +# 851 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const; +# 1028 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; +# 1044 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const; +# 1061 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; +# 1081 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const + { return __c; } +# 1104 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const + { return __c; } +# 1156 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + template<> + class ctype : public __ctype_abstract_base + { + 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(-1)]; + + + mask _M_bit[16]; + __wmask_type _M_wmask[16]; + + public: + + + static locale::id id; +# 1214 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + explicit + ctype(size_t __refs = 0); +# 1225 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual bool + do_is(mask __m, char_type __c) const; +# 1268 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; +# 1286 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const; +# 1338 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; +# 1354 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const; +# 1371 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; +# 1391 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const; +# 1413 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const; +# 1436 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const; +# 1462 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 : public ctype + { + public: + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + + + + + + protected: + virtual + ~ctype_byname(); + }; + + + +} + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/x86_64-pc-linux-gnu/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + explicit + numpunct(__cache_type* __cache, size_t __refs = 0) + : facet(__refs), _M_data(__cache) + { _M_initialize_numpunct(); } +# 1717 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + char_type + decimal_point() const + { return this->do_decimal_point(); } +# 1744 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + char_type + thousands_sep() const + { return this->do_thousands_sep(); } +# 1775 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + string + grouping() const + { return this->do_grouping(); } +# 1788 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + string_type + truename() const + { return this->do_truename(); } +# 1801 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + string_type + falsename() const + { return this->do_falsename(); } + + protected: + + virtual + ~numpunct(); +# 1818 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_decimal_point() const + { return _M_data->_M_decimal_point; } +# 1830 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual char_type + do_thousands_sep() const + { return _M_data->_M_thousands_sep; } +# 1843 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual string + do_grouping() const + { return _M_data->_M_grouping; } +# 1856 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + virtual string_type + do_truename() const + { return _M_data->_M_truename; } +# 1869 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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::~numpunct(); + + template<> + void + numpunct::_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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + template + class num_get : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef _InIter iter_type; + + + + static locale::id id; +# 1968 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + explicit + num_get(size_t __refs = 0) : facet(__refs) { } +# 1994 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + __attribute ((__abi_tag__ ("cxx11"))) + iter_type + _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, + _ValueT&) const; + + template + 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 __gnu_cxx::__enable_if::__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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + }; + + template + locale::id num_get<_CharT, _InIter>::id; +# 2288 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + template + class num_put : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef _OutIter iter_type; + + + + static locale::id id; +# 2309 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + explicit + num_put(size_t __refs = 0) : facet(__refs) { } +# 2327 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + locale::id num_put<_CharT, _OutIter>::id; + + + + + + + + + + template + inline bool + isspace(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::space, __c); } + + + template + inline bool + isprint(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::print, __c); } + + + template + inline bool + iscntrl(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::cntrl, __c); } + + + template + inline bool + isupper(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::upper, __c); } + + + template + inline bool + islower(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::lower, __c); } + + + template + inline bool + isalpha(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::alpha, __c); } + + + template + inline bool + isdigit(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::digit, __c); } + + + template + inline bool + ispunct(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::punct, __c); } + + + template + inline bool + isxdigit(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::xdigit, __c); } + + + template + inline bool + isalnum(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::alnum, __c); } + + + template + inline bool + isgraph(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::graph, __c); } +# 2637 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 3 + template + inline _CharT + toupper(_CharT __c, const locale& __loc) + { return use_facet >(__loc).toupper(__c); } + + + template + inline _CharT + tolower(_CharT __c, const locale& __loc) + { return use_facet >(__loc).tolower(__c); } + + +} + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.tcc" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.tcc" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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*>(__caches[__i]); + } + }; + + template + void + __numpunct_cache<_CharT>::_M_cache(const locale& __loc) + { + const numpunct<_CharT>& __np = use_facet >(__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 >(__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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.tcc" 3 + __attribute__ ((__pure__)) bool + __verify_grouping(const char* __grouping, size_t __grouping_size, + const string& __grouping_tmp) throw (); + + + + template + __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(__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(__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 + 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(__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(__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 + _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 + _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 + _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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.tcc" 3 + template + _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 + _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(__ul); + return __beg; + } + + + + template + 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(__w); + } + + + + template + 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 + 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 + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.tcc" 3 + template + 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(__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(__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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.tcc" 3 + const ctype<_CharT>& __ctype = use_facet >(__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 + _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 + _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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.tcc" 3 + template + _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 + _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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.tcc" 3 + template + 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(__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 >(__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(__gbeg[__idx]) > 0 + && __gbeg[__idx] != __gnu_cxx::__numeric_traits::__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 >(const locale&); + + extern template + const numpunct& + use_facet >(const locale&); + + extern template + const num_put& + use_facet >(const locale&); + + extern template + const num_get& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + 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 >(const locale&); + + extern template + const numpunct& + use_facet >(const locale&); + + extern template + const num_put& + use_facet >(const locale&); + + extern template + const num_get& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + + +} +# 2652 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/locale_facets.h" 2 3 +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + operator void*() const + { return this->fail() ? 0 : const_cast(this); } + + + bool + operator!() const + { return this->fail(); } +# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + iostate + rdstate() const + { return _M_streambuf_state; } +# 147 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + bool + fail() const + { return (this->rdstate() & (badbit | failbit)) != 0; } + + + + + + + + bool + bad() const + { return (this->rdstate() & badbit) != 0; } +# 221 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + iostate + exceptions() const + { return _M_exception; } +# 256 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + basic_ostream<_CharT, _Traits>* + tie() const + { return _M_tie; } +# 306 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + basic_streambuf<_CharT, _Traits>* + rdbuf(basic_streambuf<_CharT, _Traits>* __sb); +# 360 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + char_type + fill(char_type __ch) + { + char_type __old = this->fill(); + _M_fill = __ch; + return __old; + } +# 409 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + locale + imbue(const locale& __loc); +# 429 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + char + narrow(char_type __c, char __dfault) const + { return __check_facet(_M_ctype).narrow(__c, __dfault); } +# 448 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 3 + void + _M_cache_locale(const locale& __loc); + }; + + +} + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.tcc" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.tcc" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + 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 + 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 + 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 + 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 + void + basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) + { + + ios_base::_M_init(); + + + _M_cache_locale(_M_ios_locale); +# 146 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + 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; + + + + +} +# 517 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/basic_ios.h" 2 3 +# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ios" 2 3 +# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + explicit + basic_ostream(__streambuf_type* __sb) + { this->init(__sb); } + + + + + + + virtual + ~basic_ostream() { } + + + class sentry; + friend class sentry; +# 107 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + __ostream_type& + operator<<(const void* __p) + { return _M_insert(__p); } +# 269 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + __ostream_type& + operator<<(__streambuf_type* __sb); +# 302 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + __ostream_type& + write(const char_type* __s, streamsize __n); +# 347 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + __ostream_type& + flush(); +# 357 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + pos_type + tellp(); +# 368 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + __ostream_type& + seekp(pos_type); +# 380 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + __ostream_type& + seekp(off_type, ios_base::seekdir); + + protected: + basic_ostream() + { this->init(0); } +# 413 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + template + __ostream_type& + _M_insert(_ValueT __v); + }; +# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + template + class basic_ostream<_CharT, _Traits>::sentry + { + + bool _M_ok; + basic_ostream<_CharT, _Traits>& _M_os; + + public: +# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + explicit + sentry(basic_ostream<_CharT, _Traits>& __os); +# 454 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + operator bool() const + { return _M_ok; } + }; +# 495 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) + { return __ostream_insert(__out, &__c, 1); } + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) + { return (__out << __out.widen(__c)); } + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, char __c) + { return __ostream_insert(__out, &__c, 1); } + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, signed char __c) + { return (__out << static_cast(__c)); } + + template + inline basic_ostream& + operator<<(basic_ostream& __out, unsigned char __c) + { return (__out << static_cast(__c)); } +# 537 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + template + 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 + basic_ostream<_CharT, _Traits> & + operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); + + + template + inline basic_ostream& + operator<<(basic_ostream& __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& + operator<<(basic_ostream& __out, const signed char* __s) + { return (__out << reinterpret_cast(__s)); } + + template + inline basic_ostream & + operator<<(basic_ostream& __out, const unsigned char* __s) + { return (__out << reinterpret_cast(__s)); } +# 588 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + endl(basic_ostream<_CharT, _Traits>& __os) + { return flush(__os.put(__os.widen('\n'))); } +# 600 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + ends(basic_ostream<_CharT, _Traits>& __os) + { return __os.put(_CharT()); } + + + + + + + template + inline basic_ostream<_CharT, _Traits>& + flush(basic_ostream<_CharT, _Traits>& __os) + { return __os.flush(); } +# 635 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 3 + +} + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ostream.tcc" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ostream.tcc" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/ostream.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + 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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 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 + 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 + 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))) + __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 + 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; + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/ostream" 2 3 +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iterator" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 1 3 +# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + operator>>(void*& __p) + { return _M_extract(__p); } +# 258 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + operator>>(__streambuf_type* __sb); +# 268 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + streamsize + gcount() const + { return _M_gcount; } +# 301 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + int_type + get(); +# 315 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + get(char_type& __c); +# 342 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + get(char_type* __s, streamsize __n, char_type __delim); +# 353 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + get(char_type* __s, streamsize __n) + { return this->get(__s, __n, this->widen('\n')); } +# 376 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + get(__streambuf_type& __sb, char_type __delim); +# 386 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + get(__streambuf_type& __sb) + { return this->get(__sb, this->widen('\n')); } +# 415 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + getline(char_type* __s, streamsize __n, char_type __delim); +# 426 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + getline(char_type* __s, streamsize __n) + { return this->getline(__s, __n, this->widen('\n')); } +# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + ignore(streamsize __n, int_type __delim); + + __istream_type& + ignore(streamsize __n); + + __istream_type& + ignore(); +# 467 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + int_type + peek(); +# 485 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + read(char_type* __s, streamsize __n); +# 504 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + streamsize + readsome(char_type* __s, streamsize __n); +# 521 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + putback(char_type __c); +# 537 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + unget(); +# 555 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + int + sync(); +# 570 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + pos_type + tellg(); +# 585 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + seekg(pos_type); +# 601 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + __istream_type& + seekg(off_type, ios_base::seekdir); + + + protected: + basic_istream() + : _M_gcount(streamsize(0)) + { this->init(0); } +# 639 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + template + __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& + 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); +# 685 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + explicit + sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); +# 734 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + operator bool() const + { return _M_ok; } + }; +# 750 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); + + template + inline basic_istream& + operator>>(basic_istream& __in, unsigned char& __c) + { return (__in >> reinterpret_cast(__c)); } + + template + inline basic_istream& + operator>>(basic_istream& __in, signed char& __c) + { return (__in >> reinterpret_cast(__c)); } +# 792 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + template + 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& + operator>>(basic_istream& __in, unsigned char* __s) + { return (__in >> reinterpret_cast(__s)); } + + template + inline basic_istream& + operator>>(basic_istream& __in, signed char* __s) + { return (__in >> reinterpret_cast(__s)); } +# 823 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + template + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + }; +# 906 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + template + basic_istream<_CharT, _Traits>& + ws(basic_istream<_CharT, _Traits>& __is); +# 931 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 3 + +} + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/istream.tcc" 1 3 +# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/istream.tcc" 3 + +# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/istream.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + 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 + 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 + 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::__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 + 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::__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 + 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 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 + 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 + 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 + 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 + 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 + 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 + 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/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/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 + 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 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 + 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 + 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 + 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 + 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 + 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 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 + 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 + 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 + 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 + 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 + 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; + 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; + + + + +} +# 935 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/istream" 2 3 +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iterator" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stream_iterator.h" 1 3 +# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stream_iterator.h" 3 + +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stream_iterator.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + + template, typename _Dist = ptrdiff_t> + class istream_iterator + : public iterator + { + public: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_istream<_CharT, _Traits> istream_type; + + private: + istream_type* _M_stream; + _Tp _M_value; + bool _M_ok; + + public: + + istream_iterator() + : _M_stream(0), _M_value(), _M_ok(false) {} + + + istream_iterator(istream_type& __s) + : _M_stream(&__s) + { _M_read(); } + + istream_iterator(const istream_iterator& __obj) + : _M_stream(__obj._M_stream), _M_value(__obj._M_value), + _M_ok(__obj._M_ok) + { } + + const _Tp& + operator*() const + { + + + ; + return _M_value; + } + + const _Tp* + operator->() const { return &(operator*()); } + + istream_iterator& + operator++() + { + + + ; + _M_read(); + return *this; + } + + istream_iterator + operator++(int) + { + + + ; + istream_iterator __tmp = *this; + _M_read(); + return __tmp; + } + + bool + _M_equal(const istream_iterator& __x) const + { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); } + + private: + void + _M_read() + { + _M_ok = (_M_stream && *_M_stream) ? true : false; + if (_M_ok) + { + *_M_stream >> _M_value; + _M_ok = *_M_stream ? true : false; + } + } + }; + + + template + inline bool + operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, + const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) + { return __x._M_equal(__y); } + + + template + inline bool + operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, + const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) + { return !__x._M_equal(__y); } +# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stream_iterator.h" 3 + template > + class ostream_iterator + : public iterator + { + public: + + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_ostream<_CharT, _Traits> ostream_type; + + + private: + ostream_type* _M_stream; + const _CharT* _M_string; + + public: + + ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {} +# 183 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stream_iterator.h" 3 + ostream_iterator(ostream_type& __s, const _CharT* __c) + : _M_stream(&__s), _M_string(__c) { } + + + ostream_iterator(const ostream_iterator& __obj) + : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { } + + + + ostream_iterator& + operator=(const _Tp& __value) + { + + + ; + *_M_stream << __value; + if (_M_string) *_M_stream << _M_string; + return *this; + } + + ostream_iterator& + operator*() + { return *this; } + + ostream_iterator& + operator++() + { return *this; } + + ostream_iterator& + operator++(int) + { return *this; } + }; + + + + +} +# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/iterator" 2 3 +# 51 "/usr/include/qt4/QtCore/qlist.h" 2 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/list" 1 3 4 +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/list" 3 4 + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/list" 3 + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 1 3 +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + namespace __detail + { + +# 77 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + struct _List_node_base + { + _List_node_base* _M_next; + _List_node_base* _M_prev; + + static void + swap(_List_node_base& __x, _List_node_base& __y) throw(); + + void + _M_transfer(_List_node_base* const __first, + _List_node_base* const __last) throw(); + + void + _M_reverse() throw(); + + void + _M_hook(_List_node_base* const __position) throw(); + + void + _M_unhook() throw(); + }; + + + } + + + + + template + struct _List_node : public __detail::_List_node_base + { + + _Tp _M_data; + + + + + + + + }; + + + + + + + template + struct _List_iterator + { + typedef _List_iterator<_Tp> _Self; + typedef _List_node<_Tp> _Node; + + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef _Tp value_type; + typedef _Tp* pointer; + typedef _Tp& reference; + + _List_iterator() + : _M_node() { } + + explicit + _List_iterator(__detail::_List_node_base* __x) + : _M_node(__x) { } + + _Self + _M_const_cast() const + { return *this; } + + + reference + operator*() const + { return static_cast<_Node*>(_M_node)->_M_data; } + + pointer + operator->() const + { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); } + + _Self& + operator++() + { + _M_node = _M_node->_M_next; + return *this; + } + + _Self + operator++(int) + { + _Self __tmp = *this; + _M_node = _M_node->_M_next; + return __tmp; + } + + _Self& + operator--() + { + _M_node = _M_node->_M_prev; + return *this; + } + + _Self + operator--(int) + { + _Self __tmp = *this; + _M_node = _M_node->_M_prev; + return __tmp; + } + + bool + operator==(const _Self& __x) const + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const + { return _M_node != __x._M_node; } + + + __detail::_List_node_base* _M_node; + }; + + + + + + + template + struct _List_const_iterator + { + typedef _List_const_iterator<_Tp> _Self; + typedef const _List_node<_Tp> _Node; + typedef _List_iterator<_Tp> iterator; + + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef _Tp value_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + + _List_const_iterator() + : _M_node() { } + + explicit + _List_const_iterator(const __detail::_List_node_base* __x) + + : _M_node(__x) { } + + _List_const_iterator(const iterator& __x) + : _M_node(__x._M_node) { } + + iterator + _M_const_cast() const + { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); } + + + + reference + operator*() const + { return static_cast<_Node*>(_M_node)->_M_data; } + + pointer + operator->() const + { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); } + + _Self& + operator++() + { + _M_node = _M_node->_M_next; + return *this; + } + + _Self + operator++(int) + { + _Self __tmp = *this; + _M_node = _M_node->_M_next; + return __tmp; + } + + _Self& + operator--() + { + _M_node = _M_node->_M_prev; + return *this; + } + + _Self + operator--(int) + { + _Self __tmp = *this; + _M_node = _M_node->_M_prev; + return __tmp; + } + + bool + operator==(const _Self& __x) const + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const + { return _M_node != __x._M_node; } + + + const __detail::_List_node_base* _M_node; + }; + + template + inline bool + operator==(const _List_iterator<_Val>& __x, + const _List_const_iterator<_Val>& __y) + { return __x._M_node == __y._M_node; } + + template + inline bool + operator!=(const _List_iterator<_Val>& __x, + const _List_const_iterator<_Val>& __y) + { return __x._M_node != __y._M_node; } + +namespace __cxx11 { + + template + class _List_base + { + protected: +# 314 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + typedef typename _Alloc::template rebind<_List_node<_Tp> >::other + _Node_alloc_type; + + typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; + + static size_t + _S_distance(const __detail::_List_node_base* __first, + const __detail::_List_node_base* __last) + { + size_t __n = 0; + while (__first != __last) + { + __first = __first->_M_next; + ++__n; + } + return __n; + } + + struct _List_impl + : public _Node_alloc_type + { + + _List_node _M_node; + + + + + _List_impl() + : _Node_alloc_type(), _M_node() + { } + + _List_impl(const _Node_alloc_type& __a) + : _Node_alloc_type(__a), _M_node() + { } + + + + + + + }; + + _List_impl _M_impl; + + + size_t _M_get_size() const { return _M_impl._M_node._M_data; } + + void _M_set_size(size_t __n) { _M_impl._M_node._M_data = __n; } + + void _M_inc_size(size_t __n) { _M_impl._M_node._M_data += __n; } + + void _M_dec_size(size_t __n) { _M_impl._M_node._M_data -= __n; } + + size_t + _M_distance(const __detail::_List_node_base* __first, + const __detail::_List_node_base* __last) const + { return _S_distance(__first, __last); } + + + size_t _M_node_count() const { return _M_impl._M_node._M_data; } +# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + _List_node<_Tp>* + _M_get_node() + { return _M_impl._Node_alloc_type::allocate(1); } + + void + _M_put_node(_List_node<_Tp>* __p) + { _M_impl._Node_alloc_type::deallocate(__p, 1); } + + public: + typedef _Alloc allocator_type; + + _Node_alloc_type& + _M_get_Node_allocator() + { return *static_cast<_Node_alloc_type*>(&_M_impl); } + + const _Node_alloc_type& + _M_get_Node_allocator() const + { return *static_cast(&_M_impl); } + + _Tp_alloc_type + _M_get_Tp_allocator() const + { return _Tp_alloc_type(_M_get_Node_allocator()); } + + allocator_type + get_allocator() const + { return allocator_type(_M_get_Node_allocator()); } + + _List_base() + : _M_impl() + { _M_init(); } + + _List_base(const _Node_alloc_type& __a) + : _M_impl(__a) + { _M_init(); } +# 445 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + ~_List_base() + { _M_clear(); } + + void + _M_clear() ; + + void + _M_init() + { + this->_M_impl._M_node._M_next = &this->_M_impl._M_node; + this->_M_impl._M_node._M_prev = &this->_M_impl._M_node; + _M_set_size(0); + } + }; +# 506 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template > + class list : protected _List_base<_Tp, _Alloc> + { + + typedef typename _Alloc::value_type _Alloc_value_type; + + + + typedef _List_base<_Tp, _Alloc> _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + typedef typename _Base::_Node_alloc_type _Node_alloc_type; + + public: + typedef _Tp value_type; + typedef typename _Tp_alloc_type::pointer pointer; + typedef typename _Tp_alloc_type::const_pointer const_pointer; + typedef typename _Tp_alloc_type::reference reference; + typedef typename _Tp_alloc_type::const_reference const_reference; + typedef _List_iterator<_Tp> iterator; + typedef _List_const_iterator<_Tp> const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + protected: + + + typedef _List_node<_Tp> _Node; + + using _Base::_M_impl; + using _Base::_M_put_node; + using _Base::_M_get_node; + using _Base::_M_get_Tp_allocator; + using _Base::_M_get_Node_allocator; +# 550 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + _Node* + _M_create_node(const value_type& __x) + { + _Node* __p = this->_M_get_node(); + try + { + _M_get_Tp_allocator().construct + (std::__addressof(__p->_M_data), __x); + } + catch(...) + { + _M_put_node(__p); + throw; + } + return __p; + } +# 586 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + public: + + + + + + + list() + + + + : _Base() { } + + + + + + explicit + list(const allocator_type& __a) + : _Base(_Node_alloc_type(__a)) { } +# 641 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + explicit + list(size_type __n, const value_type& __value = value_type(), + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { _M_fill_initialize(__n, __value); } +# 655 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + list(const list& __x) + : _Base(__x._M_get_Node_allocator()) + { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } +# 702 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template + list(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { + + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_initialize_dispatch(__first, __last, _Integral()); + } +# 728 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + list& + operator=(const list& __x); +# 774 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + assign(size_type __n, const value_type& __val) + { _M_fill_assign(__n, __val); } +# 797 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template + void + assign(_InputIterator __first, _InputIterator __last) + { + + typedef typename std::__is_integer<_InputIterator>::__type _Integral; + _M_assign_dispatch(__first, __last, _Integral()); + } +# 821 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + allocator_type + get_allocator() const + { return _Base::get_allocator(); } + + + + + + + iterator + begin() + { return iterator(this->_M_impl._M_node._M_next); } + + + + + + + const_iterator + begin() const + { return const_iterator(this->_M_impl._M_node._M_next); } + + + + + + + iterator + end() + { return iterator(&this->_M_impl._M_node); } + + + + + + + const_iterator + end() const + { return const_iterator(&this->_M_impl._M_node); } + + + + + + + reverse_iterator + rbegin() + { return reverse_iterator(end()); } + + + + + + + const_reverse_iterator + rbegin() const + { return const_reverse_iterator(end()); } + + + + + + + reverse_iterator + rend() + { return reverse_iterator(begin()); } + + + + + + + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } +# 940 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + bool + empty() const + { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; } + + + size_type + size() const + { return this->_M_node_count(); } + + + size_type + max_size() const + { return _M_get_Node_allocator().max_size(); } +# 990 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + resize(size_type __new_size, value_type __x = value_type()); + + + + + + + + reference + front() + { return *begin(); } + + + + + + const_reference + front() const + { return *begin(); } + + + + + + reference + back() + { + iterator __tmp = end(); + --__tmp; + return *__tmp; + } + + + + + + const_reference + back() const + { + const_iterator __tmp = end(); + --__tmp; + return *__tmp; + } +# 1046 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + push_front(const value_type& __x) + { this->_M_insert(begin(), __x); } +# 1073 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + pop_front() + { this->_M_erase(begin()); } +# 1087 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + push_back(const value_type& __x) + { this->_M_insert(end(), __x); } +# 1113 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + pop_back() + { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); } +# 1159 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + iterator + insert(iterator __position, const value_type& __x); +# 1229 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + insert(iterator __position, size_type __n, const value_type& __x) + { + list __tmp(__n, __x, get_allocator()); + splice(__position, __tmp); + } +# 1272 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template + void + insert(iterator __position, _InputIterator __first, + _InputIterator __last) + { + list __tmp(__first, __last, get_allocator()); + splice(__position, __tmp); + } +# 1297 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + iterator + + + + erase(iterator __position); +# 1322 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + iterator + + + + erase(iterator __first, iterator __last) + + { + while (__first != __last) + __first = erase(__first); + return __last._M_const_cast(); + } +# 1343 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + swap(list& __x) + { + __detail::_List_node_base::swap(this->_M_impl._M_node, + __x._M_impl._M_node); + + size_t __xsize = __x._M_get_size(); + __x._M_set_size(this->_M_get_size()); + this->_M_set_size(__xsize); + + + + std::__alloc_swap:: + _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()); + } + + + + + + + + void + clear() + { + _Base::_M_clear(); + _Base::_M_init(); + } +# 1384 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + + + + splice(iterator __position, list& __x) + + { + if (!__x.empty()) + { + _M_check_equal_allocators(__x); + + this->_M_transfer(__position._M_const_cast(), + __x.begin(), __x.end()); + + this->_M_inc_size(__x._M_get_size()); + __x._M_set_size(0); + } + } +# 1432 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + splice(iterator __position, list& __x, iterator __i) + + { + iterator __j = __i._M_const_cast(); + ++__j; + if (__position == __i || __position == __j) + return; + + if (this != &__x) + _M_check_equal_allocators(__x); + + this->_M_transfer(__position._M_const_cast(), + __i._M_const_cast(), __j); + + this->_M_inc_size(1); + __x._M_dec_size(1); + } +# 1497 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + splice(iterator __position, list& __x, iterator __first, + iterator __last) + + { + if (__first != __last) + { + if (this != &__x) + _M_check_equal_allocators(__x); + + size_t __n = this->_M_distance(__first._M_node, __last._M_node); + this->_M_inc_size(__n); + __x._M_dec_size(__n); + + this->_M_transfer(__position._M_const_cast(), + __first._M_const_cast(), + __last._M_const_cast()); + } + } +# 1548 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + remove(const _Tp& __value); +# 1562 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template + void + remove_if(_Predicate); +# 1576 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + unique(); +# 1591 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template + void + unique(_BinaryPredicate); +# 1612 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + merge(list& __x); +# 1639 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template + void + merge(list& __x, _StrictWeakOrdering __comp); + + + + + + + + void + reverse() + { this->_M_impl._M_node._M_reverse(); } + + + + + + + + void + sort(); + + + + + + + + template + void + sort(_StrictWeakOrdering); + + protected: + + + + + + + template + void + _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) + { _M_fill_initialize(static_cast(__n), __x); } + + + template + void + _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { + for (; __first != __last; ++__first) + + + + push_back(*__first); + + } + + + + void + _M_fill_initialize(size_type __n, const value_type& __x) + { + for (; __n; --__n) + push_back(__x); + } +# 1727 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { _M_fill_assign(__n, __val); } + + + template + void + _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + __false_type); + + + + void + _M_fill_assign(size_type __n, const value_type& __val); + + + + void + _M_transfer(iterator __position, iterator __first, iterator __last) + { __position._M_node->_M_transfer(__first._M_node, __last._M_node); } + + + + void + _M_insert(iterator __position, const value_type& __x) + { + _Node* __tmp = _M_create_node(__x); + __tmp->_M_hook(__position._M_node); + this->_M_inc_size(1); + } +# 1770 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + void + _M_erase(iterator __position) + { + this->_M_dec_size(1); + __position._M_node->_M_unhook(); + _Node* __n = static_cast<_Node*>(__position._M_node); + + + + _M_get_Tp_allocator().destroy(std::__addressof(__n->_M_data)); + + _M_put_node(__n); + } + + + void + _M_check_equal_allocators(list& __x) + { + if (std::__alloc_neq:: + _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator())) + __builtin_abort(); + } + }; +} +# 1805 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template + inline bool + operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { + typedef typename list<_Tp, _Alloc>::const_iterator const_iterator; + const_iterator __end1 = __x.end(); + const_iterator __end2 = __y.end(); + + const_iterator __i1 = __x.begin(); + const_iterator __i2 = __y.begin(); + while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) + { + ++__i1; + ++__i2; + } + return __i1 == __end1 && __i2 == __end2; + } +# 1834 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_list.h" 3 + template + inline bool + operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); } + + + template + inline bool + operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return !(__x == __y); } + + + template + inline bool + operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return __y < __x; } + + + template + inline bool + operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return !(__x < __y); } + + + template + inline void + swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) + { __x.swap(__y); } + + +} +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/list" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/list.tcc" 1 3 +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/list.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + void + _List_base<_Tp, _Alloc>:: + _M_clear() + { + typedef _List_node<_Tp> _Node; + __detail::_List_node_base* __cur = _M_impl._M_node._M_next; + while (__cur != &_M_impl._M_node) + { + _Node* __tmp = static_cast<_Node*>(__cur); + __cur = __tmp->_M_next; + + + + _M_get_Tp_allocator().destroy(std::__addressof(__tmp->_M_data)); + + _M_put_node(__tmp); + } + } +# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/list.tcc" 3 + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + + + + insert(iterator __position, const value_type& __x) + + { + _Node* __tmp = _M_create_node(__x); + __tmp->_M_hook(__position._M_const_cast()._M_node); + this->_M_inc_size(1); + return iterator(__tmp); + } +# 146 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/list.tcc" 3 + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + + + + erase(iterator __position) + + { + iterator __ret = iterator(__position._M_node->_M_next); + _M_erase(__position._M_const_cast()); + return __ret; + } +# 210 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/list.tcc" 3 + template + void + list<_Tp, _Alloc>:: + resize(size_type __new_size, value_type __x) + { + iterator __i = begin(); + size_type __len = 0; + for (; __i != end() && __len < __new_size; ++__i, ++__len) + ; + if (__len == __new_size) + erase(__i, end()); + else + insert(end(), __new_size - __len, __x); + } + + + template + list<_Tp, _Alloc>& + list<_Tp, _Alloc>:: + operator=(const list& __x) + { + if (this != &__x) + { + iterator __first1 = begin(); + iterator __last1 = end(); + const_iterator __first2 = __x.begin(); + const_iterator __last2 = __x.end(); + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, ++__first2) + *__first1 = *__first2; + if (__first2 == __last2) + erase(__first1, __last1); + else + insert(__last1, __first2, __last2); + } + return *this; + } + + template + void + list<_Tp, _Alloc>:: + _M_fill_assign(size_type __n, const value_type& __val) + { + iterator __i = begin(); + for (; __i != end() && __n > 0; ++__i, --__n) + *__i = __val; + if (__n > 0) + insert(end(), __n, __val); + else + erase(__i, end()); + } + + template + template + void + list<_Tp, _Alloc>:: + _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2, + __false_type) + { + iterator __first1 = begin(); + iterator __last1 = end(); + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, ++__first2) + *__first1 = *__first2; + if (__first2 == __last2) + erase(__first1, __last1); + else + insert(__last1, __first2, __last2); + } + + template + void + list<_Tp, _Alloc>:: + remove(const value_type& __value) + { + iterator __first = begin(); + iterator __last = end(); + iterator __extra = __last; + while (__first != __last) + { + iterator __next = __first; + ++__next; + if (*__first == __value) + { + + + + if (std::__addressof(*__first) != std::__addressof(__value)) + _M_erase(__first); + else + __extra = __first; + } + __first = __next; + } + if (__extra != __last) + _M_erase(__extra); + } + + template + void + list<_Tp, _Alloc>:: + unique() + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) + return; + iterator __next = __first; + while (++__next != __last) + { + if (*__first == *__next) + _M_erase(__next); + else + __first = __next; + __next = __first; + } + } + + template + void + list<_Tp, _Alloc>:: + + + + merge(list& __x) + + { + + + if (this != &__x) + { + _M_check_equal_allocators(__x); + + iterator __first1 = begin(); + iterator __last1 = end(); + iterator __first2 = __x.begin(); + iterator __last2 = __x.end(); + while (__first1 != __last1 && __first2 != __last2) + if (*__first2 < *__first1) + { + iterator __next = __first2; + _M_transfer(__first1, __first2, ++__next); + __first2 = __next; + } + else + ++__first1; + if (__first2 != __last2) + _M_transfer(__last1, __first2, __last2); + + this->_M_inc_size(__x._M_get_size()); + __x._M_set_size(0); + } + } + + template + template + void + list<_Tp, _Alloc>:: + + + + merge(list& __x, _StrictWeakOrdering __comp) + + { + + + if (this != &__x) + { + _M_check_equal_allocators(__x); + + iterator __first1 = begin(); + iterator __last1 = end(); + iterator __first2 = __x.begin(); + iterator __last2 = __x.end(); + while (__first1 != __last1 && __first2 != __last2) + if (__comp(*__first2, *__first1)) + { + iterator __next = __first2; + _M_transfer(__first1, __first2, ++__next); + __first2 = __next; + } + else + ++__first1; + if (__first2 != __last2) + _M_transfer(__last1, __first2, __last2); + + this->_M_inc_size(__x._M_get_size()); + __x._M_set_size(0); + } + } + + template + void + list<_Tp, _Alloc>:: + sort() + { + + if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node + && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) + { + list __carry; + list __tmp[64]; + list * __fill = &__tmp[0]; + list * __counter; + + do + { + __carry.splice(__carry.begin(), *this, begin()); + + for(__counter = &__tmp[0]; + __counter != __fill && !__counter->empty(); + ++__counter) + { + __counter->merge(__carry); + __carry.swap(*__counter); + } + __carry.swap(*__counter); + if (__counter == __fill) + ++__fill; + } + while ( !empty() ); + + for (__counter = &__tmp[1]; __counter != __fill; ++__counter) + __counter->merge(*(__counter - 1)); + swap( *(__fill - 1) ); + } + } + + template + template + void + list<_Tp, _Alloc>:: + remove_if(_Predicate __pred) + { + iterator __first = begin(); + iterator __last = end(); + while (__first != __last) + { + iterator __next = __first; + ++__next; + if (__pred(*__first)) + _M_erase(__first); + __first = __next; + } + } + + template + template + void + list<_Tp, _Alloc>:: + unique(_BinaryPredicate __binary_pred) + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) + return; + iterator __next = __first; + while (++__next != __last) + { + if (__binary_pred(*__first, *__next)) + _M_erase(__next); + else + __first = __next; + __next = __first; + } + } + + template + template + void + list<_Tp, _Alloc>:: + sort(_StrictWeakOrdering __comp) + { + + if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node + && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) + { + list __carry; + list __tmp[64]; + list * __fill = &__tmp[0]; + list * __counter; + + do + { + __carry.splice(__carry.begin(), *this, begin()); + + for(__counter = &__tmp[0]; + __counter != __fill && !__counter->empty(); + ++__counter) + { + __counter->merge(__carry, __comp); + __carry.swap(*__counter); + } + __carry.swap(*__counter); + if (__counter == __fill) + ++__fill; + } + while ( !empty() ); + + for (__counter = &__tmp[1]; __counter != __fill; ++__counter) + __counter->merge(*(__counter - 1), __comp); + swap(*(__fill - 1)); + } + } + + +} +# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/list" 2 3 +# 52 "/usr/include/qt4/QtCore/qlist.h" 2 3 4 + + + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include-fixed/limits.h" 1 3 4 +# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include-fixed/limits.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include-fixed/syslimits.h" 1 3 4 + + + + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include-fixed/limits.h" 1 3 4 +# 168 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include-fixed/limits.h" 3 4 +# 1 "/usr/include/limits.h" 1 3 4 +# 143 "/usr/include/limits.h" 3 4 +# 1 "/usr/include/bits/posix1_lim.h" 1 3 4 +# 160 "/usr/include/bits/posix1_lim.h" 3 4 +# 1 "/usr/include/bits/local_lim.h" 1 3 4 +# 38 "/usr/include/bits/local_lim.h" 3 4 +# 1 "/usr/include/linux/limits.h" 1 3 4 +# 39 "/usr/include/bits/local_lim.h" 2 3 4 +# 161 "/usr/include/bits/posix1_lim.h" 2 3 4 +# 144 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/posix2_lim.h" 1 3 4 +# 148 "/usr/include/limits.h" 2 3 4 + + + +# 1 "/usr/include/bits/xopen_lim.h" 1 3 4 +# 33 "/usr/include/bits/xopen_lim.h" 3 4 +# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 +# 34 "/usr/include/bits/xopen_lim.h" 2 3 4 +# 152 "/usr/include/limits.h" 2 3 4 +# 169 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include-fixed/limits.h" 2 3 4 +# 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include-fixed/syslimits.h" 2 3 4 +# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include-fixed/limits.h" 2 3 4 +# 60 "/usr/include/qt4/QtCore/qlist.h" 2 3 4 + + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +template class QVector; +template class QSet; + +struct QListData { + struct Data { + QBasicAtomicInt ref; + int alloc, begin, end; + uint sharable : 1; + void *array[1]; + }; + enum { DataHeaderSize = sizeof(Data) - sizeof(void *) }; + + Data *detach(int alloc); + Data *detach_grow(int *i, int n); + Data *detach(); + Data *detach2(); + Data *detach3(); + void realloc(int alloc); + static Data shared_null; + Data *d; + void **erase(void **xi); + void **append(int n); + void **append(); + void **append(const QListData &l); + void **append2(const QListData &l); + void **prepend(); + void **insert(int i); + void remove(int i); + void remove(int i, int n); + void move(int from, int to); + inline int size() const { return d->end - d->begin; } + inline bool isEmpty() const { return d->end == d->begin; } + inline void **at(int i) const { return d->array + d->begin + i; } + inline void **begin() const { return d->array + d->begin; } + inline void **end() const { return d->array + d->end; } +}; + +template +class QList +{ + struct Node { void *v; + + + + inline T &t() + { return *reinterpret_cast(QTypeInfo::isLarge || QTypeInfo::isStatic + ? v : this); } + + }; + + union { QListData p; QListData::Data *d; }; + +public: + inline QList() : d(&QListData::shared_null) { d->ref.ref(); } + inline QList(const QList &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach_helper(); } + ~QList(); + QList &operator=(const QList &l); + + + + + inline void swap(QList &other) { qSwap(d, other.d); } + + + + + bool operator==(const QList &l) const; + inline bool operator!=(const QList &l) const { return !(*this == l); } + + inline int size() const { return p.size(); } + + inline void detach() { if (d->ref != 1) detach_helper(); } + + inline void detachShared() + { + + if (d->ref != 1 && this->d != &QListData::shared_null) + detach_helper(); + } + + inline bool isDetached() const { return d->ref == 1; } + inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } + inline bool isSharedWith(const QList &other) const { return d == other.d; } + + inline bool isEmpty() const { return p.isEmpty(); } + + void clear(); + + const T &at(int i) const; + const T &operator[](int i) const; + T &operator[](int i); + + void reserve(int size); + void append(const T &t); + void append(const QList &t); + void prepend(const T &t); + void insert(int i, const T &t); + void replace(int i, const T &t); + void removeAt(int i); + int removeAll(const T &t); + bool removeOne(const T &t); + T takeAt(int i); + T takeFirst(); + T takeLast(); + void move(int from, int to); + void swap(int i, int j); + int indexOf(const T &t, int from = 0) const; + int lastIndexOf(const T &t, int from = -1) const; + QBool contains(const T &t) const; + int count(const T &t) const; + + class const_iterator; + + class iterator { + public: + Node *i; + typedef std::random_access_iterator_tag iterator_category; + typedef qptrdiff difference_type; + typedef T value_type; + typedef T *pointer; + typedef T &reference; + + inline iterator() : i(0) {} + inline iterator(Node *n) : i(n) {} + inline iterator(const iterator &o): i(o.i){} + inline T &operator*() const { return i->t(); } + inline T *operator->() const { return &i->t(); } + inline T &operator[](int j) const { return i[j].t(); } + inline bool operator==(const iterator &o) const { return i == o.i; } + inline bool operator!=(const iterator &o) const { return i != o.i; } + inline bool operator<(const iterator& other) const { return i < other.i; } + inline bool operator<=(const iterator& other) const { return i <= other.i; } + inline bool operator>(const iterator& other) const { return i > other.i; } + inline bool operator>=(const iterator& other) const { return i >= other.i; } + + inline bool operator==(const const_iterator &o) const + { return i == o.i; } + inline bool operator!=(const const_iterator &o) const + { return i != o.i; } + inline bool operator<(const const_iterator& other) const + { return i < other.i; } + inline bool operator<=(const const_iterator& other) const + { return i <= other.i; } + inline bool operator>(const const_iterator& other) const + { return i > other.i; } + inline bool operator>=(const const_iterator& other) const + { return i >= other.i; } + + inline iterator &operator++() { ++i; return *this; } + inline iterator operator++(int) { Node *n = i; ++i; return n; } + inline iterator &operator--() { i--; return *this; } + inline iterator operator--(int) { Node *n = i; i--; return n; } + inline iterator &operator+=(int j) { i+=j; return *this; } + inline iterator &operator-=(int j) { i-=j; return *this; } + inline iterator operator+(int j) const { return iterator(i+j); } + inline iterator operator-(int j) const { return iterator(i-j); } + inline int operator-(iterator j) const { return int(i - j.i); } + }; + friend class iterator; + + class const_iterator { + public: + Node *i; + typedef std::random_access_iterator_tag iterator_category; + typedef qptrdiff difference_type; + typedef T value_type; + typedef const T *pointer; + typedef const T &reference; + + inline const_iterator() : i(0) {} + inline const_iterator(Node *n) : i(n) {} + inline const_iterator(const const_iterator &o): i(o.i) {} + + + + inline const_iterator(const iterator &o): i(o.i) {} + + inline const T &operator*() const { return i->t(); } + inline const T *operator->() const { return &i->t(); } + inline const T &operator[](int j) const { return i[j].t(); } + inline bool operator==(const const_iterator &o) const { return i == o.i; } + inline bool operator!=(const const_iterator &o) const { return i != o.i; } + inline bool operator<(const const_iterator& other) const { return i < other.i; } + inline bool operator<=(const const_iterator& other) const { return i <= other.i; } + inline bool operator>(const const_iterator& other) const { return i > other.i; } + inline bool operator>=(const const_iterator& other) const { return i >= other.i; } + inline const_iterator &operator++() { ++i; return *this; } + inline const_iterator operator++(int) { Node *n = i; ++i; return n; } + inline const_iterator &operator--() { i--; return *this; } + inline const_iterator operator--(int) { Node *n = i; i--; return n; } + inline const_iterator &operator+=(int j) { i+=j; return *this; } + inline const_iterator &operator-=(int j) { i-=j; return *this; } + inline const_iterator operator+(int j) const { return const_iterator(i+j); } + inline const_iterator operator-(int j) const { return const_iterator(i-j); } + inline int operator-(const_iterator j) const { return i - j.i; } + }; + friend class const_iterator; + + + inline iterator begin() { detach(); return reinterpret_cast(p.begin()); } + inline const_iterator begin() const { return reinterpret_cast(p.begin()); } + inline const_iterator constBegin() const { return reinterpret_cast(p.begin()); } + inline iterator end() { detach(); return reinterpret_cast(p.end()); } + inline const_iterator end() const { return reinterpret_cast(p.end()); } + inline const_iterator constEnd() const { return reinterpret_cast(p.end()); } + iterator insert(iterator before, const T &t); + iterator erase(iterator pos); + iterator erase(iterator first, iterator last); + + + typedef iterator Iterator; + typedef const_iterator ConstIterator; + inline int count() const { return p.size(); } + inline int length() const { return p.size(); } + inline T& first() { qt_noop(); return *begin(); } + inline const T& first() const { qt_noop(); return at(0); } + T& last() { qt_noop(); return *(--end()); } + const T& last() const { qt_noop(); return at(count() - 1); } + inline void removeFirst() { qt_noop(); erase(begin()); } + inline void removeLast() { qt_noop(); erase(--end()); } + inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; } + inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; } + QList mid(int pos, int length = -1) const; + + T value(int i) const; + T value(int i, const T &defaultValue) const; + + + inline void push_back(const T &t) { append(t); } + inline void push_front(const T &t) { prepend(t); } + inline T& front() { return first(); } + inline const T& front() const { return first(); } + inline T& back() { return last(); } + inline const T& back() const { return last(); } + inline void pop_front() { removeFirst(); } + inline void pop_back() { removeLast(); } + inline bool empty() const { return isEmpty(); } + typedef int size_type; + typedef T value_type; + typedef value_type *pointer; + typedef const value_type *const_pointer; + typedef value_type &reference; + typedef const value_type &const_reference; + typedef qptrdiff difference_type; +# 328 "/usr/include/qt4/QtCore/qlist.h" 3 4 + QList &operator+=(const QList &l); + inline QList operator+(const QList &l) const + { QList n = *this; n += l; return n; } + inline QList &operator+=(const T &t) + { append(t); return *this; } + inline QList &operator<< (const T &t) + { append(t); return *this; } + inline QList &operator<<(const QList &l) + { *this += l; return *this; } + + QVector toVector() const; + QSet toSet() const; + + static QList fromVector(const QVector &vector); + static QList fromSet(const QSet &set); + + + static inline QList fromStdList(const std::list &list) + { QList tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; } + inline std::list toStdList() const + { std::list tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; } + + +private: + Node *detach_helper_grow(int i, int n); + void detach_helper(int alloc); + void detach_helper(); + void free(QListData::Data *d); + + void node_construct(Node *n, const T &t); + void node_destruct(Node *n); + void node_copy(Node *from, Node *to, Node *src); + void node_destruct(Node *from, Node *to); +}; + + + + + + + +template +inline void QList::node_construct(Node *n, const T &t) +{ + if (QTypeInfo::isLarge || QTypeInfo::isStatic) n->v = new T(t); + else if (QTypeInfo::isComplex) new (n) T(t); + + + + + else *reinterpret_cast(n) = t; + + + + +} + +template +inline void QList::node_destruct(Node *n) +{ + if (QTypeInfo::isLarge || QTypeInfo::isStatic) delete reinterpret_cast(n->v); + else if (QTypeInfo::isComplex) reinterpret_cast(n)->~T(); +} + +template +inline void QList::node_copy(Node *from, Node *to, Node *src) +{ + Node *current = from; + if (QTypeInfo::isLarge || QTypeInfo::isStatic) { + try { + while(current != to) { + current->v = new T(*reinterpret_cast(src->v)); + ++current; + ++src; + } + } catch (...) { + while (current-- != from) + delete reinterpret_cast(current->v); + throw; + } + + } else if (QTypeInfo::isComplex) { + try { + while(current != to) { + new (current) T(*reinterpret_cast(src)); + ++current; + ++src; + } + } catch (...) { + while (current-- != from) + (reinterpret_cast(current))->~T(); + throw; + } + } else { + if (src != from && to - from > 0) + memcpy(from, src, (to - from) * sizeof(Node *)); + } +} + +template +inline void QList::node_destruct(Node *from, Node *to) +{ + if (QTypeInfo::isLarge || QTypeInfo::isStatic) + while(from != to) --to, delete reinterpret_cast(to->v); + else if (QTypeInfo::isComplex) + while (from != to) --to, reinterpret_cast(to)->~T(); +} + +template +inline QList &QList::operator=(const QList &l) +{ + if (d != l.d) { + QListData::Data *o = l.d; + o->ref.ref(); + if (!d->ref.deref()) + free(d); + d = o; + if (!d->sharable) + detach_helper(); + } + return *this; +} +template +inline typename QList::iterator QList::insert(iterator before, const T &t) +{ + int iBefore = int(before.i - reinterpret_cast(p.begin())); + Node *n = reinterpret_cast(p.insert(iBefore)); + try { + node_construct(n, t); + } catch (...) { + p.remove(iBefore); + throw; + } + return n; +} +template +inline typename QList::iterator QList::erase(iterator it) +{ node_destruct(it.i); + return reinterpret_cast(p.erase(reinterpret_cast(it.i))); } +template +inline const T &QList::at(int i) const +{ qt_noop(); + return reinterpret_cast(p.at(i))->t(); } +template +inline const T &QList::operator[](int i) const +{ qt_noop(); + return reinterpret_cast(p.at(i))->t(); } +template +inline T &QList::operator[](int i) +{ qt_noop(); + detach(); return reinterpret_cast(p.at(i))->t(); } +template +inline void QList::removeAt(int i) +{ if(i >= 0 && i < p.size()) { detach(); + node_destruct(reinterpret_cast(p.at(i))); p.remove(i); } } +template +inline T QList::takeAt(int i) +{ qt_noop(); + detach(); Node *n = reinterpret_cast(p.at(i)); T t = n->t(); node_destruct(n); + p.remove(i); return t; } +template +inline T QList::takeFirst() +{ T t = first(); removeFirst(); return t; } +template +inline T QList::takeLast() +{ T t = last(); removeLast(); return t; } + +template + void QList::reserve(int alloc) +{ + if (d->alloc < alloc) { + if (d->ref != 1) + detach_helper(alloc); + else + p.realloc(alloc); + } +} + +template + void QList::append(const T &t) +{ + if (d->ref != 1) { + Node *n = detach_helper_grow(0x7fffffff, 1); + try { + node_construct(n, t); + } catch (...) { + --d->end; + throw; + } + } else { + if (QTypeInfo::isLarge || QTypeInfo::isStatic) { + Node *n = reinterpret_cast(p.append()); + try { + node_construct(n, t); + } catch (...) { + --d->end; + throw; + } + } else { + Node *n, copy; + node_construct(©, t); + try { + n = reinterpret_cast(p.append());; + } catch (...) { + node_destruct(©); + throw; + } + *n = copy; + } + } +} + +template +inline void QList::prepend(const T &t) +{ + if (d->ref != 1) { + Node *n = detach_helper_grow(0, 1); + try { + node_construct(n, t); + } catch (...) { + ++d->begin; + throw; + } + } else { + if (QTypeInfo::isLarge || QTypeInfo::isStatic) { + Node *n = reinterpret_cast(p.prepend()); + try { + node_construct(n, t); + } catch (...) { + ++d->begin; + throw; + } + } else { + Node *n, copy; + node_construct(©, t); + try { + n = reinterpret_cast(p.prepend());; + } catch (...) { + node_destruct(©); + throw; + } + *n = copy; + } + } +} + +template +inline void QList::insert(int i, const T &t) +{ + if (d->ref != 1) { + Node *n = detach_helper_grow(i, 1); + try { + node_construct(n, t); + } catch (...) { + p.remove(i); + throw; + } + } else { + if (QTypeInfo::isLarge || QTypeInfo::isStatic) { + Node *n = reinterpret_cast(p.insert(i)); + try { + node_construct(n, t); + } catch (...) { + p.remove(i); + throw; + } + } else { + Node *n, copy; + node_construct(©, t); + try { + n = reinterpret_cast(p.insert(i));; + } catch (...) { + node_destruct(©); + throw; + } + *n = copy; + } + } +} + +template +inline void QList::replace(int i, const T &t) +{ + qt_noop(); + detach(); + reinterpret_cast(p.at(i))->t() = t; +} + +template +inline void QList::swap(int i, int j) +{ + qt_noop() + ; + detach(); + void *t = d->array[d->begin + i]; + d->array[d->begin + i] = d->array[d->begin + j]; + d->array[d->begin + j] = t; +} + +template +inline void QList::move(int from, int to) +{ + qt_noop() + ; + detach(); + p.move(from, to); +} + +template + QList QList::mid(int pos, int alength) const +{ + if (alength < 0 || pos + alength > size()) + alength = size() - pos; + if (pos == 0 && alength == size()) + return *this; + QList cpy; + if (alength <= 0) + return cpy; + cpy.reserve(alength); + cpy.d->end = alength; + try { + cpy.node_copy(reinterpret_cast(cpy.p.begin()), + reinterpret_cast(cpy.p.end()), + reinterpret_cast(p.begin() + pos)); + } catch (...) { + + cpy.d->end = 0; + throw; + } + return cpy; +} + +template + T QList::value(int i) const +{ + if (i < 0 || i >= p.size()) { + return T(); + } + return reinterpret_cast(p.at(i))->t(); +} + +template + T QList::value(int i, const T& defaultValue) const +{ + return ((i < 0 || i >= p.size()) ? defaultValue : reinterpret_cast(p.at(i))->t()); +} + +template + typename QList::Node *QList::detach_helper_grow(int i, int c) +{ + Node *n = reinterpret_cast(p.begin()); + QListData::Data *x = p.detach_grow(&i, c); + try { + node_copy(reinterpret_cast(p.begin()), + reinterpret_cast(p.begin() + i), n); + } catch (...) { + qFree(d); + d = x; + throw; + } + try { + node_copy(reinterpret_cast(p.begin() + i + c), + reinterpret_cast(p.end()), n + i); + } catch (...) { + node_destruct(reinterpret_cast(p.begin()), + reinterpret_cast(p.begin() + i)); + qFree(d); + d = x; + throw; + } + + if (!x->ref.deref()) + free(x); + + return reinterpret_cast(p.begin() + i); +} + +template + void QList::detach_helper(int alloc) +{ + Node *n = reinterpret_cast(p.begin()); + QListData::Data *x = p.detach(alloc); + try { + node_copy(reinterpret_cast(p.begin()), reinterpret_cast(p.end()), n); + } catch (...) { + qFree(d); + d = x; + throw; + } + + if (!x->ref.deref()) + free(x); +} + +template + void QList::detach_helper() +{ + detach_helper(d->alloc); +} + +template + QList::~QList() +{ + if (!d->ref.deref()) + free(d); +} + +template + bool QList::operator==(const QList &l) const +{ + if (p.size() != l.p.size()) + return false; + if (d == l.d) + return true; + Node *i = reinterpret_cast(p.end()); + Node *b = reinterpret_cast(p.begin()); + Node *li = reinterpret_cast(l.p.end()); + while (i != b) { + --i; --li; + if (!(i->t() == li->t())) + return false; + } + return true; +} + + +template + void QList::free(QListData::Data *data) +{ + node_destruct(reinterpret_cast(data->array + data->begin), + reinterpret_cast(data->array + data->end)); + qFree(data); +} + + +template + void QList::clear() +{ + *this = QList(); +} + +template + int QList::removeAll(const T &_t) +{ + int index = indexOf(_t); + if (index == -1) + return 0; + + const T t = _t; + detach(); + + Node *i = reinterpret_cast(p.at(index)); + Node *e = reinterpret_cast(p.end()); + Node *n = i; + node_destruct(i); + while (++i != e) { + if (i->t() == t) + node_destruct(i); + else + *n++ = *i; + } + + int removedCount = e - n; + d->end -= removedCount; + return removedCount; +} + +template + bool QList::removeOne(const T &_t) +{ + int index = indexOf(_t); + if (index != -1) { + removeAt(index); + return true; + } + return false; +} + +template + typename QList::iterator QList::erase(typename QList::iterator afirst, + typename QList::iterator alast) +{ + for (Node *n = afirst.i; n < alast.i; ++n) + node_destruct(n); + int idx = afirst - begin(); + p.remove(idx, alast - afirst); + return begin() + idx; +} + +template + QList &QList::operator+=(const QList &l) +{ + if (!l.isEmpty()) { + if (isEmpty()) { + *this = l; + } else { + Node *n = (d->ref != 1) + ? detach_helper_grow(0x7fffffff, l.size()) + : reinterpret_cast(p.append2(l.p)); + try { + node_copy(n, reinterpret_cast(p.end()), + reinterpret_cast(l.p.begin())); + } catch (...) { + + d->end -= int(reinterpret_cast(p.end()) - n); + throw; + } + } + } + return *this; +} + +template +inline void QList::append(const QList &t) +{ + *this += t; +} + +template + int QList::indexOf(const T &t, int from) const +{ + if (from < 0) + from = qMax(from + p.size(), 0); + if (from < p.size()) { + Node *n = reinterpret_cast(p.at(from -1)); + Node *e = reinterpret_cast(p.end()); + while (++n != e) + if (n->t() == t) + return int(n - reinterpret_cast(p.begin())); + } + return -1; +} + +template + int QList::lastIndexOf(const T &t, int from) const +{ + if (from < 0) + from += p.size(); + else if (from >= p.size()) + from = p.size()-1; + if (from >= 0) { + Node *b = reinterpret_cast(p.begin()); + Node *n = reinterpret_cast(p.at(from + 1)); + while (n-- != b) { + if (n->t() == t) + return n - b; + } + } + return -1; +} + +template + QBool QList::contains(const T &t) const +{ + Node *b = reinterpret_cast(p.begin()); + Node *i = reinterpret_cast(p.end()); + while (i-- != b) + if (i->t() == t) + return QBool(true); + return QBool(false); +} + +template + int QList::count(const T &t) const +{ + int c = 0; + Node *b = reinterpret_cast(p.begin()); + Node *i = reinterpret_cast(p.end()); + while (i-- != b) + if (i->t() == t) + ++c; + return c; +} + +template class QListIterator { typedef typename QList::const_iterator const_iterator; QList c; const_iterator i; public: inline QListIterator(const QList &container) : c(container), i(c.constBegin()) {} inline QListIterator &operator=(const QList &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } }; +template class QMutableListIterator { typedef typename QList::iterator iterator; typedef typename QList::const_iterator const_iterator; QList *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableListIterator(QList &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableListIterator() { c->setSharable(true); } inline QMutableListIterator &operator=(QList &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } }; + + + + +# 51 "/usr/include/qt4/QtCore/qobject.h" 2 3 4 + + + +# 1 "/usr/include/qt4/QtCore/qscopedpointer.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qscopedpointer.h" 3 4 + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +template +struct QScopedPointerDeleter +{ + static inline void cleanup(T *pointer) + { + + + + typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ]; + (void) sizeof(IsIncompleteType); + + delete pointer; + } +}; + +template +struct QScopedPointerArrayDeleter +{ + static inline void cleanup(T *pointer) + { + + + + typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ]; + (void) sizeof(IsIncompleteType); + + delete [] pointer; + } +}; + +struct QScopedPointerPodDeleter +{ + static inline void cleanup(void *pointer) { if (pointer) qFree(pointer); } +}; + +template > +class QScopedPointer +{ + + typedef T *QScopedPointer:: *RestrictedBool; + +public: + explicit inline QScopedPointer(T *p = 0) : d(p) + { + } + + inline ~QScopedPointer() + { + T *oldD = this->d; + Cleanup::cleanup(oldD); + this->d = 0; + } + + inline T &operator*() const + { + qt_noop(); + return *d; + } + + inline T *operator->() const + { + qt_noop(); + return d; + } + + inline bool operator!() const + { + return !d; + } + + + + + + + + inline operator RestrictedBool() const + { + return isNull() ? 0 : &QScopedPointer::d; + } + + + inline T *data() const + { + return d; + } + + inline bool isNull() const + { + return !d; + } + + inline void reset(T *other = 0) + { + if (d == other) + return; + T *oldD = d; + d = other; + Cleanup::cleanup(oldD); + } + + inline T *take() + { + T *oldD = d; + d = 0; + return oldD; + } + + inline void swap(QScopedPointer &other) + { + qSwap(d, other.d); + } + + typedef T *pointer; + +protected: + T *d; + +private: + QScopedPointer(const QScopedPointer &); QScopedPointer &operator=(const QScopedPointer &); +}; + +template +inline bool operator==(const QScopedPointer &lhs, const QScopedPointer &rhs) +{ + return lhs.data() == rhs.data(); +} + +template +inline bool operator!=(const QScopedPointer &lhs, const QScopedPointer &rhs) +{ + return lhs.data() != rhs.data(); +} + +template +inline void qSwap(QScopedPointer &p1, QScopedPointer &p2) +{ p1.swap(p2); } + + + +namespace std { + template + inline void swap(::QScopedPointer &p1, ::QScopedPointer &p2) + { p1.swap(p2); } +} + + + + + +namespace QtPrivate { + template struct QScopedArrayEnsureSameType; + template struct QScopedArrayEnsureSameType { typedef X* Type; }; + template struct QScopedArrayEnsureSameType { typedef X* Type; }; +} + +template > +class QScopedArrayPointer : public QScopedPointer +{ +public: + inline QScopedArrayPointer() : QScopedPointer(0) {} + + template + explicit inline QScopedArrayPointer(D *p, typename QtPrivate::QScopedArrayEnsureSameType::Type = 0) + : QScopedPointer(p) + { + } + + inline T &operator[](int i) + { + return this->d[i]; + } + + inline const T &operator[](int i) const + { + return this->d[i]; + } + +private: + explicit inline QScopedArrayPointer(void *) { +# 239 "/usr/include/qt4/QtCore/qscopedpointer.h" 3 4 + } + + QScopedArrayPointer(const QScopedArrayPointer &); QScopedArrayPointer &operator=(const QScopedArrayPointer &); +}; + + + +# 55 "/usr/include/qt4/QtCore/qobject.h" 2 3 4 + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QEvent; +class QTimerEvent; +class QChildEvent; +struct QMetaObject; +class QVariant; +class QObjectPrivate; +class QObject; +class QThread; +class QWidget; + +class QRegExp; + + +class QObjectUserData; + + +typedef QList QObjectList; + + void qt_qFindChildren_helper(const QObject *parent, const QString &name, const QRegExp *re, + const QMetaObject &mo, QList *list); + QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo); + +class + + + +QObjectData { +public: + virtual ~QObjectData() = 0; + QObject *q_ptr; + QObject *parent; + QObjectList children; + + uint isWidget : 1; + uint pendTimer : 1; + uint blockSig : 1; + uint wasDeleted : 1; + uint ownObjectName : 1; + uint sendChildEvents : 1; + uint receiveChildEvents : 1; + uint inEventHandler : 1; + uint inThreadChangeEvent : 1; + uint hasGuards : 1; + uint unused : 22; + int postedEvents; + QMetaObject *metaObject; +}; + + +class QObject +{ + public: template inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); + + inline QObjectPrivate* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); } inline const QObjectPrivate* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); } friend class QObjectPrivate; + +public: + explicit QObject(QObject *parent=0); + virtual ~QObject(); + + virtual bool event(QEvent *); + virtual bool eventFilter(QObject *, QEvent *); +# 143 "/usr/include/qt4/QtCore/qobject.h" 3 4 + QString objectName() const; + void setObjectName(const QString &name); + + inline bool isWidgetType() const { return d_ptr->isWidget; } + + inline bool signalsBlocked() const { return d_ptr->blockSig; } + bool blockSignals(bool b); + + QThread *thread() const; + void moveToThread(QThread *thread); + + int startTimer(int interval); + void killTimer(int id); + + template + inline T findChild(const QString &aName = QString()) const + { return static_cast(qt_qFindChild_helper(this, aName, reinterpret_cast(0)->staticMetaObject)); } + + template + inline QList findChildren(const QString &aName = QString()) const + { + QList list; + union { + QList *typedList; + QList *voidList; + } u; + u.typedList = &list; + qt_qFindChildren_helper(this, aName, 0, reinterpret_cast(0)->staticMetaObject, u.voidList); + return list; + } + + + template + inline QList findChildren(const QRegExp &re) const + { + QList list; + union { + QList *typedList; + QList *voidList; + } u; + u.typedList = &list; + qt_qFindChildren_helper(this, QString(), &re, reinterpret_cast(0)->staticMetaObject, u.voidList); + return list; + } +# 197 "/usr/include/qt4/QtCore/qobject.h" 3 4 + inline const QObjectList &children() const { return d_ptr->children; } + + void setParent(QObject *); + void installEventFilter(QObject *); + void removeEventFilter(QObject *); + + + static bool connect(const QObject *sender, const char *signal, + const QObject *receiver, const char *member, Qt::ConnectionType = + + + + + + + Qt::AutoConnection + + + ); + + static bool connect(const QObject *sender, const QMetaMethod &signal, + const QObject *receiver, const QMetaMethod &method, + Qt::ConnectionType type = + + + + + + + Qt::AutoConnection + + + ); + + inline bool connect(const QObject *sender, const char *signal, + const char *member, Qt::ConnectionType type = + + + + + + + Qt::AutoConnection + + + ) const; + + static bool disconnect(const QObject *sender, const char *signal, + const QObject *receiver, const char *member); + static bool disconnect(const QObject *sender, const QMetaMethod &signal, + const QObject *receiver, const QMetaMethod &member); + inline bool disconnect(const char *signal = 0, + const QObject *receiver = 0, const char *member = 0) + { return disconnect(this, signal, receiver, member); } + inline bool disconnect(const QObject *receiver, const char *member = 0) + { return disconnect(this, 0, receiver, member); } + + void dumpObjectTree(); + void dumpObjectInfo(); + + + bool setProperty(const char *name, const QVariant &value); + QVariant property(const char *name) const; + QList dynamicPropertyNames() const; + + + + static uint registerUserData(); + void setUserData(uint id, QObjectUserData* data); + QObjectUserData* userData(uint id) const; + + +protected: + void destroyed(QObject * = 0); + +public: + inline QObject *parent() const { return d_ptr->parent; } + + inline bool inherits(const char *classname) const + { return const_cast(this)->qt_metacast(classname) != 0; } + +public : + void deleteLater(); + +protected: + QObject *sender() const; + int senderSignalIndex() const; + int receivers(const char* signal) const; + + virtual void timerEvent(QTimerEvent *); + virtual void childEvent(QChildEvent *); + virtual void customEvent(QEvent *); + + virtual void connectNotify(const char *signal); + virtual void disconnectNotify(const char *signal); +# 316 "/usr/include/qt4/QtCore/qobject.h" 3 4 +protected: + QObject(QObjectPrivate &dd, QObject *parent = 0); + +protected: + QScopedPointer d_ptr; + + static const QMetaObject staticQtMetaObject; + + friend struct QMetaObject; + friend class QApplication; + friend class QApplicationPrivate; + friend class QCoreApplication; + friend class QCoreApplicationPrivate; + friend class QWidget; + friend class QThreadData; + +private: + QObject(const QObject &); QObject &operator=(const QObject &); + +}; + +inline bool QObject::connect(const QObject *asender, const char *asignal, + const char *amember, Qt::ConnectionType atype) const +{ return connect(asender, asignal, this, amember, atype); } + + +class QObjectUserData { +public: + virtual ~QObjectUserData(); +}; +# 354 "/usr/include/qt4/QtCore/qobject.h" 3 4 +template +inline T qFindChild(const QObject *o, const QString &name = QString()) +{ return o->findChild(name); } + +template +inline QList qFindChildren(const QObject *o, const QString &name = QString()) +{ + return o->findChildren(name); +} + + +template +inline QList qFindChildren(const QObject *o, const QRegExp &re) +{ + return o->findChildren(re); +} + + + + +template +inline T qobject_cast(QObject *object) +{ + + reinterpret_cast(object)->qt_check_for_QOBJECT_macro(*reinterpret_cast(object)); + + return static_cast(reinterpret_cast(object)->staticMetaObject.cast(object)); +} + +template +inline T qobject_cast(const QObject *object) +{ + + reinterpret_cast(object)->qt_check_for_QOBJECT_macro(*reinterpret_cast(const_cast(object))); + + return static_cast(reinterpret_cast(object)->staticMetaObject.cast(object)); +} + + +template inline const char * qobject_interface_iid() +{ return 0; } +# 407 "/usr/include/qt4/QtCore/qobject.h" 3 4 + QDebug operator<<(QDebug, const QObject *); + + + + + +# 46 "/usr/include/qt4/QtCore/qcoreapplication.h" 2 3 4 +# 1 "/usr/include/qt4/QtCore/qcoreevent.h" 1 3 4 +# 49 "/usr/include/qt4/QtCore/qcoreevent.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QEventPrivate; +class QEvent +{ + public: static const QMetaObject staticMetaObject; private: + + +public: + enum Type { + + + + + + + None = 0, + Timer = 1, + MouseButtonPress = 2, + MouseButtonRelease = 3, + MouseButtonDblClick = 4, + MouseMove = 5, + KeyPress = 6, + KeyRelease = 7, + FocusIn = 8, + FocusOut = 9, + Enter = 10, + Leave = 11, + Paint = 12, + Move = 13, + Resize = 14, + Create = 15, + Destroy = 16, + Show = 17, + Hide = 18, + Close = 19, + Quit = 20, + ParentChange = 21, + ParentAboutToChange = 131, + + + + ThreadChange = 22, + WindowActivate = 24, + WindowDeactivate = 25, + ShowToParent = 26, + HideToParent = 27, + Wheel = 31, + WindowTitleChange = 33, + WindowIconChange = 34, + ApplicationWindowIconChange = 35, + ApplicationFontChange = 36, + ApplicationLayoutDirectionChange = 37, + ApplicationPaletteChange = 38, + PaletteChange = 39, + Clipboard = 40, + Speech = 42, + MetaCall = 43, + SockAct = 50, + WinEventAct = 132, + DeferredDelete = 52, + DragEnter = 60, + DragMove = 61, + DragLeave = 62, + Drop = 63, + DragResponse = 64, + ChildAdded = 68, + ChildPolished = 69, + + + + + + ChildRemoved = 71, + ShowWindowRequest = 73, + PolishRequest = 74, + Polish = 75, + LayoutRequest = 76, + UpdateRequest = 77, + UpdateLater = 78, + + EmbeddingControl = 79, + ActivateControl = 80, + DeactivateControl = 81, + ContextMenu = 82, + InputMethod = 83, + AccessibilityPrepare = 86, + TabletMove = 87, + LocaleChange = 88, + LanguageChange = 89, + LayoutDirectionChange = 90, + Style = 91, + TabletPress = 92, + TabletRelease = 93, + OkRequest = 94, + HelpRequest = 95, + + IconDrag = 96, + + FontChange = 97, + EnabledChange = 98, + ActivationChange = 99, + StyleChange = 100, + IconTextChange = 101, + ModifiedChange = 102, + MouseTrackingChange = 109, + + WindowBlocked = 103, + WindowUnblocked = 104, + WindowStateChange = 105, + + ToolTip = 110, + WhatsThis = 111, + StatusTip = 112, + + ActionChanged = 113, + ActionAdded = 114, + ActionRemoved = 115, + + FileOpen = 116, + + Shortcut = 117, + ShortcutOverride = 51, + + + + + + + + WhatsThisClicked = 118, + + + + + + ToolBarChange = 120, + + ApplicationActivate = 121, + ApplicationActivated = ApplicationActivate, + ApplicationDeactivate = 122, + ApplicationDeactivated = ApplicationDeactivate, + + QueryWhatsThis = 123, + EnterWhatsThisMode = 124, + LeaveWhatsThisMode = 125, + + ZOrderChange = 126, + + HoverEnter = 127, + HoverLeave = 128, + HoverMove = 129, + + AccessibilityHelp = 119, + AccessibilityDescription = 130, + + + + + + + + AcceptDropsChange = 152, + + MenubarUpdated = 153, + + + ZeroTimerEvent = 154, + + GraphicsSceneMouseMove = 155, + GraphicsSceneMousePress = 156, + GraphicsSceneMouseRelease = 157, + GraphicsSceneMouseDoubleClick = 158, + GraphicsSceneContextMenu = 159, + GraphicsSceneHoverEnter = 160, + GraphicsSceneHoverMove = 161, + GraphicsSceneHoverLeave = 162, + GraphicsSceneHelp = 163, + GraphicsSceneDragEnter = 164, + GraphicsSceneDragMove = 165, + GraphicsSceneDragLeave = 166, + GraphicsSceneDrop = 167, + GraphicsSceneWheel = 168, + + KeyboardLayoutChange = 169, + + DynamicPropertyChange = 170, + + TabletEnterProximity = 171, + TabletLeaveProximity = 172, + + NonClientAreaMouseMove = 173, + NonClientAreaMouseButtonPress = 174, + NonClientAreaMouseButtonRelease = 175, + NonClientAreaMouseButtonDblClick = 176, + + MacSizeChange = 177, + + ContentsRectChange = 178, + + MacGLWindowChange = 179, + + FutureCallOut = 180, + + GraphicsSceneResize = 181, + GraphicsSceneMove = 182, + + CursorChange = 183, + ToolTipChange = 184, + + NetworkReplyUpdated = 185, + + GrabMouse = 186, + UngrabMouse = 187, + GrabKeyboard = 188, + UngrabKeyboard = 189, + MacGLClearDrawable = 191, + + StateMachineSignal = 192, + StateMachineWrapped = 193, + + TouchBegin = 194, + TouchUpdate = 195, + TouchEnd = 196, + + + NativeGesture = 197, + + RequestSoftwareInputPanel = 199, + CloseSoftwareInputPanel = 200, + + UpdateSoftKeys = 201, + + WinIdChange = 203, + + Gesture = 198, + GestureOverride = 202, + + + PlatformPanel = 212, + + + + + User = 1000, + MaxUser = 65535 + }; + + QEvent(Type type); + virtual ~QEvent(); + inline Type type() const { return static_cast(t); } + inline bool spontaneous() const { return spont; } + + inline void setAccepted(bool accepted) { m_accept = accepted; } + inline bool isAccepted() const { return m_accept; } + + inline void accept() { m_accept = true; } + inline void ignore() { m_accept = false; } + + static int registerEventType(int hint = -1); + +protected: + QEventPrivate *d; + ushort t; + +private: + ushort posted : 1; + ushort spont : 1; + ushort m_accept : 1; + ushort reserved : 13; + + friend class QCoreApplication; + friend class QCoreApplicationPrivate; + friend class QThreadData; + friend class QApplication; + friend class QApplicationPrivate; + friend class Q3AccelManager; + friend class QShortcutMap; + friend class QETWidget; + friend class QGraphicsView; + friend class QGraphicsViewPrivate; + friend class QGraphicsScene; + friend class QGraphicsScenePrivate; + + friend class QGestureManager; + +}; + +class QTimerEvent : public QEvent +{ +public: + QTimerEvent( int timerId ); + ~QTimerEvent(); + int timerId() const { return id; } +protected: + int id; +}; + +class QObject; + +class QChildEvent : public QEvent +{ +public: + QChildEvent( Type type, QObject *child ); + ~QChildEvent(); + QObject *child() const { return c; } + bool added() const { return type() == ChildAdded; } + + + + bool polished() const { return type() == ChildPolished; } + bool removed() const { return type() == ChildRemoved; } +protected: + QObject *c; +}; +# 380 "/usr/include/qt4/QtCore/qcoreevent.h" 3 4 +class QDynamicPropertyChangeEvent : public QEvent +{ +public: + QDynamicPropertyChangeEvent(const QByteArray &name); + ~QDynamicPropertyChangeEvent(); + + inline QByteArray propertyName() const { return n; } + +private: + QByteArray n; +}; + + + + +# 47 "/usr/include/qt4/QtCore/qcoreapplication.h" 2 3 4 +# 1 "/usr/include/qt4/QtCore/qeventloop.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qeventloop.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QEventLoopPrivate; + +class QEventLoop : public QObject +{ + public: template inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); + inline QEventLoopPrivate* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); } inline const QEventLoopPrivate* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); } friend class QEventLoopPrivate; + +public: + explicit QEventLoop(QObject *parent = 0); + ~QEventLoop(); + + enum ProcessEventsFlag { + AllEvents = 0x00, + ExcludeUserInputEvents = 0x01, + ExcludeSocketNotifiers = 0x02, + WaitForMoreEvents = 0x04, + + + + + X11ExcludeTimers = 0x08 + + , DeferredDeletion = 0x10 + + , EventLoopExec = 0x20 + , DialogExec = 0x40 + }; + typedef QFlags ProcessEventsFlags; + + bool processEvents(ProcessEventsFlags flags = AllEvents); + void processEvents(ProcessEventsFlags flags, int maximumTime); + + int exec(ProcessEventsFlags flags = AllEvents); + void exit(int returnCode = 0); + bool isRunning() const; + + void wakeUp(); + +public : + void quit(); +}; + + inline QFlags operator|(QEventLoop::ProcessEventsFlags::enum_type f1, QEventLoop::ProcessEventsFlags::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(QEventLoop::ProcessEventsFlags::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QEventLoop::ProcessEventsFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + + + + +# 48 "/usr/include/qt4/QtCore/qcoreapplication.h" 2 3 4 +# 57 "/usr/include/qt4/QtCore/qcoreapplication.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QCoreApplicationPrivate; +class QTextCodec; +class QTranslator; +class QPostEventList; +class QStringList; + + + +class QCoreApplication : public QObject +{ + public: template inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); + + + + + + inline QCoreApplicationPrivate* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); } inline const QCoreApplicationPrivate* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); } friend class QCoreApplicationPrivate; +public: + enum { ApplicationFlags = 0x040807 + + | 0x01000000 + + }; + + + + + + QCoreApplication(int &argc, char **argv, int + + = ApplicationFlags + + ); + + + ~QCoreApplication(); + + + static int argc(); + static char **argv(); + + static QStringList arguments(); + + static void setAttribute(Qt::ApplicationAttribute attribute, bool on = true); + static bool testAttribute(Qt::ApplicationAttribute attribute); + + static void setOrganizationDomain(const QString &orgDomain); + static QString organizationDomain(); + static void setOrganizationName(const QString &orgName); + static QString organizationName(); + static void setApplicationName(const QString &application); + static QString applicationName(); + static void setApplicationVersion(const QString &version); + static QString applicationVersion(); + + static QCoreApplication *instance() { return self; } + + static int exec(); + static void processEvents(QEventLoop::ProcessEventsFlags flags = QEventLoop::AllEvents); + static void processEvents(QEventLoop::ProcessEventsFlags flags, int maxtime); + static void exit(int retcode=0); + + static bool sendEvent(QObject *receiver, QEvent *event); + static void postEvent(QObject *receiver, QEvent *event); + static void postEvent(QObject *receiver, QEvent *event, int priority); + static void sendPostedEvents(QObject *receiver, int event_type); + static void sendPostedEvents(); + static void removePostedEvents(QObject *receiver); + static void removePostedEvents(QObject *receiver, int eventType); + static bool hasPendingEvents(); + + virtual bool notify(QObject *, QEvent *); + + static bool startingUp(); + static bool closingDown(); + + static QString applicationDirPath(); + static QString applicationFilePath(); + static qint64 applicationPid(); + + + static void setLibraryPaths(const QStringList &); + static QStringList libraryPaths(); + static void addLibraryPath(const QString &); + static void removeLibraryPath(const QString &); + + + + static void installTranslator(QTranslator * messageFile); + static void removeTranslator(QTranslator * messageFile); + + enum Encoding { CodecForTr, UnicodeUTF8, DefaultCodec = CodecForTr }; + + static QString translate(const char * context, + const char * key, + const char * disambiguation = 0, + Encoding encoding = CodecForTr); + static QString translate(const char * context, + const char * key, + const char * disambiguation, + Encoding encoding, int n); + + static void flush(); +# 185 "/usr/include/qt4/QtCore/qcoreapplication.h" 3 4 + static void watchUnixSignal(int signal, bool watch); + + + typedef bool (*EventFilter)(void *message, long *result); + EventFilter setEventFilter(EventFilter filter); + bool filterEvent(void *message, long *result); + +public : + static void quit(); + +protected: + void aboutToQuit(); + void unixSignal(int); + +protected: + bool event(QEvent *); + + virtual bool compressEvent(QEvent *, QObject *receiver, QPostEventList *); + +protected: + QCoreApplication(QCoreApplicationPrivate &p); + +private: + static bool sendSpontaneousEvent(QObject *receiver, QEvent *event); + bool notifyInternal(QObject *receiver, QEvent *event); + + void init(); + + static QCoreApplication *self; + + QCoreApplication(const QCoreApplication &); QCoreApplication &operator=(const QCoreApplication &); + + friend class QEventDispatcherUNIXPrivate; + friend class QApplication; + friend class QApplicationPrivate; + friend class QETWidget; + friend class Q3AccelManager; + friend class QShortcutMap; + friend class QWidget; + friend class QWidgetPrivate; + friend bool qt_sendSpontaneousEvent(QObject*, QEvent*); + friend QString qAppName(); + friend class QClassFactory; +}; + +inline bool QCoreApplication::sendEvent(QObject *receiver, QEvent *event) +{ if (event) event->spont = false; return self ? self->notifyInternal(receiver, event) : false; } + +inline bool QCoreApplication::sendSpontaneousEvent(QObject *receiver, QEvent *event) +{ if (event) event->spont = true; return self ? self->notifyInternal(receiver, event) : false; } + +inline void QCoreApplication::sendPostedEvents() { sendPostedEvents(0, 0); } +# 282 "/usr/include/qt4/QtCore/qcoreapplication.h" 3 4 +typedef void (*QtCleanUpFunction)(); + + void qAddPostRoutine(QtCleanUpFunction); + void qRemovePostRoutine(QtCleanUpFunction); + QString qAppName(); + + + + + + + + + +# 46 "/usr/include/qt4/QtGui/qapplication.h" 2 3 4 +# 1 "/usr/include/qt4/QtGui/qwindowdefs.h" 1 3 4 +# 48 "/usr/include/qt4/QtGui/qwindowdefs.h" 3 4 + + + +typedef QtValidLicenseForGuiModule QtGuiModule; + + + +class QPaintDevice; +class QWidget; +class QDialog; +class QColor; +class QPalette; + + + +class QCursor; +class QPoint; +class QSize; +class QRect; +class QPolygon; +class QPainter; +class QRegion; +class QFont; +class QFontMetrics; +class QFontInfo; +class QPen; +class QBrush; +class QMatrix; +class QPixmap; +class QBitmap; +class QMovie; +class QImage; +class QPicture; +class QPrinter; +class QTimer; +class QTime; +class QClipboard; +class QString; +class QByteArray; +class QApplication; + +template class QList; +typedef QList QWidgetList; + + + +# 115 "/usr/include/qt4/QtGui/qwindowdefs.h" 3 4 +typedef struct _XDisplay Display; +typedef union _XEvent XEvent; +typedef struct _XGC *GC; +typedef struct _XRegion *Region; +typedef unsigned long WId; +# 145 "/usr/include/qt4/QtGui/qwindowdefs.h" 3 4 + + + +template class QHash; +typedef QHash QWidgetMapper; + +template class QSet; +typedef QSet QWidgetSet; + + + +# 47 "/usr/include/qt4/QtGui/qapplication.h" 2 3 4 +# 1 "/usr/include/qt4/QtCore/qpoint.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qpoint.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QPoint +{ +public: + QPoint(); + QPoint(int xpos, int ypos); + + bool isNull() const; + + int x() const; + int y() const; + void setX(int x); + void setY(int y); + + int manhattanLength() const; + + int &rx(); + int &ry(); + + QPoint &operator+=(const QPoint &p); + QPoint &operator-=(const QPoint &p); + + QPoint &operator*=(float c); + QPoint &operator*=(double c); + QPoint &operator*=(int c); + + QPoint &operator/=(qreal c); + + friend inline bool operator==(const QPoint &, const QPoint &); + friend inline bool operator!=(const QPoint &, const QPoint &); + friend inline const QPoint operator+(const QPoint &, const QPoint &); + friend inline const QPoint operator-(const QPoint &, const QPoint &); + friend inline const QPoint operator*(const QPoint &, float); + friend inline const QPoint operator*(float, const QPoint &); + friend inline const QPoint operator*(const QPoint &, double); + friend inline const QPoint operator*(double, const QPoint &); + friend inline const QPoint operator*(const QPoint &, int); + friend inline const QPoint operator*(int, const QPoint &); + friend inline const QPoint operator-(const QPoint &); + friend inline const QPoint operator/(const QPoint &, qreal); + +private: + friend class QTransform; + + + + + + int xp; + int yp; + +}; + +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPoint)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPoint"; } }; + + + + + + QDataStream &operator<<(QDataStream &, const QPoint &); + QDataStream &operator>>(QDataStream &, QPoint &); + + + + + + +inline QPoint::QPoint() +{ xp=0; yp=0; } + +inline QPoint::QPoint(int xpos, int ypos) +{ xp = xpos; yp = ypos; } + +inline bool QPoint::isNull() const +{ return xp == 0 && yp == 0; } + +inline int QPoint::x() const +{ return xp; } + +inline int QPoint::y() const +{ return yp; } + +inline void QPoint::setX(int xpos) +{ xp = xpos; } + +inline void QPoint::setY(int ypos) +{ yp = ypos; } + +inline int &QPoint::rx() +{ return xp; } + +inline int &QPoint::ry() +{ return yp; } + +inline QPoint &QPoint::operator+=(const QPoint &p) +{ xp+=p.xp; yp+=p.yp; return *this; } + +inline QPoint &QPoint::operator-=(const QPoint &p) +{ xp-=p.xp; yp-=p.yp; return *this; } + +inline QPoint &QPoint::operator*=(float c) +{ xp = qRound(xp*c); yp = qRound(yp*c); return *this; } + +inline QPoint &QPoint::operator*=(double c) +{ xp = qRound(xp*c); yp = qRound(yp*c); return *this; } + +inline QPoint &QPoint::operator*=(int c) +{ xp = xp*c; yp = yp*c; return *this; } + +inline bool operator==(const QPoint &p1, const QPoint &p2) +{ return p1.xp == p2.xp && p1.yp == p2.yp; } + +inline bool operator!=(const QPoint &p1, const QPoint &p2) +{ return p1.xp != p2.xp || p1.yp != p2.yp; } + +inline const QPoint operator+(const QPoint &p1, const QPoint &p2) +{ return QPoint(p1.xp+p2.xp, p1.yp+p2.yp); } + +inline const QPoint operator-(const QPoint &p1, const QPoint &p2) +{ return QPoint(p1.xp-p2.xp, p1.yp-p2.yp); } + +inline const QPoint operator*(const QPoint &p, float c) +{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); } + +inline const QPoint operator*(const QPoint &p, double c) +{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); } + +inline const QPoint operator*(const QPoint &p, int c) +{ return QPoint(p.xp*c, p.yp*c); } + +inline const QPoint operator*(float c, const QPoint &p) +{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); } + +inline const QPoint operator*(double c, const QPoint &p) +{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); } + +inline const QPoint operator*(int c, const QPoint &p) +{ return QPoint(p.xp*c, p.yp*c); } + +inline const QPoint operator-(const QPoint &p) +{ return QPoint(-p.xp, -p.yp); } + +inline QPoint &QPoint::operator/=(qreal c) +{ + xp = qRound(xp/c); + yp = qRound(yp/c); + return *this; +} + +inline const QPoint operator/(const QPoint &p, qreal c) +{ + return QPoint(qRound(p.xp/c), qRound(p.yp/c)); +} + + + QDebug operator<<(QDebug, const QPoint &); + + + + + + +class QPointF +{ +public: + QPointF(); + QPointF(const QPoint &p); + QPointF(qreal xpos, qreal ypos); + + qreal manhattanLength() const; + + bool isNull() const; + + qreal x() const; + qreal y() const; + void setX(qreal x); + void setY(qreal y); + + qreal &rx(); + qreal &ry(); + + QPointF &operator+=(const QPointF &p); + QPointF &operator-=(const QPointF &p); + QPointF &operator*=(qreal c); + QPointF &operator/=(qreal c); + + friend inline bool operator==(const QPointF &, const QPointF &); + friend inline bool operator!=(const QPointF &, const QPointF &); + friend inline const QPointF operator+(const QPointF &, const QPointF &); + friend inline const QPointF operator-(const QPointF &, const QPointF &); + friend inline const QPointF operator*(qreal, const QPointF &); + friend inline const QPointF operator*(const QPointF &, qreal); + friend inline const QPointF operator-(const QPointF &); + friend inline const QPointF operator/(const QPointF &, qreal); + + QPoint toPoint() const; + +private: + friend class QMatrix; + friend class QTransform; + + qreal xp; + qreal yp; +}; + +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPointF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPointF"; } }; + + + + + + QDataStream &operator<<(QDataStream &, const QPointF &); + QDataStream &operator>>(QDataStream &, QPointF &); + + + + + + +inline QPointF::QPointF() : xp(0), yp(0) { } + +inline QPointF::QPointF(qreal xpos, qreal ypos) : xp(xpos), yp(ypos) { } + +inline QPointF::QPointF(const QPoint &p) : xp(p.x()), yp(p.y()) { } + +inline bool QPointF::isNull() const +{ + return qIsNull(xp) && qIsNull(yp); +} + +inline qreal QPointF::x() const +{ + return xp; +} + +inline qreal QPointF::y() const +{ + return yp; +} + +inline void QPointF::setX(qreal xpos) +{ + xp = xpos; +} + +inline void QPointF::setY(qreal ypos) +{ + yp = ypos; +} + +inline qreal &QPointF::rx() +{ + return xp; +} + +inline qreal &QPointF::ry() +{ + return yp; +} + +inline QPointF &QPointF::operator+=(const QPointF &p) +{ + xp+=p.xp; + yp+=p.yp; + return *this; +} + +inline QPointF &QPointF::operator-=(const QPointF &p) +{ + xp-=p.xp; yp-=p.yp; return *this; +} + +inline QPointF &QPointF::operator*=(qreal c) +{ + xp*=c; yp*=c; return *this; +} + +inline bool operator==(const QPointF &p1, const QPointF &p2) +{ + return qFuzzyIsNull(p1.xp - p2.xp) && qFuzzyIsNull(p1.yp - p2.yp); +} + +inline bool operator!=(const QPointF &p1, const QPointF &p2) +{ + return !qFuzzyIsNull(p1.xp - p2.xp) || !qFuzzyIsNull(p1.yp - p2.yp); +} + +inline const QPointF operator+(const QPointF &p1, const QPointF &p2) +{ + return QPointF(p1.xp+p2.xp, p1.yp+p2.yp); +} + +inline const QPointF operator-(const QPointF &p1, const QPointF &p2) +{ + return QPointF(p1.xp-p2.xp, p1.yp-p2.yp); +} + +inline const QPointF operator*(const QPointF &p, qreal c) +{ + return QPointF(p.xp*c, p.yp*c); +} + +inline const QPointF operator*(qreal c, const QPointF &p) +{ + return QPointF(p.xp*c, p.yp*c); +} + +inline const QPointF operator-(const QPointF &p) +{ + return QPointF(-p.xp, -p.yp); +} + +inline QPointF &QPointF::operator/=(qreal c) +{ + xp/=c; + yp/=c; + return *this; +} + +inline const QPointF operator/(const QPointF &p, qreal c) +{ + return QPointF(p.xp/c, p.yp/c); +} + +inline QPoint QPointF::toPoint() const +{ + return QPoint(qRound(xp), qRound(yp)); +} + + + QDebug operator<<(QDebug d, const QPointF &p); + + + + + +# 48 "/usr/include/qt4/QtGui/qapplication.h" 2 3 4 +# 1 "/usr/include/qt4/QtCore/qsize.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qsize.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QSize +{ +public: + QSize(); + QSize(int w, int h); + + bool isNull() const; + bool isEmpty() const; + bool isValid() const; + + int width() const; + int height() const; + void setWidth(int w); + void setHeight(int h); + void transpose(); + + void scale(int w, int h, Qt::AspectRatioMode mode); + void scale(const QSize &s, Qt::AspectRatioMode mode); + + QSize expandedTo(const QSize &) const; + QSize boundedTo(const QSize &) const; + + int &rwidth(); + int &rheight(); + + QSize &operator+=(const QSize &); + QSize &operator-=(const QSize &); + QSize &operator*=(qreal c); + QSize &operator/=(qreal c); + + friend inline bool operator==(const QSize &, const QSize &); + friend inline bool operator!=(const QSize &, const QSize &); + friend inline const QSize operator+(const QSize &, const QSize &); + friend inline const QSize operator-(const QSize &, const QSize &); + friend inline const QSize operator*(const QSize &, qreal); + friend inline const QSize operator*(qreal, const QSize &); + friend inline const QSize operator/(const QSize &, qreal); + +private: + int wd; + int ht; +}; +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSize)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSize"; } }; + + + + + + + QDataStream &operator<<(QDataStream &, const QSize &); + QDataStream &operator>>(QDataStream &, QSize &); + + + + + + + +inline QSize::QSize() +{ wd = ht = -1; } + +inline QSize::QSize(int w, int h) +{ wd = w; ht = h; } + +inline bool QSize::isNull() const +{ return wd==0 && ht==0; } + +inline bool QSize::isEmpty() const +{ return wd<1 || ht<1; } + +inline bool QSize::isValid() const +{ return wd>=0 && ht>=0; } + +inline int QSize::width() const +{ return wd; } + +inline int QSize::height() const +{ return ht; } + +inline void QSize::setWidth(int w) +{ wd = w; } + +inline void QSize::setHeight(int h) +{ ht = h; } + +inline void QSize::scale(int w, int h, Qt::AspectRatioMode mode) +{ scale(QSize(w, h), mode); } + +inline int &QSize::rwidth() +{ return wd; } + +inline int &QSize::rheight() +{ return ht; } + +inline QSize &QSize::operator+=(const QSize &s) +{ wd+=s.wd; ht+=s.ht; return *this; } + +inline QSize &QSize::operator-=(const QSize &s) +{ wd-=s.wd; ht-=s.ht; return *this; } + +inline QSize &QSize::operator*=(qreal c) +{ wd = qRound(wd*c); ht = qRound(ht*c); return *this; } + +inline bool operator==(const QSize &s1, const QSize &s2) +{ return s1.wd == s2.wd && s1.ht == s2.ht; } + +inline bool operator!=(const QSize &s1, const QSize &s2) +{ return s1.wd != s2.wd || s1.ht != s2.ht; } + +inline const QSize operator+(const QSize & s1, const QSize & s2) +{ return QSize(s1.wd+s2.wd, s1.ht+s2.ht); } + +inline const QSize operator-(const QSize &s1, const QSize &s2) +{ return QSize(s1.wd-s2.wd, s1.ht-s2.ht); } + +inline const QSize operator*(const QSize &s, qreal c) +{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); } + +inline const QSize operator*(qreal c, const QSize &s) +{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); } + +inline QSize &QSize::operator/=(qreal c) +{ + qt_noop(); + wd = qRound(wd/c); ht = qRound(ht/c); + return *this; +} + +inline const QSize operator/(const QSize &s, qreal c) +{ + qt_noop(); + return QSize(qRound(s.wd/c), qRound(s.ht/c)); +} + +inline QSize QSize::expandedTo(const QSize & otherSize) const +{ + return QSize(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht)); +} + +inline QSize QSize::boundedTo(const QSize & otherSize) const +{ + return QSize(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht)); +} + + + QDebug operator<<(QDebug, const QSize &); + + + +class QSizeF +{ +public: + QSizeF(); + QSizeF(const QSize &sz); + QSizeF(qreal w, qreal h); + + bool isNull() const; + bool isEmpty() const; + bool isValid() const; + + qreal width() const; + qreal height() const; + void setWidth(qreal w); + void setHeight(qreal h); + void transpose(); + + void scale(qreal w, qreal h, Qt::AspectRatioMode mode); + void scale(const QSizeF &s, Qt::AspectRatioMode mode); + + QSizeF expandedTo(const QSizeF &) const; + QSizeF boundedTo(const QSizeF &) const; + + qreal &rwidth(); + qreal &rheight(); + + QSizeF &operator+=(const QSizeF &); + QSizeF &operator-=(const QSizeF &); + QSizeF &operator*=(qreal c); + QSizeF &operator/=(qreal c); + + friend inline bool operator==(const QSizeF &, const QSizeF &); + friend inline bool operator!=(const QSizeF &, const QSizeF &); + friend inline const QSizeF operator+(const QSizeF &, const QSizeF &); + friend inline const QSizeF operator-(const QSizeF &, const QSizeF &); + friend inline const QSizeF operator*(const QSizeF &, qreal); + friend inline const QSizeF operator*(qreal, const QSizeF &); + friend inline const QSizeF operator/(const QSizeF &, qreal); + + inline QSize toSize() const; + +private: + qreal wd; + qreal ht; +}; +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSizeF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSizeF"; } }; + + + + + + + + QDataStream &operator<<(QDataStream &, const QSizeF &); + QDataStream &operator>>(QDataStream &, QSizeF &); + + + + + + + +inline QSizeF::QSizeF() +{ wd = ht = -1.; } + +inline QSizeF::QSizeF(const QSize &sz) + : wd(sz.width()), ht(sz.height()) +{ +} + +inline QSizeF::QSizeF(qreal w, qreal h) +{ wd = w; ht = h; } + +inline bool QSizeF::isNull() const +{ return qIsNull(wd) && qIsNull(ht); } + +inline bool QSizeF::isEmpty() const +{ return wd <= 0. || ht <= 0.; } + +inline bool QSizeF::isValid() const +{ return wd >= 0. && ht >= 0.; } + +inline qreal QSizeF::width() const +{ return wd; } + +inline qreal QSizeF::height() const +{ return ht; } + +inline void QSizeF::setWidth(qreal w) +{ wd = w; } + +inline void QSizeF::setHeight(qreal h) +{ ht = h; } + +inline void QSizeF::scale(qreal w, qreal h, Qt::AspectRatioMode mode) +{ scale(QSizeF(w, h), mode); } + +inline qreal &QSizeF::rwidth() +{ return wd; } + +inline qreal &QSizeF::rheight() +{ return ht; } + +inline QSizeF &QSizeF::operator+=(const QSizeF &s) +{ wd += s.wd; ht += s.ht; return *this; } + +inline QSizeF &QSizeF::operator-=(const QSizeF &s) +{ wd -= s.wd; ht -= s.ht; return *this; } + +inline QSizeF &QSizeF::operator*=(qreal c) +{ wd *= c; ht *= c; return *this; } + +inline bool operator==(const QSizeF &s1, const QSizeF &s2) +{ return qFuzzyCompare(s1.wd, s2.wd) && qFuzzyCompare(s1.ht, s2.ht); } + +inline bool operator!=(const QSizeF &s1, const QSizeF &s2) +{ return !qFuzzyCompare(s1.wd, s2.wd) || !qFuzzyCompare(s1.ht, s2.ht); } + +inline const QSizeF operator+(const QSizeF & s1, const QSizeF & s2) +{ return QSizeF(s1.wd+s2.wd, s1.ht+s2.ht); } + +inline const QSizeF operator-(const QSizeF &s1, const QSizeF &s2) +{ return QSizeF(s1.wd-s2.wd, s1.ht-s2.ht); } + +inline const QSizeF operator*(const QSizeF &s, qreal c) +{ return QSizeF(s.wd*c, s.ht*c); } + +inline const QSizeF operator*(qreal c, const QSizeF &s) +{ return QSizeF(s.wd*c, s.ht*c); } + +inline QSizeF &QSizeF::operator/=(qreal c) +{ + qt_noop(); + wd = wd/c; ht = ht/c; + return *this; +} + +inline const QSizeF operator/(const QSizeF &s, qreal c) +{ + qt_noop(); + return QSizeF(s.wd/c, s.ht/c); +} + +inline QSizeF QSizeF::expandedTo(const QSizeF & otherSize) const +{ + return QSizeF(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht)); +} + +inline QSizeF QSizeF::boundedTo(const QSizeF & otherSize) const +{ + return QSizeF(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht)); +} + +inline QSize QSizeF::toSize() const +{ + return QSize(qRound(wd), qRound(ht)); +} + + + QDebug operator<<(QDebug, const QSizeF &); + + + + + +# 49 "/usr/include/qt4/QtGui/qapplication.h" 2 3 4 +# 1 "/usr/include/qt4/QtGui/qcursor.h" 1 3 4 +# 48 "/usr/include/qt4/QtGui/qcursor.h" 3 4 + + + + +typedef QtValidLicenseForGuiModule QtGuiModule; + +class QVariant; +# 75 "/usr/include/qt4/QtGui/qcursor.h" 3 4 +class QCursorData; +class QBitmap; +class QPixmap; +# 89 "/usr/include/qt4/QtGui/qcursor.h" 3 4 +class QCursor +{ +public: + QCursor(); + QCursor(Qt::CursorShape shape); + QCursor(const QBitmap &bitmap, const QBitmap &mask, int hotX=-1, int hotY=-1); + QCursor(const QPixmap &pixmap, int hotX=-1, int hotY=-1); + QCursor(const QCursor &cursor); + ~QCursor(); + QCursor &operator=(const QCursor &cursor); + + + + + operator QVariant() const; + + Qt::CursorShape shape() const; + void setShape(Qt::CursorShape newShape); + + const QBitmap *bitmap() const; + const QBitmap *mask() const; + QPixmap pixmap() const; + QPoint hotSpot() const; + + static QPoint pos(); + static void setPos(int x, int y); + inline static void setPos(const QPoint &p) { setPos(p.x(), p.y()); } +# 128 "/usr/include/qt4/QtGui/qcursor.h" 3 4 + Qt::HANDLE handle() const; + QCursor(Qt::HANDLE cursor); + static int x11Screen(); +# 140 "/usr/include/qt4/QtGui/qcursor.h" 3 4 +private: + QCursorData *d; +# 153 "/usr/include/qt4/QtGui/qcursor.h" 3 4 +}; +# 171 "/usr/include/qt4/QtGui/qcursor.h" 3 4 + QDataStream &operator<<(QDataStream &outS, const QCursor &cursor); + QDataStream &operator>>(QDataStream &inS, QCursor &cursor); + + + + + + +# 50 "/usr/include/qt4/QtGui/qapplication.h" 2 3 4 +# 62 "/usr/include/qt4/QtGui/qapplication.h" 3 4 + + + + + + + + +typedef QtValidLicenseForGuiModule QtGuiModule; + +class QSessionManager; +class QDesktopWidget; +class QStyle; +class QEventLoop; +class QIcon; + +class QInputContext; + +template class QList; +class QLocale; +# 91 "/usr/include/qt4/QtGui/qapplication.h" 3 4 +class QApplication; +class QApplicationPrivate; + + + + + + +class QApplication : public QCoreApplication +{ + public: template inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); + + + + + + + + + + + + + + + + + + + + +public: + enum Type { Tty, GuiClient, GuiServer }; + + + + + + + QApplication(int &argc, char **argv, int = ApplicationFlags); + QApplication(int &argc, char **argv, bool GUIenabled, int = ApplicationFlags); + QApplication(int &argc, char **argv, Type, int = ApplicationFlags); + + QApplication(Display* dpy, Qt::HANDLE visual = 0, Qt::HANDLE cmap = 0, int = ApplicationFlags); + QApplication(Display *dpy, int &argc, char **argv, Qt::HANDLE visual = 0, Qt::HANDLE cmap= 0, int = ApplicationFlags); + + + + + + virtual ~QApplication(); + + static Type type(); + + static QStyle *style(); + static void setStyle(QStyle*); + static QStyle *setStyle(const QString&); + enum ColorSpec { NormalColor=0, CustomColor=1, ManyColor=2 }; + static int colorSpec(); + static void setColorSpec(int); + static void setGraphicsSystem(const QString &); + + + static QCursor *overrideCursor(); + static void setOverrideCursor(const QCursor &); + static void changeOverrideCursor(const QCursor &); + static void restoreOverrideCursor(); + + static QPalette palette(); + static QPalette palette(const QWidget *); + static QPalette palette(const char *className); + static void setPalette(const QPalette &, const char* className = 0); + static QFont font(); + static QFont font(const QWidget*); + static QFont font(const char *className); + static void setFont(const QFont &, const char* className = 0); + static QFontMetrics fontMetrics(); + + static void setWindowIcon(const QIcon &icon); + static QIcon windowIcon(); + + + + + + + + static QWidgetList allWidgets(); + static QWidgetList topLevelWidgets(); + + static QDesktopWidget *desktop(); + + static QWidget *activePopupWidget(); + static QWidget *activeModalWidget(); + + static QClipboard *clipboard(); + + static QWidget *focusWidget(); + + static QWidget *activeWindow(); + static void setActiveWindow(QWidget* act); + + static QWidget *widgetAt(const QPoint &p); + static inline QWidget *widgetAt(int x, int y) { return widgetAt(QPoint(x, y)); } + static QWidget *topLevelAt(const QPoint &p); + static inline QWidget *topLevelAt(int x, int y) { return topLevelAt(QPoint(x, y)); } + + static void syncX(); + static void beep(); + static void alert(QWidget *widget, int duration = 0); + + static Qt::KeyboardModifiers keyboardModifiers(); + static Qt::KeyboardModifiers queryKeyboardModifiers(); + static Qt::MouseButtons mouseButtons(); + + static void setDesktopSettingsAware(bool); + static bool desktopSettingsAware(); + + static void setCursorFlashTime(int); + static int cursorFlashTime(); + + static void setDoubleClickInterval(int); + static int doubleClickInterval(); + + static void setKeyboardInputInterval(int); + static int keyboardInputInterval(); + + + static void setWheelScrollLines(int); + static int wheelScrollLines(); + + static void setGlobalStrut(const QSize &); + static QSize globalStrut(); + + static void setStartDragTime(int ms); + static int startDragTime(); + static void setStartDragDistance(int l); + static int startDragDistance(); + + static void setLayoutDirection(Qt::LayoutDirection direction); + static Qt::LayoutDirection layoutDirection(); + + static inline bool isRightToLeft() { return layoutDirection() == Qt::RightToLeft; } + static inline bool isLeftToRight() { return layoutDirection() == Qt::LeftToRight; } + + static bool isEffectEnabled(Qt::UIEffect); + static void setEffectEnabled(Qt::UIEffect, bool enable = true); + + + + + + virtual bool x11EventFilter(XEvent *); + virtual int x11ClientMessage(QWidget*, XEvent*, bool passive_only); + int x11ProcessEvent(XEvent*); +# 273 "/usr/include/qt4/QtGui/qapplication.h" 3 4 + bool isSessionRestored() const; + QString sessionId() const; + QString sessionKey() const; + virtual void commitData(QSessionManager& sm); + virtual void saveState(QSessionManager& sm); + + + + void setInputContext(QInputContext *); + QInputContext *inputContext() const; + + + static QLocale keyboardInputLocale(); + static Qt::LayoutDirection keyboardInputDirection(); + + static int exec(); + bool notify(QObject *, QEvent *); + + + static void setQuitOnLastWindowClosed(bool quit); + static bool quitOnLastWindowClosed(); +# 302 "/usr/include/qt4/QtGui/qapplication.h" 3 4 +protected: + void lastWindowClosed(); + void focusChanged(QWidget *old, QWidget *now); + void fontDatabaseChanged(); + + void commitDataRequest(QSessionManager &sessionManager); + void saveStateRequest(QSessionManager &sessionManager); + + + + + + +public: + QString styleSheet() const; +public : + + void setStyleSheet(const QString& sheet); + + + + + + void setAutoSipEnabled(const bool enabled); + bool autoSipEnabled() const; + static void closeAllWindows(); + static void aboutQt(); + +protected: + + + + bool event(QEvent *); + bool compressEvent(QEvent *, QObject *receiver, QPostEventList *); +# 390 "/usr/include/qt4/QtGui/qapplication.h" 3 4 +private: + QApplication(const QApplication &); QApplication &operator=(const QApplication &); + inline QApplicationPrivate* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); } inline const QApplicationPrivate* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); } friend class QApplicationPrivate; + + friend class QGraphicsWidget; + friend class QGraphicsItem; + friend class QGraphicsScene; + friend class QGraphicsScenePrivate; + friend class QWidget; + friend class QWidgetPrivate; + friend class QETWidget; + friend class Q3AccelManager; + friend class QTranslator; + friend class QWidgetAnimator; + + friend class QShortcut; + friend class QLineEdit; + friend class QTextControl; + + friend class QAction; + friend class QFontDatabasePrivate; +# 419 "/usr/include/qt4/QtGui/qapplication.h" 3 4 + friend class QGestureManager; + + + + + + + + + + + +}; + + + + +# 1 "/usr/include/qt4/QtGui/QApplication" 2 3 4 +# 2 "../test.cpp" 2 +# 1 "/usr/include/qt4/QtGui/QKeyEvent" 1 3 4 +# 1 "/usr/include/qt4/QtGui/qevent.h" 1 3 4 +# 47 "/usr/include/qt4/QtGui/qevent.h" 3 4 +# 1 "/usr/include/qt4/QtGui/qregion.h" 1 3 4 +# 46 "/usr/include/qt4/QtGui/qregion.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qrect.h" 1 3 4 +# 52 "/usr/include/qt4/QtCore/qrect.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QRect +{ +public: + QRect() { x1 = y1 = 0; x2 = y2 = -1; } + QRect(const QPoint &topleft, const QPoint &bottomright); + QRect(const QPoint &topleft, const QSize &size); + QRect(int left, int top, int width, int height); + + bool isNull() const; + bool isEmpty() const; + bool isValid() const; + + int left() const; + int top() const; + int right() const; + int bottom() const; + QRect normalized() const; +# 85 "/usr/include/qt4/QtCore/qrect.h" 3 4 + int x() const; + int y() const; + void setLeft(int pos); + void setTop(int pos); + void setRight(int pos); + void setBottom(int pos); + void setX(int x); + void setY(int y); + + void setTopLeft(const QPoint &p); + void setBottomRight(const QPoint &p); + void setTopRight(const QPoint &p); + void setBottomLeft(const QPoint &p); + + QPoint topLeft() const; + QPoint bottomRight() const; + QPoint topRight() const; + QPoint bottomLeft() const; + QPoint center() const; + + void moveLeft(int pos); + void moveTop(int pos); + void moveRight(int pos); + void moveBottom(int pos); + void moveTopLeft(const QPoint &p); + void moveBottomRight(const QPoint &p); + void moveTopRight(const QPoint &p); + void moveBottomLeft(const QPoint &p); + void moveCenter(const QPoint &p); + + inline void translate(int dx, int dy); + inline void translate(const QPoint &p); + inline QRect translated(int dx, int dy) const; + inline QRect translated(const QPoint &p) const; + + void moveTo(int x, int t); + void moveTo(const QPoint &p); + + + + + + + void setRect(int x, int y, int w, int h); + inline void getRect(int *x, int *y, int *w, int *h) const; + + void setCoords(int x1, int y1, int x2, int y2); + + + + inline void getCoords(int *x1, int *y1, int *x2, int *y2) const; + + inline void adjust(int x1, int y1, int x2, int y2); + inline QRect adjusted(int x1, int y1, int x2, int y2) const; + + QSize size() const; + int width() const; + int height() const; + void setWidth(int w); + void setHeight(int h); + void setSize(const QSize &s); + + QRect operator|(const QRect &r) const; + QRect operator&(const QRect &r) const; + QRect& operator|=(const QRect &r); + QRect& operator&=(const QRect &r); + + bool contains(const QPoint &p, bool proper=false) const; + bool contains(int x, int y) const; + bool contains(int x, int y, bool proper) const; + bool contains(const QRect &r, bool proper = false) const; + QRect unite(const QRect &r) const; + QRect united(const QRect &other) const; + QRect intersect(const QRect &r) const; + QRect intersected(const QRect &other) const; + bool intersects(const QRect &r) const; + + friend inline bool operator==(const QRect &, const QRect &); + friend inline bool operator!=(const QRect &, const QRect &); + + + + + + + +private: + + friend void qt_setCoords(QRect *r, int xp1, int yp1, int xp2, int yp2); +# 182 "/usr/include/qt4/QtCore/qrect.h" 3 4 + int x1; + int y1; + int x2; + int y2; + + +}; +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRect)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRect"; } }; + + inline bool operator==(const QRect &, const QRect &); + inline bool operator!=(const QRect &, const QRect &); + + + + + + + QDataStream &operator<<(QDataStream &, const QRect &); + QDataStream &operator>>(QDataStream &, QRect &); + + + + + + +inline QRect::QRect(int aleft, int atop, int awidth, int aheight) +{ + x1 = aleft; + y1 = atop; + x2 = (aleft + awidth - 1); + y2 = (atop + aheight - 1); +} + +inline QRect::QRect(const QPoint &atopLeft, const QPoint &abottomRight) +{ + x1 = atopLeft.x(); + y1 = atopLeft.y(); + x2 = abottomRight.x(); + y2 = abottomRight.y(); +} + +inline QRect::QRect(const QPoint &atopLeft, const QSize &asize) +{ + x1 = atopLeft.x(); + y1 = atopLeft.y(); + x2 = (x1+asize.width() - 1); + y2 = (y1+asize.height() - 1); +} + +inline bool QRect::isNull() const +{ return x2 == x1 - 1 && y2 == y1 - 1; } + +inline bool QRect::isEmpty() const +{ return x1 > x2 || y1 > y2; } + +inline bool QRect::isValid() const +{ return x1 <= x2 && y1 <= y2; } + +inline int QRect::left() const +{ return x1; } + +inline int QRect::top() const +{ return y1; } + +inline int QRect::right() const +{ return x2; } + +inline int QRect::bottom() const +{ return y2; } + +inline int QRect::x() const +{ return x1; } + +inline int QRect::y() const +{ return y1; } + +inline void QRect::setLeft(int pos) +{ x1 = pos; } + +inline void QRect::setTop(int pos) +{ y1 = pos; } + +inline void QRect::setRight(int pos) +{ x2 = pos; } + +inline void QRect::setBottom(int pos) +{ y2 = pos; } + +inline void QRect::setTopLeft(const QPoint &p) +{ x1 = p.x(); y1 = p.y(); } + +inline void QRect::setBottomRight(const QPoint &p) +{ x2 = p.x(); y2 = p.y(); } + +inline void QRect::setTopRight(const QPoint &p) +{ x2 = p.x(); y1 = p.y(); } + +inline void QRect::setBottomLeft(const QPoint &p) +{ x1 = p.x(); y2 = p.y(); } + +inline void QRect::setX(int ax) +{ x1 = ax; } + +inline void QRect::setY(int ay) +{ y1 = ay; } + +inline QPoint QRect::topLeft() const +{ return QPoint(x1, y1); } + +inline QPoint QRect::bottomRight() const +{ return QPoint(x2, y2); } + +inline QPoint QRect::topRight() const +{ return QPoint(x2, y1); } + +inline QPoint QRect::bottomLeft() const +{ return QPoint(x1, y2); } + +inline QPoint QRect::center() const +{ return QPoint((x1+x2)/2, (y1+y2)/2); } + +inline int QRect::width() const +{ return x2 - x1 + 1; } + +inline int QRect::height() const +{ return y2 - y1 + 1; } + +inline QSize QRect::size() const +{ return QSize(width(), height()); } + +inline void QRect::translate(int dx, int dy) +{ + x1 += dx; + y1 += dy; + x2 += dx; + y2 += dy; +} + +inline void QRect::translate(const QPoint &p) +{ + x1 += p.x(); + y1 += p.y(); + x2 += p.x(); + y2 += p.y(); +} + +inline QRect QRect::translated(int dx, int dy) const +{ return QRect(QPoint(x1 + dx, y1 + dy), QPoint(x2 + dx, y2 + dy)); } + +inline QRect QRect::translated(const QPoint &p) const +{ return QRect(QPoint(x1 + p.x(), y1 + p.y()), QPoint(x2 + p.x(), y2 + p.y())); } + +inline void QRect::moveTo(int ax, int ay) +{ + x2 += ax - x1; + y2 += ay - y1; + x1 = ax; + y1 = ay; +} + +inline void QRect::moveTo(const QPoint &p) +{ + x2 += p.x() - x1; + y2 += p.y() - y1; + x1 = p.x(); + y1 = p.y(); +} + +inline void QRect::moveLeft(int pos) +{ x2 += (pos - x1); x1 = pos; } + +inline void QRect::moveTop(int pos) +{ y2 += (pos - y1); y1 = pos; } + +inline void QRect::moveRight(int pos) +{ + x1 += (pos - x2); + x2 = pos; +} + +inline void QRect::moveBottom(int pos) +{ + y1 += (pos - y2); + y2 = pos; +} + +inline void QRect::moveTopLeft(const QPoint &p) +{ + moveLeft(p.x()); + moveTop(p.y()); +} + +inline void QRect::moveBottomRight(const QPoint &p) +{ + moveRight(p.x()); + moveBottom(p.y()); +} + +inline void QRect::moveTopRight(const QPoint &p) +{ + moveRight(p.x()); + moveTop(p.y()); +} + +inline void QRect::moveBottomLeft(const QPoint &p) +{ + moveLeft(p.x()); + moveBottom(p.y()); +} + +inline void QRect::getRect(int *ax, int *ay, int *aw, int *ah) const +{ + *ax = x1; + *ay = y1; + *aw = x2 - x1 + 1; + *ah = y2 - y1 + 1; +} + +inline void QRect::setRect(int ax, int ay, int aw, int ah) +{ + x1 = ax; + y1 = ay; + x2 = (ax + aw - 1); + y2 = (ay + ah - 1); +} + +inline void QRect::getCoords(int *xp1, int *yp1, int *xp2, int *yp2) const +{ + *xp1 = x1; + *yp1 = y1; + *xp2 = x2; + *yp2 = y2; +} + +inline void QRect::setCoords(int xp1, int yp1, int xp2, int yp2) +{ + x1 = xp1; + y1 = yp1; + x2 = xp2; + y2 = yp2; +} +# 431 "/usr/include/qt4/QtCore/qrect.h" 3 4 +inline QRect QRect::adjusted(int xp1, int yp1, int xp2, int yp2) const +{ return QRect(QPoint(x1 + xp1, y1 + yp1), QPoint(x2 + xp2, y2 + yp2)); } + +inline void QRect::adjust(int dx1, int dy1, int dx2, int dy2) +{ + x1 += dx1; + y1 += dy1; + x2 += dx2; + y2 += dy2; +} + +inline void QRect::setWidth(int w) +{ x2 = (x1 + w - 1); } + +inline void QRect::setHeight(int h) +{ y2 = (y1 + h - 1); } + +inline void QRect::setSize(const QSize &s) +{ + x2 = (s.width() + x1 - 1); + y2 = (s.height() + y1 - 1); +} + +inline bool QRect::contains(int ax, int ay, bool aproper) const +{ + return contains(QPoint(ax, ay), aproper); +} + +inline bool QRect::contains(int ax, int ay) const +{ + return contains(QPoint(ax, ay), false); +} + +inline QRect& QRect::operator|=(const QRect &r) +{ + *this = *this | r; + return *this; +} + +inline QRect& QRect::operator&=(const QRect &r) +{ + *this = *this & r; + return *this; +} + +inline QRect QRect::intersect(const QRect &r) const +{ + return *this & r; +} + +inline QRect QRect::intersected(const QRect &other) const +{ + return intersect(other); +} + +inline QRect QRect::unite(const QRect &r) const +{ + return *this | r; +} + +inline QRect QRect::united(const QRect &r) const +{ + return unite(r); +} + +inline bool operator==(const QRect &r1, const QRect &r2) +{ + return r1.x1==r2.x1 && r1.x2==r2.x2 && r1.y1==r2.y1 && r1.y2==r2.y2; +} + +inline bool operator!=(const QRect &r1, const QRect &r2) +{ + return r1.x1!=r2.x1 || r1.x2!=r2.x2 || r1.y1!=r2.y1 || r1.y2!=r2.y2; +} + + + QDebug operator<<(QDebug, const QRect &); + + + +class QRectF +{ +public: + QRectF() { xp = yp = 0.; w = h = 0.; } + QRectF(const QPointF &topleft, const QSizeF &size); + QRectF(const QPointF &topleft, const QPointF &bottomRight); + QRectF(qreal left, qreal top, qreal width, qreal height); + QRectF(const QRect &rect); + + bool isNull() const; + bool isEmpty() const; + bool isValid() const; + QRectF normalized() const; + + inline qreal left() const { return xp; } + inline qreal top() const { return yp; } + inline qreal right() const { return xp + w; } + inline qreal bottom() const { return yp + h; } + + inline qreal x() const; + inline qreal y() const; + inline void setLeft(qreal pos); + inline void setTop(qreal pos); + inline void setRight(qreal pos); + inline void setBottom(qreal pos); + inline void setX(qreal pos) { setLeft(pos); } + inline void setY(qreal pos) { setTop(pos); } + + inline QPointF topLeft() const { return QPointF(xp, yp); } + inline QPointF bottomRight() const { return QPointF(xp+w, yp+h); } + inline QPointF topRight() const { return QPointF(xp+w, yp); } + inline QPointF bottomLeft() const { return QPointF(xp, yp+h); } + inline QPointF center() const; + + void setTopLeft(const QPointF &p); + void setBottomRight(const QPointF &p); + void setTopRight(const QPointF &p); + void setBottomLeft(const QPointF &p); + + void moveLeft(qreal pos); + void moveTop(qreal pos); + void moveRight(qreal pos); + void moveBottom(qreal pos); + void moveTopLeft(const QPointF &p); + void moveBottomRight(const QPointF &p); + void moveTopRight(const QPointF &p); + void moveBottomLeft(const QPointF &p); + void moveCenter(const QPointF &p); + + void translate(qreal dx, qreal dy); + void translate(const QPointF &p); + + QRectF translated(qreal dx, qreal dy) const; + QRectF translated(const QPointF &p) const; + + void moveTo(qreal x, qreal t); + void moveTo(const QPointF &p); + + void setRect(qreal x, qreal y, qreal w, qreal h); + void getRect(qreal *x, qreal *y, qreal *w, qreal *h) const; + + void setCoords(qreal x1, qreal y1, qreal x2, qreal y2); + void getCoords(qreal *x1, qreal *y1, qreal *x2, qreal *y2) const; + + inline void adjust(qreal x1, qreal y1, qreal x2, qreal y2); + inline QRectF adjusted(qreal x1, qreal y1, qreal x2, qreal y2) const; + + QSizeF size() const; + qreal width() const; + qreal height() const; + void setWidth(qreal w); + void setHeight(qreal h); + void setSize(const QSizeF &s); + + QRectF operator|(const QRectF &r) const; + QRectF operator&(const QRectF &r) const; + QRectF& operator|=(const QRectF &r); + QRectF& operator&=(const QRectF &r); + + bool contains(const QPointF &p) const; + bool contains(qreal x, qreal y) const; + bool contains(const QRectF &r) const; + QRectF unite(const QRectF &r) const; + QRectF united(const QRectF &other) const; + QRectF intersect(const QRectF &r) const; + QRectF intersected(const QRectF &other) const; + bool intersects(const QRectF &r) const; + + friend inline bool operator==(const QRectF &, const QRectF &); + friend inline bool operator!=(const QRectF &, const QRectF &); + + QRect toRect() const; + QRect toAlignedRect() const; + +private: + qreal xp; + qreal yp; + qreal w; + qreal h; +}; +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRectF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRectF"; } }; + + inline bool operator==(const QRectF &, const QRectF &); + inline bool operator!=(const QRectF &, const QRectF &); + + + + + + + QDataStream &operator<<(QDataStream &, const QRectF &); + QDataStream &operator>>(QDataStream &, QRectF &); + + + + + + +inline QRectF::QRectF(qreal aleft, qreal atop, qreal awidth, qreal aheight) + : xp(aleft), yp(atop), w(awidth), h(aheight) +{ +} + +inline QRectF::QRectF(const QPointF &atopLeft, const QSizeF &asize) +{ + xp = atopLeft.x(); + yp = atopLeft.y(); + w = asize.width(); + h = asize.height(); +} + +inline QRectF::QRectF(const QPointF &atopLeft, const QPointF &abottomRight) +{ + xp = atopLeft.x(); + yp = atopLeft.y(); + w = abottomRight.x() - xp; + h = abottomRight.y() - yp; +} + +inline QRectF::QRectF(const QRect &r) + : xp(r.x()), yp(r.y()), w(r.width()), h(r.height()) +{ +} + +inline bool QRectF::isNull() const +{ return w == 0. && h == 0.; } + +inline bool QRectF::isEmpty() const +{ return w <= 0. || h <= 0.; } + +inline bool QRectF::isValid() const +{ return w > 0. && h > 0.; } + +inline qreal QRectF::x() const +{ return xp; } + +inline qreal QRectF::y() const +{ return yp; } + +inline void QRectF::setLeft(qreal pos) { qreal diff = pos - xp; xp += diff; w -= diff; } + +inline void QRectF::setRight(qreal pos) { w = pos - xp; } + +inline void QRectF::setTop(qreal pos) { qreal diff = pos - yp; yp += diff; h -= diff; } + +inline void QRectF::setBottom(qreal pos) { h = pos - yp; } + +inline void QRectF::setTopLeft(const QPointF &p) { setLeft(p.x()); setTop(p.y()); } + +inline void QRectF::setTopRight(const QPointF &p) { setRight(p.x()); setTop(p.y()); } + +inline void QRectF::setBottomLeft(const QPointF &p) { setLeft(p.x()); setBottom(p.y()); } + +inline void QRectF::setBottomRight(const QPointF &p) { setRight(p.x()); setBottom(p.y()); } + +inline QPointF QRectF::center() const +{ return QPointF(xp + w/2, yp + h/2); } + +inline void QRectF::moveLeft(qreal pos) { xp = pos; } + +inline void QRectF::moveTop(qreal pos) { yp = pos; } + +inline void QRectF::moveRight(qreal pos) { xp = pos - w; } + +inline void QRectF::moveBottom(qreal pos) { yp = pos - h; } + +inline void QRectF::moveTopLeft(const QPointF &p) { moveLeft(p.x()); moveTop(p.y()); } + +inline void QRectF::moveTopRight(const QPointF &p) { moveRight(p.x()); moveTop(p.y()); } + +inline void QRectF::moveBottomLeft(const QPointF &p) { moveLeft(p.x()); moveBottom(p.y()); } + +inline void QRectF::moveBottomRight(const QPointF &p) { moveRight(p.x()); moveBottom(p.y()); } + +inline void QRectF::moveCenter(const QPointF &p) { xp = p.x() - w/2; yp = p.y() - h/2; } + +inline qreal QRectF::width() const +{ return w; } + +inline qreal QRectF::height() const +{ return h; } + +inline QSizeF QRectF::size() const +{ return QSizeF(w, h); } + +inline void QRectF::translate(qreal dx, qreal dy) +{ + xp += dx; + yp += dy; +} + +inline void QRectF::translate(const QPointF &p) +{ + xp += p.x(); + yp += p.y(); +} + +inline void QRectF::moveTo(qreal ax, qreal ay) +{ + xp = ax; + yp = ay; +} + +inline void QRectF::moveTo(const QPointF &p) +{ + xp = p.x(); + yp = p.y(); +} + +inline QRectF QRectF::translated(qreal dx, qreal dy) const +{ return QRectF(xp + dx, yp + dy, w, h); } + +inline QRectF QRectF::translated(const QPointF &p) const +{ return QRectF(xp + p.x(), yp + p.y(), w, h); } + +inline void QRectF::getRect(qreal *ax, qreal *ay, qreal *aaw, qreal *aah) const +{ + *ax = this->xp; + *ay = this->yp; + *aaw = this->w; + *aah = this->h; +} + +inline void QRectF::setRect(qreal ax, qreal ay, qreal aaw, qreal aah) +{ + this->xp = ax; + this->yp = ay; + this->w = aaw; + this->h = aah; +} + +inline void QRectF::getCoords(qreal *xp1, qreal *yp1, qreal *xp2, qreal *yp2) const +{ + *xp1 = xp; + *yp1 = yp; + *xp2 = xp + w; + *yp2 = yp + h; +} + +inline void QRectF::setCoords(qreal xp1, qreal yp1, qreal xp2, qreal yp2) +{ + xp = xp1; + yp = yp1; + w = xp2 - xp1; + h = yp2 - yp1; +} + +inline void QRectF::adjust(qreal xp1, qreal yp1, qreal xp2, qreal yp2) +{ xp += xp1; yp += yp1; w += xp2 - xp1; h += yp2 - yp1; } + +inline QRectF QRectF::adjusted(qreal xp1, qreal yp1, qreal xp2, qreal yp2) const +{ return QRectF(xp + xp1, yp + yp1, w + xp2 - xp1, h + yp2 - yp1); } + +inline void QRectF::setWidth(qreal aw) +{ this->w = aw; } + +inline void QRectF::setHeight(qreal ah) +{ this->h = ah; } + +inline void QRectF::setSize(const QSizeF &s) +{ + w = s.width(); + h = s.height(); +} + +inline bool QRectF::contains(qreal ax, qreal ay) const +{ + return contains(QPointF(ax, ay)); +} + +inline QRectF& QRectF::operator|=(const QRectF &r) +{ + *this = *this | r; + return *this; +} + +inline QRectF& QRectF::operator&=(const QRectF &r) +{ + *this = *this & r; + return *this; +} + +inline QRectF QRectF::intersect(const QRectF &r) const +{ + return *this & r; +} + +inline QRectF QRectF::intersected(const QRectF &r) const +{ + return intersect(r); +} + +inline QRectF QRectF::unite(const QRectF &r) const +{ + return *this | r; +} + +inline QRectF QRectF::united(const QRectF &r) const +{ + return unite(r); +} + +inline bool operator==(const QRectF &r1, const QRectF &r2) +{ + return qFuzzyCompare(r1.xp, r2.xp) && qFuzzyCompare(r1.yp, r2.yp) + && qFuzzyCompare(r1.w, r2.w) && qFuzzyCompare(r1.h, r2.h); +} + +inline bool operator!=(const QRectF &r1, const QRectF &r2) +{ + return !qFuzzyCompare(r1.xp, r2.xp) || !qFuzzyCompare(r1.yp, r2.yp) + || !qFuzzyCompare(r1.w, r2.w) || !qFuzzyCompare(r1.h, r2.h); +} + +inline QRect QRectF::toRect() const +{ + return QRect(qRound(xp), qRound(yp), qRound(w), qRound(h)); +} + + + QDebug operator<<(QDebug, const QRectF &); + + + + + +# 47 "/usr/include/qt4/QtGui/qregion.h" 2 3 4 + + + +# 1 "/usr/include/qt4/QtCore/qdatastream.h" 1 3 4 +# 46 "/usr/include/qt4/QtCore/qdatastream.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qiodevice.h" 1 3 4 +# 57 "/usr/include/qt4/QtCore/qiodevice.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QByteArray; +class QIODevicePrivate; + +class QIODevice + + : public QObject + +{ + + public: template inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); + +public: + enum OpenModeFlag { + NotOpen = 0x0000, + ReadOnly = 0x0001, + WriteOnly = 0x0002, + ReadWrite = ReadOnly | WriteOnly, + Append = 0x0004, + Truncate = 0x0008, + Text = 0x0010, + Unbuffered = 0x0020 + }; + typedef QFlags OpenMode; + + QIODevice(); + + explicit QIODevice(QObject *parent); + + virtual ~QIODevice(); + + OpenMode openMode() const; + + void setTextModeEnabled(bool enabled); + bool isTextModeEnabled() const; + + bool isOpen() const; + bool isReadable() const; + bool isWritable() const; + virtual bool isSequential() const; + + virtual bool open(OpenMode mode); + virtual void close(); + + + + virtual qint64 pos() const; + virtual qint64 size() const; + virtual bool seek(qint64 pos); + virtual bool atEnd() const; + virtual bool reset(); + + virtual qint64 bytesAvailable() const; + virtual qint64 bytesToWrite() const; + + qint64 read(char *data, qint64 maxlen); + QByteArray read(qint64 maxlen); + QByteArray readAll(); + qint64 readLine(char *data, qint64 maxlen); + QByteArray readLine(qint64 maxlen = 0); + virtual bool canReadLine() const; + + qint64 write(const char *data, qint64 len); + qint64 write(const char *data); + inline qint64 write(const QByteArray &data) + { return write(data.constData(), data.size()); } + + qint64 peek(char *data, qint64 maxlen); + QByteArray peek(qint64 maxlen); + + virtual bool waitForReadyRead(int msecs); + virtual bool waitForBytesWritten(int msecs); + + void ungetChar(char c); + bool putChar(char c); + bool getChar(char *c); + + QString errorString() const; + + +protected: + void readyRead(); + void bytesWritten(qint64 bytes); + void aboutToClose(); + void readChannelFinished(); + + +protected: + + + + QIODevice(QIODevicePrivate &dd, QObject *parent = 0); + + virtual qint64 readData(char *data, qint64 maxlen) = 0; + virtual qint64 readLineData(char *data, qint64 maxlen); + virtual qint64 writeData(const char *data, qint64 len) = 0; + + void setOpenMode(OpenMode openMode); + + void setErrorString(const QString &errorString); + + + + + +private: + inline QIODevicePrivate* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); } inline const QIODevicePrivate* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); } friend class QIODevicePrivate; + QIODevice(const QIODevice &); QIODevice &operator=(const QIODevice &); +# 204 "/usr/include/qt4/QtCore/qiodevice.h" 3 4 +}; + + inline QFlags operator|(QIODevice::OpenMode::enum_type f1, QIODevice::OpenMode::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(QIODevice::OpenMode::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QIODevice::OpenMode::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } +# 246 "/usr/include/qt4/QtCore/qiodevice.h" 3 4 +class QDebug; + QDebug operator<<(QDebug debug, QIODevice::OpenMode modes); + + + + + +# 47 "/usr/include/qt4/QtCore/qdatastream.h" 2 3 4 + + + + + + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QByteArray; +class QIODevice; + +template class QList; +template class QLinkedList; +template class QVector; +template class QSet; +template class QHash; +template class QMap; + + +class QDataStreamPrivate; +class QDataStream +{ +public: + enum Version { + Qt_1_0 = 1, + Qt_2_0 = 2, + Qt_2_1 = 3, + Qt_3_0 = 4, + Qt_3_1 = 5, + Qt_3_3 = 6, + Qt_4_0 = 7, + Qt_4_1 = Qt_4_0, + Qt_4_2 = 8, + Qt_4_3 = 9, + Qt_4_4 = 10, + Qt_4_5 = 11, + Qt_4_6 = 12, + Qt_4_7 = Qt_4_6, + Qt_4_8 = Qt_4_7 + + + + + }; + + enum ByteOrder { + BigEndian = QSysInfo::BigEndian, + LittleEndian = QSysInfo::LittleEndian + }; + + enum Status { + Ok, + ReadPastEnd, + ReadCorruptData, + WriteFailed + }; + + enum FloatingPointPrecision { + SinglePrecision, + DoublePrecision + }; + + QDataStream(); + explicit QDataStream(QIODevice *); + + + + QDataStream(QByteArray *, QIODevice::OpenMode flags); + QDataStream(const QByteArray &); + virtual ~QDataStream(); + + QIODevice *device() const; + void setDevice(QIODevice *); + void unsetDevice(); + + bool atEnd() const; + + + + + Status status() const; + void setStatus(Status status); + void resetStatus(); + + FloatingPointPrecision floatingPointPrecision() const; + void setFloatingPointPrecision(FloatingPointPrecision precision); + + ByteOrder byteOrder() const; + void setByteOrder(ByteOrder); + + int version() const; + void setVersion(int); + + QDataStream &operator>>(qint8 &i); + QDataStream &operator>>(quint8 &i); + QDataStream &operator>>(qint16 &i); + QDataStream &operator>>(quint16 &i); + QDataStream &operator>>(qint32 &i); + QDataStream &operator>>(quint32 &i); + QDataStream &operator>>(qint64 &i); + QDataStream &operator>>(quint64 &i); + + QDataStream &operator>>(bool &i); + QDataStream &operator>>(float &f); + QDataStream &operator>>(double &f); + QDataStream &operator>>(char *&str); + + QDataStream &operator<<(qint8 i); + QDataStream &operator<<(quint8 i); + QDataStream &operator<<(qint16 i); + QDataStream &operator<<(quint16 i); + QDataStream &operator<<(qint32 i); + QDataStream &operator<<(quint32 i); + QDataStream &operator<<(qint64 i); + QDataStream &operator<<(quint64 i); + QDataStream &operator<<(bool i); + QDataStream &operator<<(float f); + QDataStream &operator<<(double f); + QDataStream &operator<<(const char *str); + + QDataStream &readBytes(char *&, uint &len); + int readRawData(char *, int len); + + QDataStream &writeBytes(const char *, uint len); + int writeRawData(const char *, int len); + + int skipRawData(int len); +# 188 "/usr/include/qt4/QtCore/qdatastream.h" 3 4 +private: + QDataStream(const QDataStream &); QDataStream &operator=(const QDataStream &); + + QScopedPointer d; + + QIODevice *dev; + bool owndev; + bool noswap; + ByteOrder byteorder; + int ver; + Status q_status; +}; + + + + + + +inline QIODevice *QDataStream::device() const +{ return dev; } + +inline QDataStream::ByteOrder QDataStream::byteOrder() const +{ return byteorder; } + +inline int QDataStream::version() const +{ return ver; } + +inline void QDataStream::setVersion(int v) +{ ver = v; } + +inline QDataStream &QDataStream::operator>>(quint8 &i) +{ return *this >> reinterpret_cast(i); } + +inline QDataStream &QDataStream::operator>>(quint16 &i) +{ return *this >> reinterpret_cast(i); } + +inline QDataStream &QDataStream::operator>>(quint32 &i) +{ return *this >> reinterpret_cast(i); } + +inline QDataStream &QDataStream::operator>>(quint64 &i) +{ return *this >> reinterpret_cast(i); } + +inline QDataStream &QDataStream::operator<<(quint8 i) +{ return *this << qint8(i); } + +inline QDataStream &QDataStream::operator<<(quint16 i) +{ return *this << qint16(i); } + +inline QDataStream &QDataStream::operator<<(quint32 i) +{ return *this << qint32(i); } + +inline QDataStream &QDataStream::operator<<(quint64 i) +{ return *this << qint64(i); } + +template +QDataStream& operator>>(QDataStream& s, QList& l) +{ + l.clear(); + quint32 c; + s >> c; + l.reserve(c); + for(quint32 i = 0; i < c; ++i) + { + T t; + s >> t; + l.append(t); + if (s.atEnd()) + break; + } + return s; +} + +template +QDataStream& operator<<(QDataStream& s, const QList& l) +{ + s << quint32(l.size()); + for (int i = 0; i < l.size(); ++i) + s << l.at(i); + return s; +} + +template +QDataStream& operator>>(QDataStream& s, QLinkedList& l) +{ + l.clear(); + quint32 c; + s >> c; + for(quint32 i = 0; i < c; ++i) + { + T t; + s >> t; + l.append(t); + if (s.atEnd()) + break; + } + return s; +} + +template +QDataStream& operator<<(QDataStream& s, const QLinkedList& l) +{ + s << quint32(l.size()); + typename QLinkedList::ConstIterator it = l.constBegin(); + for(; it != l.constEnd(); ++it) + s << *it; + return s; +} + +template +QDataStream& operator>>(QDataStream& s, QVector& v) +{ + v.clear(); + quint32 c; + s >> c; + v.resize(c); + for(quint32 i = 0; i < c; ++i) { + T t; + s >> t; + v[i] = t; + } + return s; +} + +template +QDataStream& operator<<(QDataStream& s, const QVector& v) +{ + s << quint32(v.size()); + for (typename QVector::const_iterator it = v.begin(); it != v.end(); ++it) + s << *it; + return s; +} + +template +QDataStream &operator>>(QDataStream &in, QSet &set) +{ + set.clear(); + quint32 c; + in >> c; + for (quint32 i = 0; i < c; ++i) { + T t; + in >> t; + set << t; + if (in.atEnd()) + break; + } + return in; +} + +template +QDataStream& operator<<(QDataStream &out, const QSet &set) +{ + out << quint32(set.size()); + typename QSet::const_iterator i = set.constBegin(); + while (i != set.constEnd()) { + out << *i; + ++i; + } + return out; +} + +template + QDataStream &operator>>(QDataStream &in, QHash &hash) +{ + QDataStream::Status oldStatus = in.status(); + in.resetStatus(); + hash.clear(); + + quint32 n; + in >> n; + + for (quint32 i = 0; i < n; ++i) { + if (in.status() != QDataStream::Ok) + break; + + Key k; + T t; + in >> k >> t; + hash.insertMulti(k, t); + } + + if (in.status() != QDataStream::Ok) + hash.clear(); + if (oldStatus != QDataStream::Ok) + in.setStatus(oldStatus); + return in; +} + +template + QDataStream &operator<<(QDataStream &out, const QHash& hash) +{ + out << quint32(hash.size()); + typename QHash::ConstIterator it = hash.end(); + typename QHash::ConstIterator begin = hash.begin(); + while (it != begin) { + --it; + out << it.key() << it.value(); + } + return out; +} + + + + +template + QDataStream &operator>>(QDataStream &in, QMap &map) + +{ + QDataStream::Status oldStatus = in.status(); + in.resetStatus(); + map.clear(); + + quint32 n; + in >> n; + + map.detach(); + map.setInsertInOrder(true); + for (quint32 i = 0; i < n; ++i) { + if (in.status() != QDataStream::Ok) + break; + + aKey key; + aT value; + in >> key >> value; + map.insertMulti(key, value); + } + map.setInsertInOrder(false); + if (in.status() != QDataStream::Ok) + map.clear(); + if (oldStatus != QDataStream::Ok) + in.setStatus(oldStatus); + return in; +} + +template + QDataStream &operator<<(QDataStream &out, const QMap &map) +{ + out << quint32(map.size()); + typename QMap::ConstIterator it = map.end(); + typename QMap::ConstIterator begin = map.begin(); + while (it != begin) { + --it; + out << it.key() << it.value(); + } + return out; +} + + + + + + +# 51 "/usr/include/qt4/QtGui/qregion.h" 2 3 4 + + + + + + +typedef QtValidLicenseForGuiModule QtGuiModule; + +template class QVector; +class QVariant; + + +struct QRegionPrivate; + + +class QBitmap; + +class QRegion +{ +public: + enum RegionType { Rectangle, Ellipse }; + + QRegion(); + QRegion(int x, int y, int w, int h, RegionType t = Rectangle); + QRegion(const QRect &r, RegionType t = Rectangle); + QRegion(const QPolygon &pa, Qt::FillRule fillRule = Qt::OddEvenFill); + + + + QRegion(const QRegion ®ion); + QRegion(const QBitmap &bitmap); + ~QRegion(); + QRegion &operator=(const QRegion &); + + + + + inline void swap(QRegion &other) { qSwap(d, other.d); } + + + + bool isEmpty() const; + + bool contains(const QPoint &p) const; + bool contains(const QRect &r) const; + + void translate(int dx, int dy); + inline void translate(const QPoint &p) { translate(p.x(), p.y()); } + QRegion translated(int dx, int dy) const; + inline QRegion translated(const QPoint &p) const { return translated(p.x(), p.y()); } + + + QRegion unite(const QRegion &r) const; + QRegion unite(const QRect &r) const; + QRegion intersect(const QRegion &r) const; + QRegion intersect(const QRect &r) const; + QRegion subtract(const QRegion &r) const; + QRegion eor(const QRegion &r) const; + + inline QRegion united(const QRegion &r) const { return unite(r); } + inline QRegion united(const QRect &r) const { return unite(r); } + inline QRegion intersected(const QRegion &r) const { return intersect(r); } + inline QRegion intersected(const QRect &r) const { return intersect(r); } + inline QRegion subtracted(const QRegion &r) const { return subtract(r); } + inline QRegion xored(const QRegion &r) const { return eor(r); } + + bool intersects(const QRegion &r) const; + bool intersects(const QRect &r) const; + + QRect boundingRect() const; + QVector rects() const; + void setRects(const QRect *rect, int num); + + int numRects() const; + + int rectCount() const; + + const QRegion operator|(const QRegion &r) const; + const QRegion operator+(const QRegion &r) const; + const QRegion operator+(const QRect &r) const; + const QRegion operator&(const QRegion &r) const; + const QRegion operator&(const QRect &r) const; + const QRegion operator-(const QRegion &r) const; + const QRegion operator^(const QRegion &r) const; + QRegion& operator|=(const QRegion &r); + QRegion& operator+=(const QRegion &r); + QRegion& operator+=(const QRect &r); + QRegion& operator&=(const QRegion &r); + QRegion& operator&=(const QRect &r); + QRegion& operator-=(const QRegion &r); + QRegion& operator^=(const QRegion &r); + + bool operator==(const QRegion &r) const; + inline bool operator!=(const QRegion &r) const { return !(operator==(r)); } + operator QVariant() const; +# 154 "/usr/include/qt4/QtGui/qregion.h" 3 4 + inline Region handle() const { if(!d->rgn) updateX11Region(); return d->rgn; } +# 176 "/usr/include/qt4/QtGui/qregion.h" 3 4 + friend QDataStream &operator<<(QDataStream &, const QRegion &); + friend QDataStream &operator>>(QDataStream &, QRegion &); + +private: + QRegion copy() const; + void detach(); + + + + + void updateX11Region() const; + void *clipRectangles(int &num) const; + friend void *qt_getClipRects(const QRegion &r, int &num); + + + + + friend bool qt_region_strictContains(const QRegion ®ion, + const QRect &rect); + friend struct QRegionPrivate; + + + void exec(const QByteArray &ba, int ver = 0, QDataStream::ByteOrder byteOrder = QDataStream::BigEndian); + + struct QRegionData { + QBasicAtomicInt ref; + + + + Region rgn; + void *xrectangles; + + + + + QRegionPrivate *qt_rgn; + + }; + + + + struct QRegionData *d; + static struct QRegionData shared_empty; + static void cleanUp(QRegionData *x); +}; + + + + + + + QDataStream &operator<<(QDataStream &, const QRegion &); + QDataStream &operator>>(QDataStream &, QRegion &); + + + + QDebug operator<<(QDebug, const QRegion &); + + + + + +# 48 "/usr/include/qt4/QtGui/qevent.h" 2 3 4 + + +# 1 "/usr/include/qt4/QtGui/qkeysequence.h" 1 3 4 +# 48 "/usr/include/qt4/QtGui/qkeysequence.h" 3 4 + + + + +typedef QtValidLicenseForGuiModule QtGuiModule; + + + + + + + +class QKeySequence; + QDataStream &operator<<(QDataStream &in, const QKeySequence &ks); + QDataStream &operator>>(QDataStream &out, QKeySequence &ks); + + + + + + +class QVariant; +class QKeySequencePrivate; + +class QKeySequence +{ +public: + enum StandardKey { + UnknownKey, + HelpContents, + WhatsThis, + Open, + Close, + Save, + New, + Delete, + Cut, + Copy, + Paste, + Undo, + Redo, + Back, + Forward, + Refresh, + ZoomIn, + ZoomOut, + Print, + AddTab, + NextChild, + PreviousChild, + Find, + FindNext, + FindPrevious, + Replace, + SelectAll, + Bold, + Italic, + Underline, + MoveToNextChar, + MoveToPreviousChar, + MoveToNextWord, + MoveToPreviousWord, + MoveToNextLine, + MoveToPreviousLine, + MoveToNextPage, + MoveToPreviousPage, + MoveToStartOfLine, + MoveToEndOfLine, + MoveToStartOfBlock, + MoveToEndOfBlock, + MoveToStartOfDocument, + MoveToEndOfDocument, + SelectNextChar, + SelectPreviousChar, + SelectNextWord, + SelectPreviousWord, + SelectNextLine, + SelectPreviousLine, + SelectNextPage, + SelectPreviousPage, + SelectStartOfLine, + SelectEndOfLine, + SelectStartOfBlock, + SelectEndOfBlock, + SelectStartOfDocument, + SelectEndOfDocument, + DeleteStartOfWord, + DeleteEndOfWord, + DeleteEndOfLine, + InsertParagraphSeparator, + InsertLineSeparator, + SaveAs, + Preferences, + Quit + }; + + enum SequenceFormat { + NativeText, + PortableText + }; + + QKeySequence(); + QKeySequence(const QString &key); + QKeySequence(const QString &key, SequenceFormat format); + QKeySequence(int k1, int k2 = 0, int k3 = 0, int k4 = 0); + QKeySequence(const QKeySequence &ks); + QKeySequence(StandardKey key); + ~QKeySequence(); + + uint count() const; + bool isEmpty() const; + + enum SequenceMatch { + NoMatch, + PartialMatch, + ExactMatch + + + + }; + + QString toString(SequenceFormat format = PortableText) const; + static QKeySequence fromString(const QString &str, SequenceFormat format = PortableText); + + SequenceMatch matches(const QKeySequence &seq) const; + static QKeySequence mnemonic(const QString &text); + static QList keyBindings(StandardKey key); + + + operator QString() const; + operator QVariant() const; + operator int() const; + int operator[](uint i) const; + QKeySequence &operator=(const QKeySequence &other); + + + + + inline void swap(QKeySequence &other) { qSwap(d, other.d); } + bool operator==(const QKeySequence &other) const; + inline bool operator!= (const QKeySequence &other) const + { return !(*this == other); } + bool operator< (const QKeySequence &ks) const; + inline bool operator> (const QKeySequence &other) const + { return other < *this; } + inline bool operator<= (const QKeySequence &other) const + { return !(other < *this); } + inline bool operator>= (const QKeySequence &other) const + { return !(*this < other); } + + bool isDetached() const; +private: + static int decodeString(const QString &ks); + static QString encodeString(int key); + int assign(const QString &str); + int assign(const QString &str, SequenceFormat format); + void setKey(int key, int index); + + QKeySequencePrivate *d; + + friend QDataStream &operator<<(QDataStream &in, const QKeySequence &ks); + friend QDataStream &operator>>(QDataStream &in, QKeySequence &ks); + friend class Q3AccelManager; + friend class QShortcutMap; + friend class QShortcut; + +public: + typedef QKeySequencePrivate * DataPtr; + inline DataPtr &data_ptr() { return d; } +}; +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QKeySequence)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QKeySequence"; } }; +template <> inline bool qIsDetached(QKeySequence &t) { return t.isDetached(); } template <> inline void qSwap(QKeySequence &value1, QKeySequence &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QKeySequence>(::QKeySequence &value1, ::QKeySequence &value2) { swap(value1.data_ptr(), value2.data_ptr()); } } + + + QDebug operator<<(QDebug, const QKeySequence &); +# 236 "/usr/include/qt4/QtGui/qkeysequence.h" 3 4 + + + +# 51 "/usr/include/qt4/QtGui/qevent.h" 2 3 4 + +# 1 "/usr/include/qt4/QtGui/qmime.h" 1 3 4 +# 45 "/usr/include/qt4/QtGui/qmime.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qmimedata.h" 1 3 4 +# 45 "/usr/include/qt4/QtCore/qmimedata.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qvariant.h" 1 3 4 +# 48 "/usr/include/qt4/QtCore/qvariant.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qmetatype.h" 1 3 4 +# 56 "/usr/include/qt4/QtCore/qmetatype.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QMetaType { +public: + enum Type { + + Void = 0, Bool = 1, Int = 2, UInt = 3, LongLong = 4, ULongLong = 5, + Double = 6, QChar = 7, QVariantMap = 8, QVariantList = 9, + QString = 10, QStringList = 11, QByteArray = 12, + QBitArray = 13, QDate = 14, QTime = 15, QDateTime = 16, QUrl = 17, + QLocale = 18, QRect = 19, QRectF = 20, QSize = 21, QSizeF = 22, + QLine = 23, QLineF = 24, QPoint = 25, QPointF = 26, QRegExp = 27, + QVariantHash = 28, QEasingCurve = 29, LastCoreType = QEasingCurve, + + FirstGuiType = 63 , + + + + QFont = 64, QPixmap = 65, QBrush = 66, QColor = 67, QPalette = 68, + QIcon = 69, QImage = 70, QPolygon = 71, QRegion = 72, QBitmap = 73, + QCursor = 74, QSizePolicy = 75, QKeySequence = 76, QPen = 77, + QTextLength = 78, QTextFormat = 79, QMatrix = 80, QTransform = 81, + QMatrix4x4 = 82, QVector2D = 83, QVector3D = 84, QVector4D = 85, + QQuaternion = 86, + LastGuiType = QQuaternion, + + FirstCoreExtType = 128 , + VoidStar = 128, Long = 129, Short = 130, Char = 131, ULong = 132, + UShort = 133, UChar = 134, Float = 135, QObjectStar = 136, QWidgetStar = 137, + QVariant = 138, + LastCoreExtType = QVariant, + + + + + + + + QReal = Double, + + + User = 256 + }; + + typedef void (*Destructor)(void *); + typedef void *(*Constructor)(const void *); + + + typedef void (*SaveOperator)(QDataStream &, const void *); + typedef void (*LoadOperator)(QDataStream &, void *); + static void registerStreamOperators(const char *typeName, SaveOperator saveOp, + LoadOperator loadOp); + static void registerStreamOperators(int type, SaveOperator saveOp, + LoadOperator loadOp); + + static int registerType(const char *typeName, Destructor destructor, + Constructor constructor); + static int registerTypedef(const char *typeName, int aliasId); + static int type(const char *typeName); + static const char *typeName(int type); + static bool isRegistered(int type); + static void *construct(int type, const void *copy = 0); + static void destroy(int type, void *data); + static void unregisterType(const char *typeName); + + + static bool save(QDataStream &stream, int type, const void *data); + static bool load(QDataStream &stream, int type, void *data); + +}; + +template +void qMetaTypeDeleteHelper(T *t) +{ + delete t; +} + +template +void *qMetaTypeConstructHelper(const T *t) +{ + if (!t) + return new T(); + return new T(*static_cast(t)); +} + + +template +void qMetaTypeSaveHelper(QDataStream &stream, const T *t) +{ + stream << *t; +} + +template +void qMetaTypeLoadHelper(QDataStream &stream, T *t) +{ + stream >> *t; +} + + +template +struct QMetaTypeId +{ + enum { Defined = 0 }; +}; + +template +struct QMetaTypeId2 +{ + enum { Defined = QMetaTypeId::Defined }; + static inline int qt_metatype_id() { return QMetaTypeId::qt_metatype_id(); } +}; + +namespace QtPrivate { + template ::Defined> + struct QMetaTypeIdHelper { + static inline int qt_metatype_id() + { return QMetaTypeId2::qt_metatype_id(); } + }; + template struct QMetaTypeIdHelper { + static inline int qt_metatype_id() + { return -1; } + }; +} + +template +int qRegisterMetaType(const char *typeName + + , T * dummy = 0 + +) +{ + const int typedefOf = dummy ? -1 : QtPrivate::QMetaTypeIdHelper::qt_metatype_id(); + if (typedefOf != -1) + return QMetaType::registerTypedef(typeName, typedefOf); + + typedef void*(*ConstructPtr)(const T*); + ConstructPtr cptr = qMetaTypeConstructHelper; + typedef void(*DeletePtr)(T*); + DeletePtr dptr = qMetaTypeDeleteHelper; + + return QMetaType::registerType(typeName, reinterpret_cast(dptr), + reinterpret_cast(cptr)); +} + + +template +void qRegisterMetaTypeStreamOperators(const char *typeName + + , T * = 0 + +) +{ + typedef void(*SavePtr)(QDataStream &, const T *); + typedef void(*LoadPtr)(QDataStream &, T *); + SavePtr sptr = qMetaTypeSaveHelper; + LoadPtr lptr = qMetaTypeLoadHelper; + + qRegisterMetaType(typeName); + QMetaType::registerStreamOperators(typeName, reinterpret_cast(sptr), + reinterpret_cast(lptr)); +} + + +template +inline int qMetaTypeId( + + T * = 0 + +) +{ + return QMetaTypeId2::qt_metatype_id(); +} + +template +inline int qRegisterMetaType( + + T * dummy = 0 + +) +{ + + + + return qMetaTypeId(dummy); + +} + + +template +inline int qRegisterMetaTypeStreamOperators() +{ + typedef void(*SavePtr)(QDataStream &, const T *); + typedef void(*LoadPtr)(QDataStream &, T *); + SavePtr sptr = qMetaTypeSaveHelper; + LoadPtr lptr = qMetaTypeLoadHelper; + + int id = qMetaTypeId(); + QMetaType::registerStreamOperators(id, + reinterpret_cast(sptr), + reinterpret_cast(lptr)); + + return id; +} +# 291 "/usr/include/qt4/QtCore/qmetatype.h" 3 4 +class QString; +class QByteArray; +class QChar; +class QStringList; +class QBitArray; +class QDate; +class QTime; +class QDateTime; +class QUrl; +class QLocale; +class QRect; +class QRectF; +class QSize; +class QSizeF; +class QLine; +class QLineF; +class QPoint; +class QPointF; + +class QRegExp; + +class QEasingCurve; +class QWidget; +class QObject; + + + + +class QFont; +class QPixmap; +class QBrush; +class QColor; +class QPalette; +class QIcon; +class QImage; +class QPolygon; +class QRegion; +class QBitmap; +class QCursor; +class QSizePolicy; +class QKeySequence; +class QPen; +class QTextLength; +class QTextFormat; +class QMatrix; +class QTransform; +class QMatrix4x4; +class QVector2D; +class QVector3D; +class QVector4D; +class QQuaternion; +class QVariant; + + + + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QString }; static inline int qt_metatype_id() { return QMetaType::QString; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::Int }; static inline int qt_metatype_id() { return QMetaType::Int; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::UInt }; static inline int qt_metatype_id() { return QMetaType::UInt; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::Bool }; static inline int qt_metatype_id() { return QMetaType::Bool; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::Double }; static inline int qt_metatype_id() { return QMetaType::Double; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QByteArray }; static inline int qt_metatype_id() { return QMetaType::QByteArray; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QChar }; static inline int qt_metatype_id() { return QMetaType::QChar; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::Long }; static inline int qt_metatype_id() { return QMetaType::Long; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::Short }; static inline int qt_metatype_id() { return QMetaType::Short; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::Char }; static inline int qt_metatype_id() { return QMetaType::Char; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::Char }; static inline int qt_metatype_id() { return QMetaType::Char; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::ULong }; static inline int qt_metatype_id() { return QMetaType::ULong; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::UShort }; static inline int qt_metatype_id() { return QMetaType::UShort; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::UChar }; static inline int qt_metatype_id() { return QMetaType::UChar; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::Float }; static inline int qt_metatype_id() { return QMetaType::Float; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QObjectStar }; static inline int qt_metatype_id() { return QMetaType::QObjectStar; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QWidgetStar }; static inline int qt_metatype_id() { return QMetaType::QWidgetStar; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::VoidStar }; static inline int qt_metatype_id() { return QMetaType::VoidStar; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::LongLong }; static inline int qt_metatype_id() { return QMetaType::LongLong; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::ULongLong }; static inline int qt_metatype_id() { return QMetaType::ULongLong; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QStringList }; static inline int qt_metatype_id() { return QMetaType::QStringList; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QBitArray }; static inline int qt_metatype_id() { return QMetaType::QBitArray; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QDate }; static inline int qt_metatype_id() { return QMetaType::QDate; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QTime }; static inline int qt_metatype_id() { return QMetaType::QTime; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QDateTime }; static inline int qt_metatype_id() { return QMetaType::QDateTime; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QUrl }; static inline int qt_metatype_id() { return QMetaType::QUrl; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QLocale }; static inline int qt_metatype_id() { return QMetaType::QLocale; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QRect }; static inline int qt_metatype_id() { return QMetaType::QRect; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QRectF }; static inline int qt_metatype_id() { return QMetaType::QRectF; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QSize }; static inline int qt_metatype_id() { return QMetaType::QSize; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QSizeF }; static inline int qt_metatype_id() { return QMetaType::QSizeF; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QLine }; static inline int qt_metatype_id() { return QMetaType::QLine; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QLineF }; static inline int qt_metatype_id() { return QMetaType::QLineF; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QPoint }; static inline int qt_metatype_id() { return QMetaType::QPoint; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QPointF }; static inline int qt_metatype_id() { return QMetaType::QPointF; } }; + + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QRegExp }; static inline int qt_metatype_id() { return QMetaType::QRegExp; } }; + + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QEasingCurve }; static inline int qt_metatype_id() { return QMetaType::QEasingCurve; } }; + + + + + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QFont }; static inline int qt_metatype_id() { return QMetaType::QFont; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QPixmap }; static inline int qt_metatype_id() { return QMetaType::QPixmap; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QBrush }; static inline int qt_metatype_id() { return QMetaType::QBrush; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QColor }; static inline int qt_metatype_id() { return QMetaType::QColor; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QPalette }; static inline int qt_metatype_id() { return QMetaType::QPalette; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QIcon }; static inline int qt_metatype_id() { return QMetaType::QIcon; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QImage }; static inline int qt_metatype_id() { return QMetaType::QImage; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QPolygon }; static inline int qt_metatype_id() { return QMetaType::QPolygon; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QRegion }; static inline int qt_metatype_id() { return QMetaType::QRegion; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QBitmap }; static inline int qt_metatype_id() { return QMetaType::QBitmap; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QCursor }; static inline int qt_metatype_id() { return QMetaType::QCursor; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QSizePolicy }; static inline int qt_metatype_id() { return QMetaType::QSizePolicy; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QKeySequence }; static inline int qt_metatype_id() { return QMetaType::QKeySequence; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QPen }; static inline int qt_metatype_id() { return QMetaType::QPen; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QTextLength }; static inline int qt_metatype_id() { return QMetaType::QTextLength; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QTextFormat }; static inline int qt_metatype_id() { return QMetaType::QTextFormat; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QMatrix }; static inline int qt_metatype_id() { return QMetaType::QMatrix; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QTransform }; static inline int qt_metatype_id() { return QMetaType::QTransform; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QMatrix4x4 }; static inline int qt_metatype_id() { return QMetaType::QMatrix4x4; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QVector2D }; static inline int qt_metatype_id() { return QMetaType::QVector2D; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QVector3D }; static inline int qt_metatype_id() { return QMetaType::QVector3D; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QVector4D }; static inline int qt_metatype_id() { return QMetaType::QVector4D; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QQuaternion }; static inline int qt_metatype_id() { return QMetaType::QQuaternion; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QVariant }; static inline int qt_metatype_id() { return QMetaType::QVariant; } }; + + +# 49 "/usr/include/qt4/QtCore/qvariant.h" 2 3 4 +# 1 "/usr/include/qt4/QtCore/qmap.h" 1 3 4 +# 50 "/usr/include/qt4/QtCore/qmap.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/map" 1 3 4 +# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/map" 3 4 + +# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/map" 3 + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 1 3 +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 +# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 92 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + enum _Rb_tree_color { _S_red = false, _S_black = true }; + + struct _Rb_tree_node_base + { + typedef _Rb_tree_node_base* _Base_ptr; + typedef const _Rb_tree_node_base* _Const_Base_ptr; + + _Rb_tree_color _M_color; + _Base_ptr _M_parent; + _Base_ptr _M_left; + _Base_ptr _M_right; + + static _Base_ptr + _S_minimum(_Base_ptr __x) + { + while (__x->_M_left != 0) __x = __x->_M_left; + return __x; + } + + static _Const_Base_ptr + _S_minimum(_Const_Base_ptr __x) + { + while (__x->_M_left != 0) __x = __x->_M_left; + return __x; + } + + static _Base_ptr + _S_maximum(_Base_ptr __x) + { + while (__x->_M_right != 0) __x = __x->_M_right; + return __x; + } + + static _Const_Base_ptr + _S_maximum(_Const_Base_ptr __x) + { + while (__x->_M_right != 0) __x = __x->_M_right; + return __x; + } + }; + + template + struct _Rb_tree_node : public _Rb_tree_node_base + { + typedef _Rb_tree_node<_Val>* _Link_type; + + + _Val _M_value_field; + + _Val* + _M_valptr() + { return std::__addressof(_M_value_field); } + + const _Val* + _M_valptr() const + { return std::__addressof(_M_value_field); } +# 159 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + }; + + __attribute__ ((__pure__)) _Rb_tree_node_base* + _Rb_tree_increment(_Rb_tree_node_base* __x) throw (); + + __attribute__ ((__pure__)) const _Rb_tree_node_base* + _Rb_tree_increment(const _Rb_tree_node_base* __x) throw (); + + __attribute__ ((__pure__)) _Rb_tree_node_base* + _Rb_tree_decrement(_Rb_tree_node_base* __x) throw (); + + __attribute__ ((__pure__)) const _Rb_tree_node_base* + _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw (); + + template + struct _Rb_tree_iterator + { + typedef _Tp value_type; + typedef _Tp& reference; + typedef _Tp* pointer; + + typedef bidirectional_iterator_tag iterator_category; + typedef ptrdiff_t difference_type; + + typedef _Rb_tree_iterator<_Tp> _Self; + typedef _Rb_tree_node_base::_Base_ptr _Base_ptr; + typedef _Rb_tree_node<_Tp>* _Link_type; + + _Rb_tree_iterator() + : _M_node() { } + + explicit + _Rb_tree_iterator(_Base_ptr __x) + : _M_node(__x) { } + + reference + operator*() const + { return *static_cast<_Link_type>(_M_node)->_M_valptr(); } + + pointer + operator->() const + { return static_cast<_Link_type> (_M_node)->_M_valptr(); } + + _Self& + operator++() + { + _M_node = _Rb_tree_increment(_M_node); + return *this; + } + + _Self + operator++(int) + { + _Self __tmp = *this; + _M_node = _Rb_tree_increment(_M_node); + return __tmp; + } + + _Self& + operator--() + { + _M_node = _Rb_tree_decrement(_M_node); + return *this; + } + + _Self + operator--(int) + { + _Self __tmp = *this; + _M_node = _Rb_tree_decrement(_M_node); + return __tmp; + } + + bool + operator==(const _Self& __x) const + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const + { return _M_node != __x._M_node; } + + _Base_ptr _M_node; + }; + + template + struct _Rb_tree_const_iterator + { + typedef _Tp value_type; + typedef const _Tp& reference; + typedef const _Tp* pointer; + + typedef _Rb_tree_iterator<_Tp> iterator; + + typedef bidirectional_iterator_tag iterator_category; + typedef ptrdiff_t difference_type; + + typedef _Rb_tree_const_iterator<_Tp> _Self; + typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr; + typedef const _Rb_tree_node<_Tp>* _Link_type; + + _Rb_tree_const_iterator() + : _M_node() { } + + explicit + _Rb_tree_const_iterator(_Base_ptr __x) + : _M_node(__x) { } + + _Rb_tree_const_iterator(const iterator& __it) + : _M_node(__it._M_node) { } + + iterator + _M_const_cast() const + { return iterator(const_cast(_M_node)); } + + reference + operator*() const + { return *static_cast<_Link_type>(_M_node)->_M_valptr(); } + + pointer + operator->() const + { return static_cast<_Link_type>(_M_node)->_M_valptr(); } + + _Self& + operator++() + { + _M_node = _Rb_tree_increment(_M_node); + return *this; + } + + _Self + operator++(int) + { + _Self __tmp = *this; + _M_node = _Rb_tree_increment(_M_node); + return __tmp; + } + + _Self& + operator--() + { + _M_node = _Rb_tree_decrement(_M_node); + return *this; + } + + _Self + operator--(int) + { + _Self __tmp = *this; + _M_node = _Rb_tree_decrement(_M_node); + return __tmp; + } + + bool + operator==(const _Self& __x) const + { return _M_node == __x._M_node; } + + bool + operator!=(const _Self& __x) const + { return _M_node != __x._M_node; } + + _Base_ptr _M_node; + }; + + template + inline bool + operator==(const _Rb_tree_iterator<_Val>& __x, + const _Rb_tree_const_iterator<_Val>& __y) + { return __x._M_node == __y._M_node; } + + template + inline bool + operator!=(const _Rb_tree_iterator<_Val>& __x, + const _Rb_tree_const_iterator<_Val>& __y) + { return __x._M_node != __y._M_node; } + + void + _Rb_tree_insert_and_rebalance(const bool __insert_left, + _Rb_tree_node_base* __x, + _Rb_tree_node_base* __p, + _Rb_tree_node_base& __header) throw (); + + _Rb_tree_node_base* + _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z, + _Rb_tree_node_base& __header) throw (); + + + template > + class _Rb_tree + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Rb_tree_node<_Val> >::other _Node_allocator; + + typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits; + + protected: + typedef _Rb_tree_node_base* _Base_ptr; + typedef const _Rb_tree_node_base* _Const_Base_ptr; + typedef _Rb_tree_node<_Val>* _Link_type; + typedef const _Rb_tree_node<_Val>* _Const_Link_type; + + private: + + + struct _Reuse_or_alloc_node + { + _Reuse_or_alloc_node(_Rb_tree& __t) + : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t) + { + if (_M_root) + { + _M_root->_M_parent = 0; + + if (_M_nodes->_M_left) + _M_nodes = _M_nodes->_M_left; + } + else + _M_nodes = 0; + } + + + + + + ~_Reuse_or_alloc_node() + { _M_t._M_erase(static_cast<_Link_type>(_M_root)); } + + template + _Link_type + + operator()(const _Arg& __arg) + + + + { + _Link_type __node = static_cast<_Link_type>(_M_extract()); + if (__node) + { + _M_t._M_destroy_node(__node); + _M_t._M_construct_node(__node, (__arg)); + return __node; + } + + return _M_t._M_create_node((__arg)); + } + + private: + _Base_ptr + _M_extract() + { + if (!_M_nodes) + return _M_nodes; + + _Base_ptr __node = _M_nodes; + _M_nodes = _M_nodes->_M_parent; + if (_M_nodes) + { + if (_M_nodes->_M_right == __node) + { + _M_nodes->_M_right = 0; + + if (_M_nodes->_M_left) + { + _M_nodes = _M_nodes->_M_left; + + while (_M_nodes->_M_right) + _M_nodes = _M_nodes->_M_right; + + if (_M_nodes->_M_left) + _M_nodes = _M_nodes->_M_left; + } + } + else + _M_nodes->_M_left = 0; + } + else + _M_root = 0; + + return __node; + } + + _Base_ptr _M_root; + _Base_ptr _M_nodes; + _Rb_tree& _M_t; + }; + + + + struct _Alloc_node + { + _Alloc_node(_Rb_tree& __t) + : _M_t(__t) { } + + template + _Link_type + + operator()(const _Arg& __arg) const + + + + { return _M_t._M_create_node((__arg)); } + + private: + _Rb_tree& _M_t; + }; + + public: + typedef _Key key_type; + typedef _Val value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + _Node_allocator& + _M_get_Node_allocator() + { return *static_cast<_Node_allocator*>(&this->_M_impl); } + + const _Node_allocator& + _M_get_Node_allocator() const + { return *static_cast(&this->_M_impl); } + + allocator_type + get_allocator() const + { return allocator_type(_M_get_Node_allocator()); } + + protected: + _Link_type + _M_get_node() + { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); } + + void + _M_put_node(_Link_type __p) + { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); } + + + void + _M_construct_node(_Link_type __node, const value_type& __x) + { + try + { get_allocator().construct(__node->_M_valptr(), __x); } + catch(...) + { + _M_put_node(__node); + throw; + } + } + + _Link_type + _M_create_node(const value_type& __x) + { + _Link_type __tmp = _M_get_node(); + _M_construct_node(__tmp, __x); + return __tmp; + } + + void + _M_destroy_node(_Link_type __p) + { get_allocator().destroy(__p->_M_valptr()); } +# 558 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + void + _M_drop_node(_Link_type __p) + { + _M_destroy_node(__p); + _M_put_node(__p); + } + + template + _Link_type + _M_clone_node(_Const_Link_type __x, _NodeGen& __node_gen) + { + _Link_type __tmp = __node_gen(*__x->_M_valptr()); + __tmp->_M_color = __x->_M_color; + __tmp->_M_left = 0; + __tmp->_M_right = 0; + return __tmp; + } + + protected: + + template + struct _Rb_tree_impl : public _Node_allocator + { + _Key_compare _M_key_compare; + _Rb_tree_node_base _M_header; + size_type _M_node_count; + + _Rb_tree_impl() + : _Node_allocator(), _M_key_compare(), _M_header(), + _M_node_count(0) + { _M_initialize(); } + + _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a) + : _Node_allocator(__a), _M_key_compare(__comp), _M_header(), + _M_node_count(0) + { _M_initialize(); } +# 603 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + void + _M_reset() + { + this->_M_header._M_parent = 0; + this->_M_header._M_left = &this->_M_header; + this->_M_header._M_right = &this->_M_header; + this->_M_node_count = 0; + } + + private: + void + _M_initialize() + { + this->_M_header._M_color = _S_red; + this->_M_header._M_parent = 0; + this->_M_header._M_left = &this->_M_header; + this->_M_header._M_right = &this->_M_header; + } + }; + + _Rb_tree_impl<_Compare> _M_impl; + + protected: + _Base_ptr& + _M_root() + { return this->_M_impl._M_header._M_parent; } + + _Const_Base_ptr + _M_root() const + { return this->_M_impl._M_header._M_parent; } + + _Base_ptr& + _M_leftmost() + { return this->_M_impl._M_header._M_left; } + + _Const_Base_ptr + _M_leftmost() const + { return this->_M_impl._M_header._M_left; } + + _Base_ptr& + _M_rightmost() + { return this->_M_impl._M_header._M_right; } + + _Const_Base_ptr + _M_rightmost() const + { return this->_M_impl._M_header._M_right; } + + _Link_type + _M_begin() + { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); } + + _Const_Link_type + _M_begin() const + { + return static_cast<_Const_Link_type> + (this->_M_impl._M_header._M_parent); + } + + _Link_type + _M_end() + { return reinterpret_cast<_Link_type>(&this->_M_impl._M_header); } + + _Const_Link_type + _M_end() const + { return reinterpret_cast<_Const_Link_type>(&this->_M_impl._M_header); } + + static const_reference + _S_value(_Const_Link_type __x) + { return *__x->_M_valptr(); } + + static const _Key& + _S_key(_Const_Link_type __x) + { return _KeyOfValue()(_S_value(__x)); } + + static _Link_type + _S_left(_Base_ptr __x) + { return static_cast<_Link_type>(__x->_M_left); } + + static _Const_Link_type + _S_left(_Const_Base_ptr __x) + { return static_cast<_Const_Link_type>(__x->_M_left); } + + static _Link_type + _S_right(_Base_ptr __x) + { return static_cast<_Link_type>(__x->_M_right); } + + static _Const_Link_type + _S_right(_Const_Base_ptr __x) + { return static_cast<_Const_Link_type>(__x->_M_right); } + + static const_reference + _S_value(_Const_Base_ptr __x) + { return *static_cast<_Const_Link_type>(__x)->_M_valptr(); } + + static const _Key& + _S_key(_Const_Base_ptr __x) + { return _KeyOfValue()(_S_value(__x)); } + + static _Base_ptr + _S_minimum(_Base_ptr __x) + { return _Rb_tree_node_base::_S_minimum(__x); } + + static _Const_Base_ptr + _S_minimum(_Const_Base_ptr __x) + { return _Rb_tree_node_base::_S_minimum(__x); } + + static _Base_ptr + _S_maximum(_Base_ptr __x) + { return _Rb_tree_node_base::_S_maximum(__x); } + + static _Const_Base_ptr + _S_maximum(_Const_Base_ptr __x) + { return _Rb_tree_node_base::_S_maximum(__x); } + + public: + typedef _Rb_tree_iterator iterator; + typedef _Rb_tree_const_iterator const_iterator; + + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + private: + pair<_Base_ptr, _Base_ptr> + _M_get_insert_unique_pos(const key_type& __k); + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_equal_pos(const key_type& __k); + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_hint_unique_pos(const_iterator __pos, + const key_type& __k); + + pair<_Base_ptr, _Base_ptr> + _M_get_insert_hint_equal_pos(const_iterator __pos, + const key_type& __k); +# 761 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + template + iterator + _M_insert_(_Base_ptr __x, _Base_ptr __y, + const value_type& __v, _NodeGen&); + + + + iterator + _M_insert_lower(_Base_ptr __y, const value_type& __v); + + iterator + _M_insert_equal_lower(const value_type& __x); + + + template + _Link_type + _M_copy(_Const_Link_type __x, _Link_type __p, _NodeGen&); + + _Link_type + _M_copy(_Const_Link_type __x, _Link_type __p) + { + _Alloc_node __an(*this); + return _M_copy(__x, __p, __an); + } + + void + _M_erase(_Link_type __x); + + iterator + _M_lower_bound(_Link_type __x, _Link_type __y, + const _Key& __k); + + const_iterator + _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y, + const _Key& __k) const; + + iterator + _M_upper_bound(_Link_type __x, _Link_type __y, + const _Key& __k); + + const_iterator + _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y, + const _Key& __k) const; + + public: + + _Rb_tree() { } + + _Rb_tree(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_impl(__comp, _Node_allocator(__a)) { } + + _Rb_tree(const _Rb_tree& __x) + : _M_impl(__x._M_impl._M_key_compare, + _Alloc_traits::_S_select_on_copy(__x._M_get_Node_allocator())) + { + if (__x._M_root() != 0) + { + _M_root() = _M_copy(__x._M_begin(), _M_end()); + _M_leftmost() = _S_minimum(_M_root()); + _M_rightmost() = _S_maximum(_M_root()); + _M_impl._M_node_count = __x._M_impl._M_node_count; + } + } +# 857 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + ~_Rb_tree() + { _M_erase(_M_begin()); } + + _Rb_tree& + operator=(const _Rb_tree& __x); + + + _Compare + key_comp() const + { return _M_impl._M_key_compare; } + + iterator + begin() + { return iterator(this->_M_impl._M_header._M_left); } + + const_iterator + begin() const + { return const_iterator(this->_M_impl._M_header._M_left); } + + iterator + end() + { return iterator(&this->_M_impl._M_header); } + + const_iterator + end() const + { return const_iterator(&this->_M_impl._M_header); } + + reverse_iterator + rbegin() + { return reverse_iterator(end()); } + + const_reverse_iterator + rbegin() const + { return const_reverse_iterator(end()); } + + reverse_iterator + rend() + { return reverse_iterator(begin()); } + + const_reverse_iterator + rend() const + { return const_reverse_iterator(begin()); } + + bool + empty() const + { return _M_impl._M_node_count == 0; } + + size_type + size() const + { return _M_impl._M_node_count; } + + size_type + max_size() const + { return _Alloc_traits::max_size(_M_get_Node_allocator()); } + + void + + + + swap(_Rb_tree& __t); +# 969 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + pair + _M_insert_unique(const value_type& __x); + + iterator + _M_insert_equal(const value_type& __x); + + template + iterator + _M_insert_unique_(const_iterator __pos, const value_type& __x, + _NodeGen&); + + iterator + _M_insert_unique_(const_iterator __pos, const value_type& __x) + { + _Alloc_node __an(*this); + return _M_insert_unique_(__pos, __x, __an); + } + + template + iterator + _M_insert_equal_(const_iterator __pos, const value_type& __x, + _NodeGen&); + iterator + _M_insert_equal_(const_iterator __pos, const value_type& __x) + { + _Alloc_node __an(*this); + return _M_insert_equal_(__pos, __x, __an); + } + + + template + void + _M_insert_unique(_InputIterator __first, _InputIterator __last); + + template + void + _M_insert_equal(_InputIterator __first, _InputIterator __last); + + private: + void + _M_erase_aux(const_iterator __position); + + void + _M_erase_aux(const_iterator __first, const_iterator __last); + + public: +# 1039 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + void + erase(iterator __position) + { _M_erase_aux(__position); } + + void + erase(const_iterator __position) + { _M_erase_aux(__position); } + + size_type + erase(const key_type& __x); +# 1061 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + void + erase(iterator __first, iterator __last) + { _M_erase_aux(__first, __last); } + + void + erase(const_iterator __first, const_iterator __last) + { _M_erase_aux(__first, __last); } + + void + erase(const key_type* __first, const key_type* __last); + + void + clear() + { + _M_erase(_M_begin()); + _M_impl._M_reset(); + } + + + iterator + find(const key_type& __k); + + const_iterator + find(const key_type& __k) const; + + size_type + count(const key_type& __k) const; + + iterator + lower_bound(const key_type& __k) + { return _M_lower_bound(_M_begin(), _M_end(), __k); } + + const_iterator + lower_bound(const key_type& __k) const + { return _M_lower_bound(_M_begin(), _M_end(), __k); } + + iterator + upper_bound(const key_type& __k) + { return _M_upper_bound(_M_begin(), _M_end(), __k); } + + const_iterator + upper_bound(const key_type& __k) const + { return _M_upper_bound(_M_begin(), _M_end(), __k); } + + pair + equal_range(const key_type& __k); + + pair + equal_range(const key_type& __k) const; +# 1243 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + bool + __rb_verify() const; +# 1268 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + }; + + template + inline bool + operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { + return __x.size() == __y.size() + && std::equal(__x.begin(), __x.end(), __y.begin()); + } + + template + inline bool + operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { + return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); + } + + template + inline bool + operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { return !(__x == __y); } + + template + inline bool + operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { return __y < __x; } + + template + inline bool + operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + template + inline bool + operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + template + inline void + swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) + { __x.swap(__y); } +# 1448 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + template + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + operator=(const _Rb_tree& __x) + { + if (this != &__x) + { +# 1473 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + _Reuse_or_alloc_node __roan(*this); + _M_impl._M_reset(); + _M_impl._M_key_compare = __x._M_impl._M_key_compare; + if (__x._M_root() != 0) + { + _M_root() = _M_copy(__x._M_begin(), _M_end(), __roan); + _M_leftmost() = _S_minimum(_M_root()); + _M_rightmost() = _S_maximum(_M_root()); + _M_impl._M_node_count = __x._M_impl._M_node_count; + } + } + + return *this; + } + + template + + + + template + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_(_Base_ptr __x, _Base_ptr __p, + + + + const _Val& __v, + + _NodeGen& __node_gen) + { + bool __insert_left = (__x != 0 || __p == _M_end() + || _M_impl._M_key_compare(_KeyOfValue()(__v), + _S_key(__p))); + + _Link_type __z = __node_gen((__v)); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template + + + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + + + + _M_insert_lower(_Base_ptr __p, const _Val& __v) + + { + bool __insert_left = (__p == _M_end() + || !_M_impl._M_key_compare(_S_key(__p), + _KeyOfValue()(__v))); + + _Link_type __z = _M_create_node((__v)); + + _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, + this->_M_impl._M_header); + ++_M_impl._M_node_count; + return iterator(__z); + } + + template + + + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + + + + _M_insert_equal_lower(const _Val& __v) + + { + _Link_type __x = _M_begin(); + _Link_type __y = _M_end(); + while (__x != 0) + { + __y = __x; + __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ? + _S_left(__x) : _S_right(__x); + } + return _M_insert_lower(__y, (__v)); + } + + template + template + typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type + _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>:: + _M_copy(_Const_Link_type __x, _Link_type __p, _NodeGen& __node_gen) + { + + _Link_type __top = _M_clone_node(__x, __node_gen); + __top->_M_parent = __p; + + try + { + if (__x->_M_right) + __top->_M_right = _M_copy(_S_right(__x), __top, __node_gen); + __p = __top; + __x = _S_left(__x); + + while (__x != 0) + { + _Link_type __y = _M_clone_node(__x, __node_gen); + __p->_M_left = __y; + __y->_M_parent = __p; + if (__x->_M_right) + __y->_M_right = _M_copy(_S_right(__x), __y, __node_gen); + __p = __y; + __x = _S_left(__x); + } + } + catch(...) + { + _M_erase(__top); + throw; + } + return __top; + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_erase(_Link_type __x) + { + + while (__x != 0) + { + _M_erase(_S_right(__x)); + _Link_type __y = _S_left(__x); + _M_drop_node(__x); + __x = __y; + } + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_lower_bound(_Link_type __x, _Link_type __y, + const _Key& __k) + { + while (__x != 0) + if (!_M_impl._M_key_compare(_S_key(__x), __k)) + __y = __x, __x = _S_left(__x); + else + __x = _S_right(__x); + return iterator(__y); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y, + const _Key& __k) const + { + while (__x != 0) + if (!_M_impl._M_key_compare(_S_key(__x), __k)) + __y = __x, __x = _S_left(__x); + else + __x = _S_right(__x); + return const_iterator(__y); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_upper_bound(_Link_type __x, _Link_type __y, + const _Key& __k) + { + while (__x != 0) + if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y = __x, __x = _S_left(__x); + else + __x = _S_right(__x); + return iterator(__y); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y, + const _Key& __k) const + { + while (__x != 0) + if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y = __x, __x = _S_left(__x); + else + __x = _S_right(__x); + return const_iterator(__y); + } + + template + pair::iterator, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + equal_range(const _Key& __k) + { + _Link_type __x = _M_begin(); + _Link_type __y = _M_end(); + while (__x != 0) + { + if (_M_impl._M_key_compare(_S_key(__x), __k)) + __x = _S_right(__x); + else if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y = __x, __x = _S_left(__x); + else + { + _Link_type __xu(__x), __yu(__y); + __y = __x, __x = _S_left(__x); + __xu = _S_right(__xu); + return pair(_M_lower_bound(__x, __y, __k), + _M_upper_bound(__xu, __yu, __k)); + } + } + return pair(iterator(__y), + iterator(__y)); + } + + template + pair::const_iterator, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + equal_range(const _Key& __k) const + { + _Const_Link_type __x = _M_begin(); + _Const_Link_type __y = _M_end(); + while (__x != 0) + { + if (_M_impl._M_key_compare(_S_key(__x), __k)) + __x = _S_right(__x); + else if (_M_impl._M_key_compare(__k, _S_key(__x))) + __y = __x, __x = _S_left(__x); + else + { + _Const_Link_type __xu(__x), __yu(__y); + __y = __x, __x = _S_left(__x); + __xu = _S_right(__xu); + return pair(_M_lower_bound(__x, __y, __k), + _M_upper_bound(__xu, __yu, __k)); + } + } + return pair(const_iterator(__y), + const_iterator(__y)); + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t) + + + + { + if (_M_root() == 0) + { + if (__t._M_root() != 0) + { + _M_root() = __t._M_root(); + _M_leftmost() = __t._M_leftmost(); + _M_rightmost() = __t._M_rightmost(); + _M_root()->_M_parent = _M_end(); + _M_impl._M_node_count = __t._M_impl._M_node_count; + + __t._M_impl._M_reset(); + } + } + else if (__t._M_root() == 0) + { + __t._M_root() = _M_root(); + __t._M_leftmost() = _M_leftmost(); + __t._M_rightmost() = _M_rightmost(); + __t._M_root()->_M_parent = __t._M_end(); + __t._M_impl._M_node_count = _M_impl._M_node_count; + + _M_impl._M_reset(); + } + else + { + std::swap(_M_root(),__t._M_root()); + std::swap(_M_leftmost(),__t._M_leftmost()); + std::swap(_M_rightmost(),__t._M_rightmost()); + + _M_root()->_M_parent = _M_end(); + __t._M_root()->_M_parent = __t._M_end(); + std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count); + } + + std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare); + + _Alloc_traits::_S_on_swap(_M_get_Node_allocator(), + __t._M_get_Node_allocator()); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_unique_pos(const key_type& __k) + { + typedef pair<_Base_ptr, _Base_ptr> _Res; + _Link_type __x = _M_begin(); + _Link_type __y = _M_end(); + bool __comp = true; + while (__x != 0) + { + __y = __x; + __comp = _M_impl._M_key_compare(__k, _S_key(__x)); + __x = __comp ? _S_left(__x) : _S_right(__x); + } + iterator __j = iterator(__y); + if (__comp) + { + if (__j == begin()) + return _Res(__x, __y); + else + --__j; + } + if (_M_impl._M_key_compare(_S_key(__j._M_node), __k)) + return _Res(__x, __y); + return _Res(__j._M_node, 0); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_equal_pos(const key_type& __k) + { + typedef pair<_Base_ptr, _Base_ptr> _Res; + _Link_type __x = _M_begin(); + _Link_type __y = _M_end(); + while (__x != 0) + { + __y = __x; + __x = _M_impl._M_key_compare(__k, _S_key(__x)) ? + _S_left(__x) : _S_right(__x); + } + return _Res(__x, __y); + } + + template + + + + pair::iterator, bool> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + + + + _M_insert_unique(const _Val& __v) + + { + typedef pair _Res; + pair<_Base_ptr, _Base_ptr> __res + = _M_get_insert_unique_pos(_KeyOfValue()(__v)); + + if (__res.second) + { + _Alloc_node __an(*this); + return _Res(_M_insert_(__res.first, __res.second, + (__v), __an), + true); + } + + return _Res(iterator(static_cast<_Link_type>(__res.first)), false); + } + + template + + + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + + + + _M_insert_equal(const _Val& __v) + + { + pair<_Base_ptr, _Base_ptr> __res + = _M_get_insert_equal_pos(_KeyOfValue()(__v)); + _Alloc_node __an(*this); + return _M_insert_(__res.first, __res.second, + (__v), __an); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_hint_unique_pos(const_iterator __position, + const key_type& __k) + { + iterator __pos = __position._M_const_cast(); + typedef pair<_Base_ptr, _Base_ptr> _Res; + + + if (__pos._M_node == _M_end()) + { + if (size() > 0 + && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k)) + return _Res(0, _M_rightmost()); + else + return _M_get_insert_unique_pos(__k); + } + else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node))) + { + + iterator __before = __pos; + if (__pos._M_node == _M_leftmost()) + return _Res(_M_leftmost(), _M_leftmost()); + else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k)) + { + if (_S_right(__before._M_node) == 0) + return _Res(0, __before._M_node); + else + return _Res(__pos._M_node, __pos._M_node); + } + else + return _M_get_insert_unique_pos(__k); + } + else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k)) + { + + iterator __after = __pos; + if (__pos._M_node == _M_rightmost()) + return _Res(0, _M_rightmost()); + else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node))) + { + if (_S_right(__pos._M_node) == 0) + return _Res(0, __pos._M_node); + else + return _Res(__after._M_node, __after._M_node); + } + else + return _M_get_insert_unique_pos(__k); + } + else + + return _Res(__pos._M_node, 0); + } + + template + + + + template + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_unique_(const_iterator __position, + + + + const _Val& __v, + + _NodeGen& __node_gen) + { + pair<_Base_ptr, _Base_ptr> __res + = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v)); + + if (__res.second) + return _M_insert_(__res.first, __res.second, + (__v), + __node_gen); + return iterator(static_cast<_Link_type>(__res.first)); + } + + template + pair::_Base_ptr, + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::_Base_ptr> + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k) + { + iterator __pos = __position._M_const_cast(); + typedef pair<_Base_ptr, _Base_ptr> _Res; + + + if (__pos._M_node == _M_end()) + { + if (size() > 0 + && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost()))) + return _Res(0, _M_rightmost()); + else + return _M_get_insert_equal_pos(__k); + } + else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k)) + { + + iterator __before = __pos; + if (__pos._M_node == _M_leftmost()) + return _Res(_M_leftmost(), _M_leftmost()); + else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node))) + { + if (_S_right(__before._M_node) == 0) + return _Res(0, __before._M_node); + else + return _Res(__pos._M_node, __pos._M_node); + } + else + return _M_get_insert_equal_pos(__k); + } + else + { + + iterator __after = __pos; + if (__pos._M_node == _M_rightmost()) + return _Res(0, _M_rightmost()); + else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k)) + { + if (_S_right(__pos._M_node) == 0) + return _Res(0, __pos._M_node); + else + return _Res(__after._M_node, __after._M_node); + } + else + return _Res(0, 0); + } + } + + template + + + + template + + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_insert_equal_(const_iterator __position, + + + + const _Val& __v, + + _NodeGen& __node_gen) + { + pair<_Base_ptr, _Base_ptr> __res + = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v)); + + if (__res.second) + return _M_insert_(__res.first, __res.second, + (__v), + __node_gen); + + return _M_insert_equal_lower((__v)); + } +# 2215 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_tree.h" 3 + template + template + void + _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>:: + _M_insert_unique(_II __first, _II __last) + { + _Alloc_node __an(*this); + for (; __first != __last; ++__first) + _M_insert_unique_(end(), *__first, __an); + } + + template + template + void + _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>:: + _M_insert_equal(_II __first, _II __last) + { + _Alloc_node __an(*this); + for (; __first != __last; ++__first) + _M_insert_equal_(end(), *__first, __an); + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_erase_aux(const_iterator __position) + { + _Link_type __y = + static_cast<_Link_type>(_Rb_tree_rebalance_for_erase + (const_cast<_Base_ptr>(__position._M_node), + this->_M_impl._M_header)); + _M_drop_node(__y); + --_M_impl._M_node_count; + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + _M_erase_aux(const_iterator __first, const_iterator __last) + { + if (__first == begin() && __last == end()) + clear(); + else + while (__first != __last) + erase(__first++); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + erase(const _Key& __x) + { + pair __p = equal_range(__x); + const size_type __old_size = size(); + erase(__p.first, __p.second); + return __old_size - size(); + } + + template + void + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + erase(const _Key* __first, const _Key* __last) + { + while (__first != __last) + erase(*__first++); + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + find(const _Key& __k) + { + iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k); + return (__j == end() + || _M_impl._M_key_compare(__k, + _S_key(__j._M_node))) ? end() : __j; + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, + _Compare, _Alloc>::const_iterator + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + find(const _Key& __k) const + { + const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k); + return (__j == end() + || _M_impl._M_key_compare(__k, + _S_key(__j._M_node))) ? end() : __j; + } + + template + typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type + _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: + count(const _Key& __k) const + { + pair __p = equal_range(__k); + const size_type __n = std::distance(__p.first, __p.second); + return __n; + } + + __attribute__ ((__pure__)) unsigned int + _Rb_tree_black_count(const _Rb_tree_node_base* __node, + const _Rb_tree_node_base* __root) throw (); + + template + bool + _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const + { + if (_M_impl._M_node_count == 0 || begin() == end()) + return _M_impl._M_node_count == 0 && begin() == end() + && this->_M_impl._M_header._M_left == _M_end() + && this->_M_impl._M_header._M_right == _M_end(); + + unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root()); + for (const_iterator __it = begin(); __it != end(); ++__it) + { + _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node); + _Const_Link_type __L = _S_left(__x); + _Const_Link_type __R = _S_right(__x); + + if (__x->_M_color == _S_red) + if ((__L && __L->_M_color == _S_red) + || (__R && __R->_M_color == _S_red)) + return false; + + if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L))) + return false; + if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x))) + return false; + + if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len) + return false; + } + + if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root())) + return false; + if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root())) + return false; + return true; + } + + +} +# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/map" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 1 3 +# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 94 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + template , + typename _Alloc = std::allocator > > + class map + { + public: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Alloc allocator_type; + + private: + + typedef typename _Alloc::value_type _Alloc_value_type; + + + + + + public: + class value_compare + : public std::binary_function + { + friend class map<_Key, _Tp, _Compare, _Alloc>; + protected: + _Compare comp; + + value_compare(_Compare __c) + : comp(__c) { } + + public: + bool operator()(const value_type& __x, const value_type& __y) const + { return comp(__x.first, __y.first); } + }; + + private: + + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind::other _Pair_alloc_type; + + typedef _Rb_tree, + key_compare, _Pair_alloc_type> _Rep_type; + + + _Rep_type _M_t; + + typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits; + + public: + + + typedef typename _Alloc_traits::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + typedef typename _Rep_type::iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + typedef typename _Rep_type::reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; + + + + + + + + map() + + + + : _M_t() { } + + + + + + + explicit + map(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) { } +# 185 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + map(const map& __x) + : _M_t(__x._M_t) { } +# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + template + map(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_unique(__first, __last); } +# 272 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + template + map(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_unique(__first, __last); } +# 295 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + map& + operator=(const map& __x) + { + _M_t = __x._M_t; + return *this; + } +# 327 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + allocator_type + get_allocator() const + { return allocator_type(_M_t.get_allocator()); } + + + + + + + + iterator + begin() + { return _M_t.begin(); } + + + + + + + const_iterator + begin() const + { return _M_t.begin(); } + + + + + + + iterator + end() + { return _M_t.end(); } + + + + + + + const_iterator + end() const + { return _M_t.end(); } + + + + + + + reverse_iterator + rbegin() + { return _M_t.rbegin(); } + + + + + + + const_reverse_iterator + rbegin() const + { return _M_t.rbegin(); } + + + + + + + reverse_iterator + rend() + { return _M_t.rend(); } + + + + + + + const_reverse_iterator + rend() const + { return _M_t.rend(); } +# 446 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + bool + empty() const + { return _M_t.empty(); } + + + size_type + size() const + { return _M_t.size(); } + + + size_type + max_size() const + { return _M_t.max_size(); } +# 473 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + mapped_type& + operator[](const key_type& __k) + { + + + + iterator __i = lower_bound(__k); + + if (__i == end() || key_comp()(__k, (*__i).first)) + + + + + + __i = insert(__i, value_type(__k, mapped_type())); + + return (*__i).second; + } +# 518 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + mapped_type& + at(const key_type& __k) + { + iterator __i = lower_bound(__k); + if (__i == end() || key_comp()(__k, (*__i).first)) + __throw_out_of_range(("map::at")); + return (*__i).second; + } + + const mapped_type& + at(const key_type& __k) const + { + const_iterator __i = lower_bound(__k); + if (__i == end() || key_comp()(__k, (*__i).first)) + __throw_out_of_range(("map::at")); + return (*__i).second; + } +# 611 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + std::pair + insert(const value_type& __x) + { return _M_t._M_insert_unique(__x); } +# 660 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + iterator + + + + insert(iterator __position, const value_type& __x) + + { return _M_t._M_insert_unique_(__position, __x); } +# 686 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_unique(__first, __last); } +# 727 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + void + erase(iterator __position) + { _M_t.erase(__position); } +# 743 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } +# 779 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + void + erase(iterator __first, iterator __last) + { _M_t.erase(__first, __last); } +# 795 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + void + swap(map& __x) + + + + { _M_t.swap(__x._M_t); } + + + + + + + + void + clear() + { _M_t.clear(); } + + + + + + + key_compare + key_comp() const + { return _M_t.key_comp(); } + + + + + + value_compare + value_comp() const + { return value_compare(_M_t.key_comp()); } +# 844 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + iterator + find(const key_type& __x) + { return _M_t.find(__x); } +# 869 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } +# 890 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + size_type + count(const key_type& __x) const + { return _M_t.find(__x) == _M_t.end() ? 0 : 1; } +# 914 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } +# 939 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } +# 959 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } +# 979 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } +# 1008 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } +# 1037 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } +# 1050 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + template + friend bool + operator==(const map<_K1, _T1, _C1, _A1>&, + const map<_K1, _T1, _C1, _A1>&); + + template + friend bool + operator<(const map<_K1, _T1, _C1, _A1>&, + const map<_K1, _T1, _C1, _A1>&); + }; +# 1071 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + template + inline bool + operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t == __y._M_t; } +# 1088 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_map.h" 3 + template + inline bool + operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + + template + inline bool + operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x == __y); } + + + template + inline bool + operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return __y < __x; } + + + template + inline bool + operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x, + const map<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + + template + inline void + swap(map<_Key, _Tp, _Compare, _Alloc>& __x, + map<_Key, _Tp, _Compare, _Alloc>& __y) + { __x.swap(__y); } + + +} +# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/map" 2 3 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 1 3 +# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +# 92 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + template , + typename _Alloc = std::allocator > > + class multimap + { + public: + typedef _Key key_type; + typedef _Tp mapped_type; + typedef std::pair value_type; + typedef _Compare key_compare; + typedef _Alloc allocator_type; + + private: + + typedef typename _Alloc::value_type _Alloc_value_type; + + + + + + public: + class value_compare + : public std::binary_function + { + friend class multimap<_Key, _Tp, _Compare, _Alloc>; + protected: + _Compare comp; + + value_compare(_Compare __c) + : comp(__c) { } + + public: + bool operator()(const value_type& __x, const value_type& __y) const + { return comp(__x.first, __y.first); } + }; + + private: + + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind::other _Pair_alloc_type; + + typedef _Rb_tree, + key_compare, _Pair_alloc_type> _Rep_type; + + _Rep_type _M_t; + + typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits; + + public: + + + typedef typename _Alloc_traits::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + typedef typename _Rep_type::iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + typedef typename _Rep_type::reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; + + + + + + + + multimap() + + + + : _M_t() { } + + + + + + + explicit + multimap(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) { } +# 183 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + multimap(const multimap& __x) + : _M_t(__x._M_t) { } +# 251 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + template + multimap(_InputIterator __first, _InputIterator __last) + : _M_t() + { _M_t._M_insert_equal(__first, __last); } +# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + template + multimap(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, _Pair_alloc_type(__a)) + { _M_t._M_insert_equal(__first, __last); } +# 290 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + multimap& + operator=(const multimap& __x) + { + _M_t = __x._M_t; + return *this; + } +# 322 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + allocator_type + get_allocator() const + { return allocator_type(_M_t.get_allocator()); } + + + + + + + + iterator + begin() + { return _M_t.begin(); } + + + + + + + const_iterator + begin() const + { return _M_t.begin(); } + + + + + + + iterator + end() + { return _M_t.end(); } + + + + + + + const_iterator + end() const + { return _M_t.end(); } + + + + + + + reverse_iterator + rbegin() + { return _M_t.rbegin(); } + + + + + + + const_reverse_iterator + rbegin() const + { return _M_t.rbegin(); } + + + + + + + reverse_iterator + rend() + { return _M_t.rend(); } + + + + + + + const_reverse_iterator + rend() const + { return _M_t.rend(); } +# 439 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + bool + empty() const + { return _M_t.empty(); } + + + size_type + size() const + { return _M_t.size(); } + + + size_type + max_size() const + { return _M_t.max_size(); } +# 519 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + iterator + insert(const value_type& __x) + { return _M_t._M_insert_equal(__x); } +# 552 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + iterator + + + + insert(iterator __position, const value_type& __x) + + { return _M_t._M_insert_equal_(__position, __x); } +# 579 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_t._M_insert_equal(__first, __last); } +# 633 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + void + erase(iterator __position) + { _M_t.erase(__position); } +# 649 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + size_type + erase(const key_type& __x) + { return _M_t.erase(__x); } +# 689 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + void + erase(iterator __first, iterator __last) + { _M_t.erase(__first, __last); } +# 705 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + void + swap(multimap& __x) + + + + { _M_t.swap(__x._M_t); } + + + + + + + + void + clear() + { _M_t.clear(); } + + + + + + + key_compare + key_comp() const + { return _M_t.key_comp(); } + + + + + + value_compare + value_comp() const + { return value_compare(_M_t.key_comp()); } +# 753 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + iterator + find(const key_type& __x) + { return _M_t.find(__x); } +# 777 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + const_iterator + find(const key_type& __x) const + { return _M_t.find(__x); } +# 795 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + size_type + count(const key_type& __x) const + { return _M_t.count(__x); } +# 819 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + iterator + lower_bound(const key_type& __x) + { return _M_t.lower_bound(__x); } +# 844 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + const_iterator + lower_bound(const key_type& __x) const + { return _M_t.lower_bound(__x); } +# 864 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + iterator + upper_bound(const key_type& __x) + { return _M_t.upper_bound(__x); } +# 884 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + const_iterator + upper_bound(const key_type& __x) const + { return _M_t.upper_bound(__x); } +# 911 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_t.equal_range(__x); } +# 938 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + std::pair + equal_range(const key_type& __x) const + { return _M_t.equal_range(__x); } +# 951 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + template + friend bool + operator==(const multimap<_K1, _T1, _C1, _A1>&, + const multimap<_K1, _T1, _C1, _A1>&); + + template + friend bool + operator<(const multimap<_K1, _T1, _C1, _A1>&, + const multimap<_K1, _T1, _C1, _A1>&); + }; +# 972 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + template + inline bool + operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t == __y._M_t; } +# 989 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/bits/stl_multimap.h" 3 + template + inline bool + operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return __x._M_t < __y._M_t; } + + + template + inline bool + operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x == __y); } + + + template + inline bool + operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return __y < __x; } + + + template + inline bool + operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, + const multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { return !(__x < __y); } + + + template + inline void + swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x, + multimap<_Key, _Tp, _Compare, _Alloc>& __y) + { __x.swap(__y); } + + +} +# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/g++-v5/map" 2 3 +# 51 "/usr/include/qt4/QtCore/qmap.h" 2 3 4 + + + + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +struct QMapData +{ + struct Node { + Node *backward; + Node *forward[1]; + }; + enum { LastLevel = 11, Sparseness = 3 }; + + QMapData *backward; + QMapData *forward[QMapData::LastLevel + 1]; + QBasicAtomicInt ref; + int topLevel; + int size; + uint randomBits; + uint insertInOrder : 1; + uint sharable : 1; + uint strictAlignment : 1; + uint reserved : 29; + + static QMapData *createData(); + static QMapData *createData(int alignment); + void continueFreeData(int offset); + Node *node_create(Node *update[], int offset); + Node *node_create(Node *update[], int offset, int alignment); + void node_delete(Node *update[], int offset, Node *node); + + + + + + static QMapData shared_null; +}; +# 105 "/usr/include/qt4/QtCore/qmap.h" 3 4 +template inline bool qMapLessThanKey(const Key &key1, const Key &key2) +{ + return key1 < key2; +} + +template inline bool qMapLessThanKey(Ptr *key1, Ptr *key2) +{ + qt_noop(); + return quintptr(key1) < quintptr(key2); +} + +template inline bool qMapLessThanKey(const Ptr *key1, const Ptr *key2) +{ + qt_noop(); + return quintptr(key1) < quintptr(key2); +} + +template +struct QMapNode { + Key key; + T value; + +private: + + + QMapData::Node *backward; + QMapData::Node *forward[1]; +}; + +template +struct QMapPayloadNode +{ + Key key; + T value; + +private: +# 155 "/usr/include/qt4/QtCore/qmap.h" 3 4 + QMapData::Node *backward; +}; + +template +class QMap +{ + typedef QMapNode Node; + typedef QMapPayloadNode PayloadNode; + + union { + QMapData *d; + QMapData::Node *e; + }; + + static inline int payload() { return sizeof(PayloadNode) - sizeof(QMapData::Node *); } + static inline int alignment() { + + return int(qMax(sizeof(void*), __alignof__(Node))); + + + + } + static inline Node *concrete(QMapData::Node *node) { + return reinterpret_cast(reinterpret_cast(node) - payload()); + } + +public: + inline QMap() : d(&QMapData::shared_null) { d->ref.ref(); } + inline QMap(const QMap &other) : d(other.d) + { d->ref.ref(); if (!d->sharable) detach(); } + inline ~QMap() { if (!d) return; if (!d->ref.deref()) freeData(d); } + + QMap &operator=(const QMap &other); + + + + + inline void swap(QMap &other) { qSwap(d, other.d); } + + explicit QMap(const typename std::map &other); + std::map toStdMap() const; + + + bool operator==(const QMap &other) const; + inline bool operator!=(const QMap &other) const { return !(*this == other); } + + inline int size() const { return d->size; } + + inline bool isEmpty() const { return d->size == 0; } + + inline void detach() { if (d->ref != 1) detach_helper(); } + inline bool isDetached() const { return d->ref == 1; } + inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } + inline bool isSharedWith(const QMap &other) const { return d == other.d; } + inline void setInsertInOrder(bool ordered) { d->insertInOrder = ordered; } + + void clear(); + + int remove(const Key &key); + T take(const Key &key); + + bool contains(const Key &key) const; + const Key key(const T &value) const; + const Key key(const T &value, const Key &defaultKey) const; + const T value(const Key &key) const; + const T value(const Key &key, const T &defaultValue) const; + T &operator[](const Key &key); + const T operator[](const Key &key) const; + + QList uniqueKeys() const; + QList keys() const; + QList keys(const T &value) const; + QList values() const; + QList values(const Key &key) const; + int count(const Key &key) const; + + class const_iterator; + + class iterator + { + friend class const_iterator; + QMapData::Node *i; + + public: + typedef std::bidirectional_iterator_tag iterator_category; + typedef qptrdiff difference_type; + typedef T value_type; + typedef T *pointer; + typedef T &reference; + + + inline operator QMapData::Node *() const { return i; } + inline iterator() : i(0) { } + inline iterator(QMapData::Node *node) : i(node) { } + + inline const Key &key() const { return concrete(i)->key; } + inline T &value() const { return concrete(i)->value; } + + + + inline T &operator*() const { return concrete(i)->value; } + inline T *operator->() const { return &concrete(i)->value; } + inline bool operator==(const iterator &o) const { return i == o.i; } + inline bool operator!=(const iterator &o) const { return i != o.i; } + + inline iterator &operator++() { + i = i->forward[0]; + return *this; + } + inline iterator operator++(int) { + iterator r = *this; + i = i->forward[0]; + return r; + } + inline iterator &operator--() { + i = i->backward; + return *this; + } + inline iterator operator--(int) { + iterator r = *this; + i = i->backward; + return r; + } + inline iterator operator+(int j) const + { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } + inline iterator operator-(int j) const { return operator+(-j); } + inline iterator &operator+=(int j) { return *this = *this + j; } + inline iterator &operator-=(int j) { return *this = *this - j; } + + + + + + public: + + inline bool operator==(const const_iterator &o) const + { return i == o.i; } + inline bool operator!=(const const_iterator &o) const + { return i != o.i; } + + private: + + inline operator bool() const { return false; } + }; + friend class iterator; + + class const_iterator + { + friend class iterator; + QMapData::Node *i; + + public: + typedef std::bidirectional_iterator_tag iterator_category; + typedef qptrdiff difference_type; + typedef T value_type; + typedef const T *pointer; + typedef const T &reference; + + + inline operator QMapData::Node *() const { return i; } + inline const_iterator() : i(0) { } + inline const_iterator(QMapData::Node *node) : i(node) { } + + + + inline const_iterator(const iterator &o) + + { i = o.i; } + + inline const Key &key() const { return concrete(i)->key; } + inline const T &value() const { return concrete(i)->value; } + + + + inline const T &operator*() const { return concrete(i)->value; } + inline const T *operator->() const { return &concrete(i)->value; } + inline bool operator==(const const_iterator &o) const { return i == o.i; } + inline bool operator!=(const const_iterator &o) const { return i != o.i; } + + inline const_iterator &operator++() { + i = i->forward[0]; + return *this; + } + inline const_iterator operator++(int) { + const_iterator r = *this; + i = i->forward[0]; + return r; + } + inline const_iterator &operator--() { + i = i->backward; + return *this; + } + inline const_iterator operator--(int) { + const_iterator r = *this; + i = i->backward; + return r; + } + inline const_iterator operator+(int j) const + { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } + inline const_iterator operator-(int j) const { return operator+(-j); } + inline const_iterator &operator+=(int j) { return *this = *this + j; } + inline const_iterator &operator-=(int j) { return *this = *this - j; } +# 365 "/usr/include/qt4/QtCore/qmap.h" 3 4 + private: + + inline operator bool() const { return false; } + }; + friend class const_iterator; + + + inline iterator begin() { detach(); return iterator(e->forward[0]); } + inline const_iterator begin() const { return const_iterator(e->forward[0]); } + inline const_iterator constBegin() const { return const_iterator(e->forward[0]); } + inline iterator end() { + detach(); + return iterator(e); + } + inline const_iterator end() const { return const_iterator(e); } + inline const_iterator constEnd() const { return const_iterator(e); } + iterator erase(iterator it); + + + + + + + typedef iterator Iterator; + typedef const_iterator ConstIterator; + inline int count() const { return d->size; } + iterator find(const Key &key); + const_iterator find(const Key &key) const; + const_iterator constFind(const Key &key) const; + iterator lowerBound(const Key &key); + const_iterator lowerBound(const Key &key) const; + iterator upperBound(const Key &key); + const_iterator upperBound(const Key &key) const; + iterator insert(const Key &key, const T &value); + + + + iterator insertMulti(const Key &key, const T &value); + + + + QMap &unite(const QMap &other); + + + typedef Key key_type; + typedef T mapped_type; + typedef qptrdiff difference_type; + typedef int size_type; + inline bool empty() const { return isEmpty(); } + + + + + +private: + void detach_helper(); + void freeData(QMapData *d); + QMapData::Node *findNode(const Key &key) const; + QMapData::Node *mutableFindNode(QMapData::Node *update[], const Key &key) const; + QMapData::Node *node_create(QMapData *d, QMapData::Node *update[], const Key &key, + const T &value); +}; + +template +inline QMap &QMap::operator=(const QMap &other) +{ + if (d != other.d) { + QMapData* o = other.d; + o->ref.ref(); + if (!d->ref.deref()) + freeData(d); + d = o; + if (!d->sharable) + detach_helper(); + } + return *this; +} + +template +inline void QMap::clear() +{ + *this = QMap(); +} + +template +inline typename QMapData::Node * +QMap::node_create(QMapData *adt, QMapData::Node *aupdate[], const Key &akey, const T &avalue) +{ + QMapData::Node *abstractNode = adt->node_create(aupdate, payload(), alignment()); + try { + Node *concreteNode = concrete(abstractNode); + new (&concreteNode->key) Key(akey); + try { + new (&concreteNode->value) T(avalue); + } catch (...) { + concreteNode->key.~Key(); + throw; + } + } catch (...) { + adt->node_delete(aupdate, payload(), abstractNode); + throw; + } +# 477 "/usr/include/qt4/QtCore/qmap.h" 3 4 + return abstractNode; +} + +template +inline QMapData::Node *QMap::findNode(const Key &akey) const +{ + QMapData::Node *cur = e; + QMapData::Node *next = e; + + for (int i = d->topLevel; i >= 0; i--) { + while ((next = cur->forward[i]) != e && qMapLessThanKey(concrete(next)->key, akey)) + cur = next; + } + + if (next != e && !qMapLessThanKey(akey, concrete(next)->key)) { + return next; + } else { + return e; + } +} + +template +inline const T QMap::value(const Key &akey) const +{ + QMapData::Node *node; + if (d->size == 0 || (node = findNode(akey)) == e) { + return T(); + } else { + return concrete(node)->value; + } +} + +template +inline const T QMap::value(const Key &akey, const T &adefaultValue) const +{ + QMapData::Node *node; + if (d->size == 0 || (node = findNode(akey)) == e) { + return adefaultValue; + } else { + return concrete(node)->value; + } +} + +template +inline const T QMap::operator[](const Key &akey) const +{ + return value(akey); +} + +template +inline T &QMap::operator[](const Key &akey) +{ + detach(); + + QMapData::Node *update[QMapData::LastLevel + 1]; + QMapData::Node *node = mutableFindNode(update, akey); + if (node == e) + node = node_create(d, update, akey, T()); + return concrete(node)->value; +} + +template +inline int QMap::count(const Key &akey) const +{ + int cnt = 0; + QMapData::Node *node = findNode(akey); + if (node != e) { + do { + ++cnt; + node = node->forward[0]; + } while (node != e && !qMapLessThanKey(akey, concrete(node)->key)); + } + return cnt; +} + +template +inline bool QMap::contains(const Key &akey) const +{ + return findNode(akey) != e; +} + +template +inline typename QMap::iterator QMap::insert(const Key &akey, + const T &avalue) +{ + detach(); + + QMapData::Node *update[QMapData::LastLevel + 1]; + QMapData::Node *node = mutableFindNode(update, akey); + if (node == e) { + node = node_create(d, update, akey, avalue); + } else { + concrete(node)->value = avalue; + } + return iterator(node); +} +# 594 "/usr/include/qt4/QtCore/qmap.h" 3 4 +template +inline typename QMap::iterator QMap::insertMulti(const Key &akey, + const T &avalue) +{ + detach(); + + QMapData::Node *update[QMapData::LastLevel + 1]; + mutableFindNode(update, akey); + return iterator(node_create(d, update, akey, avalue)); +} + +template +inline typename QMap::const_iterator QMap::find(const Key &akey) const +{ + return const_iterator(findNode(akey)); +} + +template +inline typename QMap::const_iterator QMap::constFind(const Key &akey) const +{ + return const_iterator(findNode(akey)); +} + +template +inline typename QMap::iterator QMap::find(const Key &akey) +{ + detach(); + return iterator(findNode(akey)); +} + +template +inline QMap &QMap::unite(const QMap &other) +{ + QMap copy(other); + const_iterator it = copy.constEnd(); + const const_iterator b = copy.constBegin(); + while (it != b) { + --it; + insertMulti(it.key(), it.value()); + } + return *this; +} + + + + + +template + void QMap::freeData(QMapData *x) +{ + if (QTypeInfo::isComplex || QTypeInfo::isComplex) { + QMapData *cur = x; + QMapData *next = cur->forward[0]; + while (next != x) { + cur = next; + next = cur->forward[0]; + Node *concreteNode = concrete(reinterpret_cast(cur)); + concreteNode->key.~Key(); + concreteNode->value.~T(); + } + } + x->continueFreeData(payload()); +} + + + + +template + int QMap::remove(const Key &akey) +{ + detach(); + + QMapData::Node *update[QMapData::LastLevel + 1]; + QMapData::Node *cur = e; + QMapData::Node *next = e; + int oldSize = d->size; + + for (int i = d->topLevel; i >= 0; i--) { + while ((next = cur->forward[i]) != e && qMapLessThanKey(concrete(next)->key, akey)) + cur = next; + update[i] = cur; + } + + if (next != e && !qMapLessThanKey(akey, concrete(next)->key)) { + bool deleteNext = true; + do { + cur = next; + next = cur->forward[0]; + deleteNext = (next != e && !qMapLessThanKey(concrete(cur)->key, concrete(next)->key)); + concrete(cur)->key.~Key(); + concrete(cur)->value.~T(); + d->node_delete(update, payload(), cur); + } while (deleteNext); + } + return oldSize - d->size; +} + +template + T QMap::take(const Key &akey) +{ + detach(); + + QMapData::Node *update[QMapData::LastLevel + 1]; + QMapData::Node *cur = e; + QMapData::Node *next = e; + + for (int i = d->topLevel; i >= 0; i--) { + while ((next = cur->forward[i]) != e && qMapLessThanKey(concrete(next)->key, akey)) + cur = next; + update[i] = cur; + } + + if (next != e && !qMapLessThanKey(akey, concrete(next)->key)) { + T t = concrete(next)->value; + concrete(next)->key.~Key(); + concrete(next)->value.~T(); + d->node_delete(update, payload(), next); + return t; + } + return T(); +} + +template + typename QMap::iterator QMap::erase(iterator it) +{ + QMapData::Node *update[QMapData::LastLevel + 1]; + QMapData::Node *cur = e; + QMapData::Node *next = e; + + if (it == iterator(e)) + return it; + + for (int i = d->topLevel; i >= 0; i--) { + while ((next = cur->forward[i]) != e && qMapLessThanKey(concrete(next)->key, it.key())) + cur = next; + update[i] = cur; + } + + while (next != e) { + cur = next; + next = cur->forward[0]; + if (cur == it) { + concrete(cur)->key.~Key(); + concrete(cur)->value.~T(); + d->node_delete(update, payload(), cur); + return iterator(next); + } + + for (int i = 0; i <= d->topLevel; ++i) { + if (update[i]->forward[i] != cur) + break; + update[i] = cur; + } + } + return end(); +} + +template + void QMap::detach_helper() +{ + union { QMapData *d; QMapData::Node *e; } x; + x.d = QMapData::createData(alignment()); + if (d->size) { + x.d->insertInOrder = true; + QMapData::Node *update[QMapData::LastLevel + 1]; + QMapData::Node *cur = e->forward[0]; + update[0] = x.e; + while (cur != e) { + try { + Node *concreteNode = concrete(cur); + node_create(x.d, update, concreteNode->key, concreteNode->value); + } catch (...) { + freeData(x.d); + throw; + } + cur = cur->forward[0]; + } + x.d->insertInOrder = false; + } + if (!d->ref.deref()) + freeData(d); + d = x.d; +} + +template + QMapData::Node *QMap::mutableFindNode(QMapData::Node *aupdate[], + const Key &akey) const +{ + QMapData::Node *cur = e; + QMapData::Node *next = e; + + for (int i = d->topLevel; i >= 0; i--) { + while ((next = cur->forward[i]) != e && qMapLessThanKey(concrete(next)->key, akey)) + cur = next; + aupdate[i] = cur; + } + if (next != e && !qMapLessThanKey(akey, concrete(next)->key)) { + return next; + } else { + return e; + } +} + +template + QList QMap::uniqueKeys() const +{ + QList res; + res.reserve(size()); + const_iterator i = begin(); + if (i != end()) { + for (;;) { + const Key &aKey = i.key(); + res.append(aKey); + do { + if (++i == end()) + goto break_out_of_outer_loop; + } while (!(aKey < i.key())); + } + } +break_out_of_outer_loop: + return res; +} + +template + QList QMap::keys() const +{ + QList res; + res.reserve(size()); + const_iterator i = begin(); + while (i != end()) { + res.append(i.key()); + ++i; + } + return res; +} + +template + QList QMap::keys(const T &avalue) const +{ + QList res; + const_iterator i = begin(); + while (i != end()) { + if (i.value() == avalue) + res.append(i.key()); + ++i; + } + return res; +} + +template + const Key QMap::key(const T &avalue) const +{ + return key(avalue, Key()); +} + +template + const Key QMap::key(const T &avalue, const Key &defaultKey) const +{ + const_iterator i = begin(); + while (i != end()) { + if (i.value() == avalue) + return i.key(); + ++i; + } + + return defaultKey; +} + +template + QList QMap::values() const +{ + QList res; + res.reserve(size()); + const_iterator i = begin(); + while (i != end()) { + res.append(i.value()); + ++i; + } + return res; +} + +template + QList QMap::values(const Key &akey) const +{ + QList res; + QMapData::Node *node = findNode(akey); + if (node != e) { + do { + res.append(concrete(node)->value); + node = node->forward[0]; + } while (node != e && !qMapLessThanKey(akey, concrete(node)->key)); + } + return res; +} + +template +inline typename QMap::const_iterator +QMap::lowerBound(const Key &akey) const +{ + QMapData::Node *update[QMapData::LastLevel + 1]; + mutableFindNode(update, akey); + return const_iterator(update[0]->forward[0]); +} + +template +inline typename QMap::iterator QMap::lowerBound(const Key &akey) +{ + detach(); + return static_cast(const_cast(this)->lowerBound(akey)); +} + +template +inline typename QMap::const_iterator +QMap::upperBound(const Key &akey) const +{ + QMapData::Node *update[QMapData::LastLevel + 1]; + mutableFindNode(update, akey); + QMapData::Node *node = update[0]->forward[0]; + while (node != e && !qMapLessThanKey(akey, concrete(node)->key)) + node = node->forward[0]; + return const_iterator(node); +} + +template +inline typename QMap::iterator QMap::upperBound(const Key &akey) +{ + detach(); + return static_cast(const_cast(this)->upperBound(akey)); +} + +template + bool QMap::operator==(const QMap &other) const +{ + if (size() != other.size()) + return false; + if (d == other.d) + return true; + + const_iterator it1 = begin(); + const_iterator it2 = other.begin(); + + while (it1 != end()) { + if (!(it1.value() == it2.value()) || qMapLessThanKey(it1.key(), it2.key()) || qMapLessThanKey(it2.key(), it1.key())) + return false; + ++it2; + ++it1; + } + return true; +} + + +template + QMap::QMap(const std::map &other) +{ + d = QMapData::createData(alignment()); + d->insertInOrder = true; + typename std::map::const_iterator it = other.end(); + while (it != other.begin()) { + --it; + insert((*it).first, (*it).second); + } + d->insertInOrder = false; +} + +template + std::map QMap::toStdMap() const +{ + std::map map; + const_iterator it = end(); + while (it != begin()) { + --it; + map.insert(std::pair(it.key(), it.value())); + } + return map; +} + + + +template +class QMultiMap : public QMap +{ +public: + QMultiMap() {} + QMultiMap(const QMap &other) : QMap(other) {} + inline void swap(QMultiMap &other) { QMap::swap(other); } + + inline typename QMap::iterator replace(const Key &key, const T &value) + { return QMap::insert(key, value); } + inline typename QMap::iterator insert(const Key &key, const T &value) + { return QMap::insertMulti(key, value); } + + inline QMultiMap &operator+=(const QMultiMap &other) + { this->unite(other); return *this; } + inline QMultiMap operator+(const QMultiMap &other) const + { QMultiMap result = *this; result += other; return result; } + + + + using QMap::contains; + using QMap::remove; + using QMap::count; + using QMap::find; + using QMap::constFind; +# 1014 "/usr/include/qt4/QtCore/qmap.h" 3 4 + bool contains(const Key &key, const T &value) const; + + int remove(const Key &key, const T &value); + + int count(const Key &key, const T &value) const; + + typename QMap::iterator find(const Key &key, const T &value) { + typename QMap::iterator i(find(key)); + typename QMap::iterator end(this->end()); + while (i != end && !qMapLessThanKey(key, i.key())) { + if (i.value() == value) + return i; + ++i; + } + return end; + } + typename QMap::const_iterator find(const Key &key, const T &value) const { + typename QMap::const_iterator i(constFind(key)); + typename QMap::const_iterator end(QMap::constEnd()); + while (i != end && !qMapLessThanKey(key, i.key())) { + if (i.value() == value) + return i; + ++i; + } + return end; + } + typename QMap::const_iterator constFind(const Key &key, const T &value) const + { return find(key, value); } +private: + T &operator[](const Key &key); + const T operator[](const Key &key) const; +}; + +template +inline bool QMultiMap::contains(const Key &key, const T &value) const +{ + return constFind(key, value) != QMap::constEnd(); +} + +template +inline int QMultiMap::remove(const Key &key, const T &value) +{ + int n = 0; + typename QMap::iterator i(find(key)); + typename QMap::iterator end(QMap::end()); + while (i != end && !qMapLessThanKey(key, i.key())) { + if (i.value() == value) { + i = this->erase(i); + ++n; + } else { + ++i; + } + } + return n; +} + +template +inline int QMultiMap::count(const Key &key, const T &value) const +{ + int n = 0; + typename QMap::const_iterator i(constFind(key)); + typename QMap::const_iterator end(QMap::constEnd()); + while (i != end && !qMapLessThanKey(key, i.key())) { + if (i.value() == value) + ++n; + ++i; + } + return n; +} + +template class QMapIterator { typedef typename QMap::const_iterator const_iterator; typedef const_iterator Item; QMap c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QMapIterator(const QMap &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QMapIterator &operator=(const QMap &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } }; +template class QMutableMapIterator { typedef typename QMap::iterator iterator; typedef typename QMap::const_iterator const_iterator; typedef iterator Item; QMap *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableMapIterator(QMap &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableMapIterator() { c->setSharable(true); } inline QMutableMapIterator &operator=(QMap &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } }; + + + + +# 50 "/usr/include/qt4/QtCore/qvariant.h" 2 3 4 +# 1 "/usr/include/qt4/QtCore/qhash.h" 1 3 4 +# 49 "/usr/include/qt4/QtCore/qhash.h" 3 4 +# 1 "/usr/include/qt4/QtCore/qpair.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qpair.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +template +struct QPair +{ + typedef T1 first_type; + typedef T2 second_type; + + QPair() : first(T1()), second(T2()) {} + QPair(const T1 &t1, const T2 &t2) : first(t1), second(t2) {} + + QPair &operator=(const QPair &other) + { first = other.first; second = other.second; return *this; } + + T1 first; + T2 second; +}; + +template +inline bool operator==(const QPair &p1, const QPair &p2) +{ return p1.first == p2.first && p1.second == p2.second; } + +template +inline bool operator!=(const QPair &p1, const QPair &p2) +{ return !(p1 == p2); } + +template +inline bool operator<(const QPair &p1, const QPair &p2) +{ + return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second); +} + +template +inline bool operator>(const QPair &p1, const QPair &p2) +{ + return p2 < p1; +} + +template +inline bool operator<=(const QPair &p1, const QPair &p2) +{ + return !(p2 < p1); +} + +template +inline bool operator>=(const QPair &p1, const QPair &p2) +{ + return !(p1 < p2); +} + +template + QPair qMakePair(const T1 &x, const T2 &y) +{ + return QPair(x, y); +} + + +template +inline QDataStream& operator>>(QDataStream& s, QPair& p) +{ + s >> p.first >> p.second; + return s; +} + +template +inline QDataStream& operator<<(QDataStream& s, const QPair& p) +{ + s << p.first << p.second; + return s; +} + + + + + +# 50 "/usr/include/qt4/QtCore/qhash.h" 2 3 4 + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QBitArray; +class QByteArray; +class QString; +class QStringRef; + +inline uint qHash(char key) { return uint(key); } +inline uint qHash(uchar key) { return uint(key); } +inline uint qHash(signed char key) { return uint(key); } +inline uint qHash(ushort key) { return uint(key); } +inline uint qHash(short key) { return uint(key); } +inline uint qHash(uint key) { return key; } +inline uint qHash(int key) { return uint(key); } +inline uint qHash(ulong key) +{ + if (sizeof(ulong) > sizeof(uint)) { + return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)); + } else { + return uint(key & (~0U)); + } +} +inline uint qHash(long key) { return qHash(ulong(key)); } +inline uint qHash(quint64 key) +{ + if (sizeof(quint64) > sizeof(uint)) { + return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)); + } else { + return uint(key & (~0U)); + } +} +inline uint qHash(qint64 key) { return qHash(quint64(key)); } +inline uint qHash(QChar key) { return qHash(key.unicode()); } + uint qHash(const QByteArray &key); + uint qHash(const QString &key); + uint qHash(const QStringRef &key); + uint qHash(const QBitArray &key); + + + + + +template inline uint qHash(const T *key) +{ + return qHash(reinterpret_cast(key)); +} + + + + +template inline uint qHash(const QPair &key) +{ + uint h1 = qHash(key.first); + uint h2 = qHash(key.second); + return ((h1 << 16) | (h1 >> 16)) ^ h2; +} + +struct QHashData +{ + struct Node { + Node *next; + uint h; + }; + + Node *fakeNext; + Node **buckets; + QBasicAtomicInt ref; + int size; + int nodeSize; + short userNumBits; + short numBits; + int numBuckets; + uint sharable : 1; + uint strictAlignment : 1; + uint reserved : 30; + + void *allocateNode(); + void *allocateNode(int nodeAlign); + void freeNode(void *node); + QHashData *detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize); + QHashData *detach_helper2(void (*node_duplicate)(Node *, void *), void (*node_delete)(Node *), + int nodeSize, int nodeAlign); + void mightGrow(); + bool willGrow(); + void hasShrunk(); + void rehash(int hint); + void free_helper(void (*node_delete)(Node *)); + void destroyAndFree(); + Node *firstNode(); + + + + + static Node *nextNode(Node *node); + static Node *previousNode(Node *node); + + static QHashData shared_null; +}; + +inline void QHashData::mightGrow() +{ + if (size >= numBuckets) + rehash(numBits + 1); +} + +inline bool QHashData::willGrow() +{ + if (size >= numBuckets) { + rehash(numBits + 1); + return true; + } else { + return false; + } +} + +inline void QHashData::hasShrunk() +{ + if (size <= (numBuckets >> 3) && numBits > userNumBits) { + try { + rehash(qMax(int(numBits) - 2, int(userNumBits))); + } catch (const std::bad_alloc &) { + + } + } +} + +inline QHashData::Node *QHashData::firstNode() +{ + Node *e = reinterpret_cast(this); + Node **bucket = buckets; + int n = numBuckets; + while (n--) { + if (*bucket != e) + return *bucket; + ++bucket; + } + return e; +} + +struct QHashDummyValue +{ +}; + +inline bool operator==(const QHashDummyValue & , const QHashDummyValue & ) +{ + return true; +} + +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QHashDummyValue)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QHashDummyValue"; } }; + +template +struct QHashDummyNode +{ + QHashDummyNode *next; + uint h; + Key key; + + inline QHashDummyNode(const Key &key0) : key(key0) {} +}; + +template +struct QHashNode +{ + QHashNode *next; + uint h; + Key key; + T value; + + inline QHashNode(const Key &key0) : key(key0) {} + inline QHashNode(const Key &key0, const T &value0) : key(key0), value(value0) {} + inline bool same_key(uint h0, const Key &key0) { return h0 == h && key0 == key; } +}; +# 250 "/usr/include/qt4/QtCore/qhash.h" 3 4 +template struct QHashDummyNode { QHashDummyNode *next; union { uint h; short key; }; inline QHashDummyNode(short ) {} }; template struct QHashNode { QHashNode *next; union { uint h; short key; }; T value; inline QHashNode(short ) {} inline QHashNode(short , const T &value0) : value(value0) {} inline bool same_key(uint h0, short) { return h0 == h; } }; +template struct QHashDummyNode { QHashDummyNode *next; union { uint h; ushort key; }; inline QHashDummyNode(ushort ) {} }; template struct QHashNode { QHashNode *next; union { uint h; ushort key; }; T value; inline QHashNode(ushort ) {} inline QHashNode(ushort , const T &value0) : value(value0) {} inline bool same_key(uint h0, ushort) { return h0 == h; } }; + +template struct QHashDummyNode { QHashDummyNode *next; union { uint h; int key; }; inline QHashDummyNode(int ) {} }; template struct QHashNode { QHashNode *next; union { uint h; int key; }; T value; inline QHashNode(int ) {} inline QHashNode(int , const T &value0) : value(value0) {} inline bool same_key(uint h0, int) { return h0 == h; } }; +template struct QHashDummyNode { QHashDummyNode *next; union { uint h; uint key; }; inline QHashDummyNode(uint ) {} }; template struct QHashNode { QHashNode *next; union { uint h; uint key; }; T value; inline QHashNode(uint ) {} inline QHashNode(uint , const T &value0) : value(value0) {} inline bool same_key(uint h0, uint) { return h0 == h; } }; + + +template +class QHash +{ + typedef QHashDummyNode DummyNode; + typedef QHashNode Node; + + union { + QHashData *d; + QHashNode *e; + }; + + static inline Node *concrete(QHashData::Node *node) { + return reinterpret_cast(node); + } + + + static inline int alignOfNode() { return qMax(sizeof(void*), __alignof__(Node)); } + static inline int alignOfDummyNode() { return qMax(sizeof(void*), __alignof__(DummyNode)); } + + + + + +public: + inline QHash() : d(&QHashData::shared_null) { d->ref.ref(); } + inline QHash(const QHash &other) : d(other.d) { d->ref.ref(); if (!d->sharable) detach(); } + inline ~QHash() { if (!d->ref.deref()) freeData(d); } + + QHash &operator=(const QHash &other); + + + + + inline void swap(QHash &other) { qSwap(d, other.d); } + + bool operator==(const QHash &other) const; + inline bool operator!=(const QHash &other) const { return !(*this == other); } + + inline int size() const { return d->size; } + + inline bool isEmpty() const { return d->size == 0; } + + inline int capacity() const { return d->numBuckets; } + void reserve(int size); + inline void squeeze() { reserve(1); } + + inline void detach() { if (d->ref != 1) detach_helper(); } + inline bool isDetached() const { return d->ref == 1; } + inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } + inline bool isSharedWith(const QHash &other) const { return d == other.d; } + + void clear(); + + int remove(const Key &key); + T take(const Key &key); + + bool contains(const Key &key) const; + const Key key(const T &value) const; + const Key key(const T &value, const Key &defaultKey) const; + const T value(const Key &key) const; + const T value(const Key &key, const T &defaultValue) const; + T &operator[](const Key &key); + const T operator[](const Key &key) const; + + QList uniqueKeys() const; + QList keys() const; + QList keys(const T &value) const; + QList values() const; + QList values(const Key &key) const; + int count(const Key &key) const; + + class const_iterator; + + class iterator + { + friend class const_iterator; + QHashData::Node *i; + + public: + typedef std::bidirectional_iterator_tag iterator_category; + typedef qptrdiff difference_type; + typedef T value_type; + typedef T *pointer; + typedef T &reference; + + + inline operator Node *() const { return concrete(i); } + inline iterator() : i(0) { } + explicit inline iterator(void *node) : i(reinterpret_cast(node)) { } + + inline const Key &key() const { return concrete(i)->key; } + inline T &value() const { return concrete(i)->value; } + inline T &operator*() const { return concrete(i)->value; } + inline T *operator->() const { return &concrete(i)->value; } + inline bool operator==(const iterator &o) const { return i == o.i; } + inline bool operator!=(const iterator &o) const { return i != o.i; } + + inline iterator &operator++() { + i = QHashData::nextNode(i); + return *this; + } + inline iterator operator++(int) { + iterator r = *this; + i = QHashData::nextNode(i); + return r; + } + inline iterator &operator--() { + i = QHashData::previousNode(i); + return *this; + } + inline iterator operator--(int) { + iterator r = *this; + i = QHashData::previousNode(i); + return r; + } + inline iterator operator+(int j) const + { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } + inline iterator operator-(int j) const { return operator+(-j); } + inline iterator &operator+=(int j) { return *this = *this + j; } + inline iterator &operator-=(int j) { return *this = *this - j; } + + + + + + public: + + inline bool operator==(const const_iterator &o) const + { return i == o.i; } + inline bool operator!=(const const_iterator &o) const + { return i != o.i; } + + private: + + inline operator bool() const { return false; } + }; + friend class iterator; + + class const_iterator + { + friend class iterator; + QHashData::Node *i; + + public: + typedef std::bidirectional_iterator_tag iterator_category; + typedef qptrdiff difference_type; + typedef T value_type; + typedef const T *pointer; + typedef const T &reference; + + + inline operator Node *() const { return concrete(i); } + inline const_iterator() : i(0) { } + explicit inline const_iterator(void *node) + : i(reinterpret_cast(node)) { } + + + + inline const_iterator(const iterator &o) + + { i = o.i; } + + inline const Key &key() const { return concrete(i)->key; } + inline const T &value() const { return concrete(i)->value; } + inline const T &operator*() const { return concrete(i)->value; } + inline const T *operator->() const { return &concrete(i)->value; } + inline bool operator==(const const_iterator &o) const { return i == o.i; } + inline bool operator!=(const const_iterator &o) const { return i != o.i; } + + inline const_iterator &operator++() { + i = QHashData::nextNode(i); + return *this; + } + inline const_iterator operator++(int) { + const_iterator r = *this; + i = QHashData::nextNode(i); + return r; + } + inline const_iterator &operator--() { + i = QHashData::previousNode(i); + return *this; + } + inline const_iterator operator--(int) { + const_iterator r = *this; + i = QHashData::previousNode(i); + return r; + } + inline const_iterator operator+(int j) const + { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } + inline const_iterator operator-(int j) const { return operator+(-j); } + inline const_iterator &operator+=(int j) { return *this = *this + j; } + inline const_iterator &operator-=(int j) { return *this = *this - j; } +# 457 "/usr/include/qt4/QtCore/qhash.h" 3 4 + private: + + inline operator bool() const { return false; } + }; + friend class const_iterator; + + + inline iterator begin() { detach(); return iterator(d->firstNode()); } + inline const_iterator begin() const { return const_iterator(d->firstNode()); } + inline const_iterator constBegin() const { return const_iterator(d->firstNode()); } + inline iterator end() { detach(); return iterator(e); } + inline const_iterator end() const { return const_iterator(e); } + inline const_iterator constEnd() const { return const_iterator(e); } + iterator erase(iterator it); + + + typedef iterator Iterator; + typedef const_iterator ConstIterator; + inline int count() const { return d->size; } + iterator find(const Key &key); + const_iterator find(const Key &key) const; + const_iterator constFind(const Key &key) const; + iterator insert(const Key &key, const T &value); + iterator insertMulti(const Key &key, const T &value); + QHash &unite(const QHash &other); + + + typedef T mapped_type; + typedef Key key_type; + typedef qptrdiff difference_type; + typedef int size_type; + + inline bool empty() const { return isEmpty(); } + + + + + + +private: + void detach_helper(); + void freeData(QHashData *d); + Node **findNode(const Key &key, uint *hp = 0) const; + Node *createNode(uint h, const Key &key, const T &value, Node **nextNode); + void deleteNode(Node *node); + static void deleteNode2(QHashData::Node *node); + + static void duplicateNode(QHashData::Node *originalNode, void *newNode); +}; + + +template +inline void QHash::deleteNode(Node *node) +{ + deleteNode2(reinterpret_cast(node)); + d->freeNode(node); +} + +template +inline void QHash::deleteNode2(QHashData::Node *node) +{ + + + + concrete(node)->~Node(); + +} + +template +inline void QHash::duplicateNode(QHashData::Node *node, void *newNode) +{ + Node *concreteNode = concrete(node); + if (QTypeInfo::isDummy) { + (void) new (newNode) DummyNode(concreteNode->key); + } else { + (void) new (newNode) Node(concreteNode->key, concreteNode->value); + } +} + +template +inline typename QHash::Node * +QHash::createNode(uint ah, const Key &akey, const T &avalue, Node **anextNode) +{ + Node *node; + + if (QTypeInfo::isDummy) { + node = reinterpret_cast(new (d->allocateNode(alignOfDummyNode())) DummyNode(akey)); + } else { + node = new (d->allocateNode(alignOfNode())) Node(akey, avalue); + } + + node->h = ah; + node->next = *anextNode; + *anextNode = node; + ++d->size; + return node; +} + +template +inline QHash &QHash::unite(const QHash &other) +{ + QHash copy(other); + const_iterator it = copy.constEnd(); + while (it != copy.constBegin()) { + --it; + insertMulti(it.key(), it.value()); + } + return *this; +} + +template + void QHash::freeData(QHashData *x) +{ + x->free_helper(deleteNode2); +} + +template +inline void QHash::clear() +{ + *this = QHash(); +} + +template + void QHash::detach_helper() +{ + QHashData *x = d->detach_helper2(duplicateNode, deleteNode2, + QTypeInfo::isDummy ? sizeof(DummyNode) : sizeof(Node), + QTypeInfo::isDummy ? alignOfDummyNode() : alignOfNode()); + if (!d->ref.deref()) + freeData(d); + d = x; +} + +template +inline QHash &QHash::operator=(const QHash &other) +{ + if (d != other.d) { + QHashData *o = other.d; + o->ref.ref(); + if (!d->ref.deref()) + freeData(d); + d = o; + if (!d->sharable) + detach_helper(); + } + return *this; +} + +template +inline const T QHash::value(const Key &akey) const +{ + Node *node; + if (d->size == 0 || (node = *findNode(akey)) == e) { + return T(); + } else { + return node->value; + } +} + +template +inline const T QHash::value(const Key &akey, const T &adefaultValue) const +{ + Node *node; + if (d->size == 0 || (node = *findNode(akey)) == e) { + return adefaultValue; + } else { + return node->value; + } +} + +template + QList QHash::uniqueKeys() const +{ + QList res; + res.reserve(size()); + const_iterator i = begin(); + if (i != end()) { + for (;;) { + const Key &aKey = i.key(); + res.append(aKey); + do { + if (++i == end()) + goto break_out_of_outer_loop; + } while (aKey == i.key()); + } + } +break_out_of_outer_loop: + return res; +} + +template + QList QHash::keys() const +{ + QList res; + res.reserve(size()); + const_iterator i = begin(); + while (i != end()) { + res.append(i.key()); + ++i; + } + return res; +} + +template + QList QHash::keys(const T &avalue) const +{ + QList res; + const_iterator i = begin(); + while (i != end()) { + if (i.value() == avalue) + res.append(i.key()); + ++i; + } + return res; +} + +template + const Key QHash::key(const T &avalue) const +{ + return key(avalue, Key()); +} + +template + const Key QHash::key(const T &avalue, const Key &defaultValue) const +{ + const_iterator i = begin(); + while (i != end()) { + if (i.value() == avalue) + return i.key(); + ++i; + } + + return defaultValue; +} + +template + QList QHash::values() const +{ + QList res; + res.reserve(size()); + const_iterator i = begin(); + while (i != end()) { + res.append(i.value()); + ++i; + } + return res; +} + +template + QList QHash::values(const Key &akey) const +{ + QList res; + Node *node = *findNode(akey); + if (node != e) { + do { + res.append(node->value); + } while ((node = node->next) != e && node->key == akey); + } + return res; +} + +template + int QHash::count(const Key &akey) const +{ + int cnt = 0; + Node *node = *findNode(akey); + if (node != e) { + do { + ++cnt; + } while ((node = node->next) != e && node->key == akey); + } + return cnt; +} + +template +inline const T QHash::operator[](const Key &akey) const +{ + return value(akey); +} + +template +inline T &QHash::operator[](const Key &akey) +{ + detach(); + + uint h; + Node **node = findNode(akey, &h); + if (*node == e) { + if (d->willGrow()) + node = findNode(akey, &h); + return createNode(h, akey, T(), node)->value; + } + return (*node)->value; +} + +template +inline typename QHash::iterator QHash::insert(const Key &akey, + const T &avalue) +{ + detach(); + + uint h; + Node **node = findNode(akey, &h); + if (*node == e) { + if (d->willGrow()) + node = findNode(akey, &h); + return iterator(createNode(h, akey, avalue, node)); + } + + if (!QTypeInfo::isDummy) + (*node)->value = avalue; + return iterator(*node); +} + +template +inline typename QHash::iterator QHash::insertMulti(const Key &akey, + const T &avalue) +{ + detach(); + d->willGrow(); + + uint h; + Node **nextNode = findNode(akey, &h); + return iterator(createNode(h, akey, avalue, nextNode)); +} + +template + int QHash::remove(const Key &akey) +{ + if (isEmpty()) + return 0; + detach(); + + int oldSize = d->size; + Node **node = findNode(akey); + if (*node != e) { + bool deleteNext = true; + do { + Node *next = (*node)->next; + deleteNext = (next != e && next->key == (*node)->key); + deleteNode(*node); + *node = next; + --d->size; + } while (deleteNext); + d->hasShrunk(); + } + return oldSize - d->size; +} + +template + T QHash::take(const Key &akey) +{ + if (isEmpty()) + return T(); + detach(); + + Node **node = findNode(akey); + if (*node != e) { + T t = (*node)->value; + Node *next = (*node)->next; + deleteNode(*node); + *node = next; + --d->size; + d->hasShrunk(); + return t; + } + return T(); +} + +template + typename QHash::iterator QHash::erase(iterator it) +{ + if (it == iterator(e)) + return it; + + iterator ret = it; + ++ret; + + Node *node = it; + Node **node_ptr = reinterpret_cast(&d->buckets[node->h % d->numBuckets]); + while (*node_ptr != node) + node_ptr = &(*node_ptr)->next; + *node_ptr = node->next; + deleteNode(node); + --d->size; + return ret; +} + +template +inline void QHash::reserve(int asize) +{ + detach(); + d->rehash(-qMax(asize, 1)); +} + +template +inline typename QHash::const_iterator QHash::find(const Key &akey) const +{ + return const_iterator(*findNode(akey)); +} + +template +inline typename QHash::const_iterator QHash::constFind(const Key &akey) const +{ + return const_iterator(*findNode(akey)); +} + +template +inline typename QHash::iterator QHash::find(const Key &akey) +{ + detach(); + return iterator(*findNode(akey)); +} + +template +inline bool QHash::contains(const Key &akey) const +{ + return *findNode(akey) != e; +} + +template + typename QHash::Node **QHash::findNode(const Key &akey, + uint *ahp) const +{ + Node **node; + uint h = qHash(akey); + + if (d->numBuckets) { + node = reinterpret_cast(&d->buckets[h % d->numBuckets]); + qt_noop(); + while (*node != e && !(*node)->same_key(h, akey)) + node = &(*node)->next; + } else { + node = const_cast(reinterpret_cast(&e)); + } + if (ahp) + *ahp = h; + return node; +} + +template + bool QHash::operator==(const QHash &other) const +{ + if (size() != other.size()) + return false; + if (d == other.d) + return true; + + const_iterator it = begin(); + + while (it != end()) { + const Key &akey = it.key(); + + const_iterator it2 = other.find(akey); + do { + if (it2 == other.end() || !(it2.key() == akey)) + return false; + if (!QTypeInfo::isDummy && !(it.value() == it2.value())) + return false; + ++it; + ++it2; + } while (it != end() && it.key() == akey); + } + return true; +} + +template +class QMultiHash : public QHash +{ +public: + QMultiHash() {} + QMultiHash(const QHash &other) : QHash(other) {} + inline void swap(QMultiHash &other) { QHash::swap(other); } + + inline typename QHash::iterator replace(const Key &key, const T &value) + { return QHash::insert(key, value); } + + inline typename QHash::iterator insert(const Key &key, const T &value) + { return QHash::insertMulti(key, value); } + + inline QMultiHash &operator+=(const QMultiHash &other) + { this->unite(other); return *this; } + inline QMultiHash operator+(const QMultiHash &other) const + { QMultiHash result = *this; result += other; return result; } + + + + using QHash::contains; + using QHash::remove; + using QHash::count; + using QHash::find; + using QHash::constFind; +# 966 "/usr/include/qt4/QtCore/qhash.h" 3 4 + bool contains(const Key &key, const T &value) const; + + int remove(const Key &key, const T &value); + + int count(const Key &key, const T &value) const; + + typename QHash::iterator find(const Key &key, const T &value) { + typename QHash::iterator i(find(key)); + typename QHash::iterator end(this->end()); + while (i != end && i.key() == key) { + if (i.value() == value) + return i; + ++i; + } + return end; + } + typename QHash::const_iterator find(const Key &key, const T &value) const { + typename QHash::const_iterator i(constFind(key)); + typename QHash::const_iterator end(QHash::constEnd()); + while (i != end && i.key() == key) { + if (i.value() == value) + return i; + ++i; + } + return end; + } + typename QHash::const_iterator constFind(const Key &key, const T &value) const + { return find(key, value); } +private: + T &operator[](const Key &key); + const T operator[](const Key &key) const; +}; + +template +inline bool QMultiHash::contains(const Key &key, const T &value) const +{ + return constFind(key, value) != QHash::constEnd(); +} + +template +inline int QMultiHash::remove(const Key &key, const T &value) +{ + int n = 0; + typename QHash::iterator i(find(key)); + typename QHash::iterator end(QHash::end()); + while (i != end && i.key() == key) { + if (i.value() == value) { + i = this->erase(i); + ++n; + } else { + ++i; + } + } + return n; +} + +template +inline int QMultiHash::count(const Key &key, const T &value) const +{ + int n = 0; + typename QHash::const_iterator i(constFind(key)); + typename QHash::const_iterator end(QHash::constEnd()); + while (i != end && i.key() == key) { + if (i.value() == value) + ++n; + ++i; + } + return n; +} + +template class QHashIterator { typedef typename QHash::const_iterator const_iterator; typedef const_iterator Item; QHash c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QHashIterator(const QHash &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QHashIterator &operator=(const QHash &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } }; +template class QMutableHashIterator { typedef typename QHash::iterator iterator; typedef typename QHash::const_iterator const_iterator; typedef iterator Item; QHash *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableHashIterator(QHash &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableHashIterator() { c->setSharable(true); } inline QMutableHashIterator &operator=(QHash &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } }; + + + + +# 51 "/usr/include/qt4/QtCore/qvariant.h" 2 3 4 + + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QBitArray; +class QDataStream; +class QDate; +class QDateTime; +class QEasingCurve; +class QLine; +class QLineF; +class QLocale; +class QMatrix; +class QTransform; +class QStringList; +class QTime; +class QPoint; +class QPointF; +class QSize; +class QSizeF; +class QRect; +class QRectF; + +class QRegExp; + +class QTextFormat; +class QTextLength; +class QUrl; +class QVariant; +class QVariantComparisonHelper; + +template +inline QVariant qVariantFromValue(const T &); + +template +inline T qvariant_cast(const QVariant &); + +class QVariant +{ + public: + enum Type { + Invalid = 0, + + Bool = 1, + Int = 2, + UInt = 3, + LongLong = 4, + ULongLong = 5, + Double = 6, + Char = 7, + Map = 8, + List = 9, + String = 10, + StringList = 11, + ByteArray = 12, + BitArray = 13, + Date = 14, + Time = 15, + DateTime = 16, + Url = 17, + Locale = 18, + Rect = 19, + RectF = 20, + Size = 21, + SizeF = 22, + Line = 23, + LineF = 24, + Point = 25, + PointF = 26, + RegExp = 27, + Hash = 28, + EasingCurve = 29, + LastCoreType = EasingCurve, + + + + + + Font = 64, + Pixmap = 65, + Brush = 66, + Color = 67, + Palette = 68, + Icon = 69, + Image = 70, + Polygon = 71, + Region = 72, + Bitmap = 73, + Cursor = 74, + SizePolicy = 75, + KeySequence = 76, + Pen = 77, + TextLength = 78, + TextFormat = 79, + Matrix = 80, + Transform = 81, + Matrix4x4 = 82, + Vector2D = 83, + Vector3D = 84, + Vector4D = 85, + Quaternion = 86, + LastGuiType = Quaternion, + + UserType = 127, + + + + + + LastType = 0xffffffff + }; + + inline QVariant(); + ~QVariant(); + QVariant(Type type); + QVariant(int typeOrUserType, const void *copy); + QVariant(int typeOrUserType, const void *copy, uint flags); + QVariant(const QVariant &other); + + + QVariant(QDataStream &s); + + + QVariant(int i); + QVariant(uint ui); + QVariant(qlonglong ll); + QVariant(qulonglong ull); + QVariant(bool b); + QVariant(double d); + QVariant(float f) { d.is_null = false; d.type = QMetaType::Float; d.data.f = f; } + + QVariant(const char *str); + + + QVariant(const QByteArray &bytearray); + QVariant(const QBitArray &bitarray); + QVariant(const QString &string); + QVariant(const QLatin1String &string); + QVariant(const QStringList &stringlist); + QVariant(const QChar &qchar); + QVariant(const QDate &date); + QVariant(const QTime &time); + QVariant(const QDateTime &datetime); + QVariant(const QList &list); + QVariant(const QMap &map); + QVariant(const QHash &hash); + + QVariant(const QSize &size); + QVariant(const QSizeF &size); + QVariant(const QPoint &pt); + QVariant(const QPointF &pt); + QVariant(const QLine &line); + QVariant(const QLineF &line); + QVariant(const QRect &rect); + QVariant(const QRectF &rect); + + QVariant(const QUrl &url); + QVariant(const QLocale &locale); + + QVariant(const QRegExp ®Exp); + + + QVariant(const QEasingCurve &easing); + + QVariant(Qt::GlobalColor color); + + QVariant& operator=(const QVariant &other); + + + + + + inline void swap(QVariant &other) { qSwap(d, other.d); } + + Type type() const; + int userType() const; + const char *typeName() const; + + bool canConvert(Type t) const; + bool convert(Type t); +# 243 "/usr/include/qt4/QtCore/qvariant.h" 3 4 + inline bool isValid() const; + bool isNull() const; + + void clear(); + + void detach(); + inline bool isDetached() const; + + int toInt(bool *ok = 0) const; + uint toUInt(bool *ok = 0) const; + qlonglong toLongLong(bool *ok = 0) const; + qulonglong toULongLong(bool *ok = 0) const; + bool toBool() const; + double toDouble(bool *ok = 0) const; + float toFloat(bool *ok = 0) const; + qreal toReal(bool *ok = 0) const; + QByteArray toByteArray() const; + QBitArray toBitArray() const; + QString toString() const; + QStringList toStringList() const; + QChar toChar() const; + QDate toDate() const; + QTime toTime() const; + QDateTime toDateTime() const; + QList toList() const; + QMap toMap() const; + QHash toHash() const; + + + QPoint toPoint() const; + QPointF toPointF() const; + QRect toRect() const; + QSize toSize() const; + QSizeF toSizeF() const; + QLine toLine() const; + QLineF toLineF() const; + QRectF toRectF() const; + + QUrl toUrl() const; + QLocale toLocale() const; + + QRegExp toRegExp() const; + + + QEasingCurve toEasingCurve() const; +# 312 "/usr/include/qt4/QtCore/qvariant.h" 3 4 + void load(QDataStream &ds); + void save(QDataStream &ds) const; + + static const char *typeToName(Type type); + static Type nameToType(const char *name); + + + + + + + + void *data(); + const void *constData() const; + inline const void *data() const { return constData(); } + + template + inline void setValue(const T &value); + + template + inline T value() const + { return qvariant_cast(*this); } + + template + static inline QVariant fromValue(const T &value) + { return qVariantFromValue(value); } + + template + bool canConvert() const + { return canConvert(Type(qMetaTypeId())); } + + public: + + struct PrivateShared + { + inline PrivateShared(void *v) : ptr(v), ref(1) { } + void *ptr; + QAtomicInt ref; + }; + struct Private + { + inline Private(): type(Invalid), is_shared(false), is_null(true) { data.ptr = 0; } + inline Private(const Private &other) + : data(other.data), type(other.type), + is_shared(other.is_shared), is_null(other.is_null) + {} + union Data + { + char c; + int i; + uint u; + bool b; + double d; + float f; + qreal real; + qlonglong ll; + qulonglong ull; + QObject *o; + void *ptr; + PrivateShared *shared; + } data; + uint type : 30; + uint is_shared : 1; + uint is_null : 1; + }; + public: + typedef void (*f_construct)(Private *, const void *); + typedef void (*f_clear)(Private *); + typedef bool (*f_null)(const Private *); + + typedef void (*f_load)(Private *, QDataStream &); + typedef void (*f_save)(const Private *, QDataStream &); + + typedef bool (*f_compare)(const Private *, const Private *); + typedef bool (*f_convert)(const QVariant::Private *d, Type t, void *, bool *); + typedef bool (*f_canConvert)(const QVariant::Private *d, Type t); + typedef void (*f_debugStream)(QDebug, const QVariant &); + struct Handler { + f_construct construct; + f_clear clear; + f_null isNull; + + f_load load; + f_save save; + + f_compare compare; + f_convert convert; + f_canConvert canConvert; + f_debugStream debugStream; + }; + + + inline bool operator==(const QVariant &v) const + { return cmp(v); } + inline bool operator!=(const QVariant &v) const + { return !cmp(v); } + +protected: + friend inline bool qvariant_cast_helper(const QVariant &, QVariant::Type, void *); + friend int qRegisterGuiVariant(); + friend int qUnregisterGuiVariant(); + friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &); + + friend QDebug operator<<(QDebug, const QVariant &); + + Private d; + + static const Handler *handler; + + void create(int type, const void *copy); + + + + bool cmp(const QVariant &other) const; + +private: + + inline QVariant(void *) { qt_noop(); } + + + + + + + inline QVariant(bool, int) { qt_noop(); } + +public: + typedef Private DataPtr; + inline DataPtr &data_ptr() { return d; } +}; + +typedef QList QVariantList; +typedef QMap QVariantMap; +typedef QHash QVariantHash; + +inline bool qvariant_cast_helper(const QVariant &v, QVariant::Type tp, void *ptr) +{ return QVariant::handler->convert(&v.d, tp, ptr, 0); } + +template +inline QVariant qVariantFromValue(const T &t) +{ + return QVariant(qMetaTypeId(reinterpret_cast(0)), &t, QTypeInfo::isPointer); +} + +template <> +inline QVariant qVariantFromValue(const QVariant &t) { return t; } + +template +inline void qVariantSetValue(QVariant &v, const T &t) +{ + + const uint type = qMetaTypeId(reinterpret_cast(0)); + QVariant::Private &d = v.data_ptr(); + if (v.isDetached() && (type == d.type || (type <= uint(QVariant::Char) && d.type <= uint(QVariant::Char)))) { + d.type = type; + d.is_null = false; + T *old = reinterpret_cast(d.is_shared ? d.data.shared->ptr : &d.data.ptr); + if (QTypeInfo::isComplex) + old->~T(); + new (old) T(t); + } else { + v = QVariant(type, &t, QTypeInfo::isPointer); + } +} + +template <> +inline void qVariantSetValue(QVariant &v, const QVariant &t) +{ + v = t; +} + + +inline QVariant::QVariant() {} +inline bool QVariant::isValid() const { return d.type != Invalid; } +# 526 "/usr/include/qt4/QtCore/qvariant.h" 3 4 +template +inline void QVariant::setValue(const T &avalue) +{ qVariantSetValue(*this, avalue); } + + + QDataStream& operator>> (QDataStream& s, QVariant& p); + QDataStream& operator<< (QDataStream& s, const QVariant& p); + QDataStream& operator>> (QDataStream& s, QVariant::Type& p); + QDataStream& operator<< (QDataStream& s, const QVariant::Type p); + + +inline bool QVariant::isDetached() const +{ return !d.is_shared || d.data.shared->ref == 1; } +# 549 "/usr/include/qt4/QtCore/qvariant.h" 3 4 +class QVariantComparisonHelper +{ +public: + inline QVariantComparisonHelper(const QVariant &var) + : v(&var) {} +private: + friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &); + const QVariant *v; +}; + +inline bool operator==(const QVariant &v1, const QVariantComparisonHelper &v2) +{ + return v1.cmp(*v2.v); +} + +inline bool operator!=(const QVariant &v1, const QVariantComparisonHelper &v2) +{ + return !operator==(v1, v2); +} + + + +template inline T qvariant_cast(const QVariant &v) +{ + const int vid = qMetaTypeId(static_cast(0)); + if (vid == v.userType()) + return *reinterpret_cast(v.constData()); + if (vid < int(QMetaType::User)) { + T t; + if (qvariant_cast_helper(v, QVariant::Type(vid), &t)) + return t; + } + return T(); +} + +template<> inline QVariant qvariant_cast(const QVariant &v) +{ + if (v.userType() == QMetaType::QVariant) + return *reinterpret_cast(v.constData()); + return v; +} + + +template +inline T qVariantValue(const QVariant &variant) +{ return qvariant_cast(variant); } + +template +inline bool qVariantCanConvert(const QVariant &variant) +{ return variant.template canConvert(); } + + + +template <> inline bool qIsDetached(QVariant &t) { return t.isDetached(); } template <> inline void qSwap(QVariant &value1, QVariant &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); } namespace std { template<> inline void swap< ::QVariant>(::QVariant &value1, ::QVariant &value2) { swap(value1.data_ptr(), value2.data_ptr()); } } +template<> class QTypeInfo { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QVariant)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QVariant"; } }; + + + QDebug operator<<(QDebug, const QVariant &); + QDebug operator<<(QDebug, const QVariant::Type); + + + + + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QVariantList }; static inline int qt_metatype_id() { return QMetaType::QVariantList; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QVariantMap }; static inline int qt_metatype_id() { return QMetaType::QVariantMap; } }; + template<> struct QMetaTypeId2 { enum { Defined = 1, MetaType = QMetaType::QVariantHash }; static inline int qt_metatype_id() { return QMetaType::QVariantHash; } }; + + +# 46 "/usr/include/qt4/QtCore/qmimedata.h" 2 3 4 + + + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QUrl; +class QMimeDataPrivate; + +class QMimeData : public QObject +{ + public: template inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); +public: + QMimeData(); + ~QMimeData(); + + QList urls() const; + void setUrls(const QList &urls); + bool hasUrls() const; + + QString text() const; + void setText(const QString &text); + bool hasText() const; + + QString html() const; + void setHtml(const QString &html); + bool hasHtml() const; + + QVariant imageData() const; + void setImageData(const QVariant &image); + bool hasImage() const; + + QVariant colorData() const; + void setColorData(const QVariant &color); + bool hasColor() const; + + QByteArray data(const QString &mimetype) const; + void setData(const QString &mimetype, const QByteArray &data); + void removeFormat(const QString &mimetype); + + virtual bool hasFormat(const QString &mimetype) const; + virtual QStringList formats() const; + + void clear(); +protected: + virtual QVariant retrieveData(const QString &mimetype, + QVariant::Type preferredType) const; +private: + QMimeData(const QMimeData &); QMimeData &operator=(const QMimeData &); + inline QMimeDataPrivate* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); } inline const QMimeDataPrivate* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); } friend class QMimeDataPrivate; +}; + + + + +# 46 "/usr/include/qt4/QtGui/qmime.h" 2 3 4 + + + + + +typedef QtValidLicenseForGuiModule QtGuiModule; + +class QMimeSource +{ +public: + virtual ~QMimeSource(); + virtual const char* format(int n = 0) const = 0; + virtual bool provides(const char*) const; + virtual QByteArray encodedData(const char*) const = 0; +}; +# 172 "/usr/include/qt4/QtGui/qmime.h" 3 4 + + + +# 53 "/usr/include/qt4/QtGui/qevent.h" 2 3 4 +# 1 "/usr/include/qt4/QtGui/qdrag.h" 1 3 4 +# 47 "/usr/include/qt4/QtGui/qdrag.h" 3 4 + + + + +typedef QtValidLicenseForGuiModule QtGuiModule; + + +class QMimeData; +class QDragPrivate; +class QWidget; +class QPixmap; +class QPoint; +class QDragManager; + +class QDrag : public QObject +{ + public: template inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); + inline QDragPrivate* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); } inline const QDragPrivate* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); } friend class QDragPrivate; +public: + explicit QDrag(QWidget *dragSource); + ~QDrag(); + + void setMimeData(QMimeData *data); + QMimeData *mimeData() const; + + void setPixmap(const QPixmap &); + QPixmap pixmap() const; + + void setHotSpot(const QPoint &hotspot); + QPoint hotSpot() const; + + QWidget *source() const; + QWidget *target() const; + + Qt::DropAction start(Qt::DropActions supportedActions = Qt::CopyAction); + Qt::DropAction exec(Qt::DropActions supportedActions = Qt::MoveAction); + Qt::DropAction exec(Qt::DropActions supportedActions, Qt::DropAction defaultAction); + + void setDragCursor(const QPixmap &cursor, Qt::DropAction action); + +protected: + void actionChanged(Qt::DropAction action); + void targetChanged(QWidget *newTarget); + +private: + + + + friend class QDragManager; + QDrag(const QDrag &); QDrag &operator=(const QDrag &); +}; + + + + + + +# 54 "/usr/include/qt4/QtGui/qevent.h" 2 3 4 + + +# 1 "/usr/include/qt4/QtCore/qset.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qset.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +template +class QSet +{ + typedef QHash Hash; + +public: + inline QSet() {} + inline QSet(const QSet &other) : q_hash(other.q_hash) {} + + inline QSet &operator=(const QSet &other) + { q_hash = other.q_hash; return *this; } + + + + + inline void swap(QSet &other) { q_hash.swap(other.q_hash); } + + inline bool operator==(const QSet &other) const + { return q_hash == other.q_hash; } + inline bool operator!=(const QSet &other) const + { return q_hash != other.q_hash; } + + inline int size() const { return q_hash.size(); } + + inline bool isEmpty() const { return q_hash.isEmpty(); } + + inline int capacity() const { return q_hash.capacity(); } + inline void reserve(int size); + inline void squeeze() { q_hash.squeeze(); } + + inline void detach() { q_hash.detach(); } + inline bool isDetached() const { return q_hash.isDetached(); } + inline void setSharable(bool sharable) { q_hash.setSharable(sharable); } + + inline void clear() { q_hash.clear(); } + + inline bool remove(const T &value) { return q_hash.remove(value) != 0; } + + inline bool contains(const T &value) const { return q_hash.contains(value); } + + bool contains(const QSet &set) const; + + class const_iterator; + + class iterator + { + typedef QHash Hash; + typename Hash::iterator i; + friend class const_iterator; + + public: + typedef std::bidirectional_iterator_tag iterator_category; + typedef qptrdiff difference_type; + typedef T value_type; + typedef const T *pointer; + typedef const T &reference; + + inline iterator() {} + inline iterator(typename Hash::iterator o) : i(o) {} + inline iterator(const iterator &o) : i(o.i) {} + inline iterator &operator=(const iterator &o) { i = o.i; return *this; } + inline const T &operator*() const { return i.key(); } + inline const T *operator->() const { return &i.key(); } + inline bool operator==(const iterator &o) const { return i == o.i; } + inline bool operator!=(const iterator &o) const { return i != o.i; } + inline bool operator==(const const_iterator &o) const + { return i == o.i; } + inline bool operator!=(const const_iterator &o) const + { return i != o.i; } + inline iterator &operator++() { ++i; return *this; } + inline iterator operator++(int) { iterator r = *this; ++i; return r; } + inline iterator &operator--() { --i; return *this; } + inline iterator operator--(int) { iterator r = *this; --i; return r; } + inline iterator operator+(int j) const { return i + j; } + inline iterator operator-(int j) const { return i - j; } + inline iterator &operator+=(int j) { i += j; return *this; } + inline iterator &operator-=(int j) { i -= j; return *this; } + }; + + class const_iterator + { + typedef QHash Hash; + typename Hash::const_iterator i; + friend class iterator; + + public: + typedef std::bidirectional_iterator_tag iterator_category; + typedef qptrdiff difference_type; + typedef T value_type; + typedef const T *pointer; + typedef const T &reference; + + inline const_iterator() {} + inline const_iterator(typename Hash::const_iterator o) : i(o) {} + inline const_iterator(const const_iterator &o) : i(o.i) {} + inline const_iterator(const iterator &o) + : i(o.i) {} + inline const_iterator &operator=(const const_iterator &o) { i = o.i; return *this; } + inline const T &operator*() const { return i.key(); } + inline const T *operator->() const { return &i.key(); } + inline bool operator==(const const_iterator &o) const { return i == o.i; } + inline bool operator!=(const const_iterator &o) const { return i != o.i; } + inline const_iterator &operator++() { ++i; return *this; } + inline const_iterator operator++(int) { const_iterator r = *this; ++i; return r; } + inline const_iterator &operator--() { --i; return *this; } + inline const_iterator operator--(int) { const_iterator r = *this; --i; return r; } + inline const_iterator operator+(int j) const { return i + j; } + inline const_iterator operator-(int j) const { return i - j; } + inline const_iterator &operator+=(int j) { i += j; return *this; } + inline const_iterator &operator-=(int j) { i -= j; return *this; } + }; + + + inline iterator begin() { return q_hash.begin(); } + inline const_iterator begin() const { return q_hash.begin(); } + inline const_iterator constBegin() const { return q_hash.constBegin(); } + inline iterator end() { return q_hash.end(); } + inline const_iterator end() const { return q_hash.end(); } + inline const_iterator constEnd() const { return q_hash.constEnd(); } + iterator erase(iterator i) + { return q_hash.erase(reinterpret_cast(i)); } + + + typedef iterator Iterator; + typedef const_iterator ConstIterator; + inline int count() const { return q_hash.count(); } + inline const_iterator insert(const T &value) + { return static_cast(q_hash.insert(value, + QHashDummyValue())); } + iterator find(const T &value) { return q_hash.find(value); } + const_iterator find(const T &value) const { return q_hash.find(value); } + inline const_iterator constFind(const T &value) const { return find(value); } + QSet &unite(const QSet &other); + QSet &intersect(const QSet &other); + QSet &subtract(const QSet &other); + + + typedef T key_type; + typedef T value_type; + typedef value_type *pointer; + typedef const value_type *const_pointer; + typedef value_type &reference; + typedef const value_type &const_reference; + typedef qptrdiff difference_type; + typedef int size_type; + + inline bool empty() const { return isEmpty(); } + + inline QSet &operator<<(const T &value) { insert(value); return *this; } + inline QSet &operator|=(const QSet &other) { unite(other); return *this; } + inline QSet &operator|=(const T &value) { insert(value); return *this; } + inline QSet &operator&=(const QSet &other) { intersect(other); return *this; } + inline QSet &operator&=(const T &value) + { QSet result; if (contains(value)) result.insert(value); return (*this = result); } + inline QSet &operator+=(const QSet &other) { unite(other); return *this; } + inline QSet &operator+=(const T &value) { insert(value); return *this; } + inline QSet &operator-=(const QSet &other) { subtract(other); return *this; } + inline QSet &operator-=(const T &value) { remove(value); return *this; } + inline QSet operator|(const QSet &other) const + { QSet result = *this; result |= other; return result; } + inline QSet operator&(const QSet &other) const + { QSet result = *this; result &= other; return result; } + inline QSet operator+(const QSet &other) const + { QSet result = *this; result += other; return result; } + inline QSet operator-(const QSet &other) const + { QSet result = *this; result -= other; return result; } + + + inline QSet operator|(const QSet &other) + { QSet result = *this; result |= other; return result; } + inline QSet operator&(const QSet &other) + { QSet result = *this; result &= other; return result; } + inline QSet operator+(const QSet &other) + { QSet result = *this; result += other; return result; } + inline QSet operator-(const QSet &other) + { QSet result = *this; result -= other; return result; } + + + QList toList() const; + inline QList values() const { return toList(); } + + static QSet fromList(const QList &list); + +private: + Hash q_hash; +}; + +template +inline void QSet::reserve(int asize) { q_hash.reserve(asize); } + +template +inline QSet &QSet::unite(const QSet &other) +{ + QSet copy(other); + typename QSet::const_iterator i = copy.constEnd(); + while (i != copy.constBegin()) { + --i; + insert(*i); + } + return *this; +} + +template +inline QSet &QSet::intersect(const QSet &other) +{ + QSet copy1(*this); + QSet copy2(other); + typename QSet::const_iterator i = copy1.constEnd(); + while (i != copy1.constBegin()) { + --i; + if (!copy2.contains(*i)) + remove(*i); + } + return *this; +} + +template +inline QSet &QSet::subtract(const QSet &other) +{ + QSet copy1(*this); + QSet copy2(other); + typename QSet::const_iterator i = copy1.constEnd(); + while (i != copy1.constBegin()) { + --i; + if (copy2.contains(*i)) + remove(*i); + } + return *this; +} + +template +inline bool QSet::contains(const QSet &other) const +{ + typename QSet::const_iterator i = other.constBegin(); + while (i != other.constEnd()) { + if (!contains(*i)) + return false; + ++i; + } + return true; +} + +template + QList QSet::toList() const +{ + QList result; + result.reserve(size()); + typename QSet::const_iterator i = constBegin(); + while (i != constEnd()) { + result.append(*i); + ++i; + } + return result; +} + +template + QSet QList::toSet() const +{ + QSet result; + result.reserve(size()); + for (int i = 0; i < size(); ++i) + result.insert(at(i)); + return result; +} + +template +QSet QSet::fromList(const QList &list) +{ + return list.toSet(); +} + +template +QList QList::fromSet(const QSet &set) +{ + return set.toList(); +} + +template class QSetIterator { typedef typename QSet::const_iterator const_iterator; QSet c; const_iterator i; public: inline QSetIterator(const QSet &container) : c(container), i(c.constBegin()) {} inline QSetIterator &operator=(const QSet &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } }; + +template +class QMutableSetIterator +{ + typedef typename QSet::iterator iterator; + QSet *c; + iterator i, n; + inline bool item_exists() const { return c->constEnd() != n; } + +public: + inline QMutableSetIterator(QSet &container) + : c(&container) + { c->setSharable(false); i = c->begin(); n = c->end(); } + inline ~QMutableSetIterator() + { c->setSharable(true); } + inline QMutableSetIterator &operator=(QSet &container) + { c->setSharable(true); c = &container; c->setSharable(false); + i = c->begin(); n = c->end(); return *this; } + inline void toFront() { i = c->begin(); n = c->end(); } + inline void toBack() { i = c->end(); n = i; } + inline bool hasNext() const { return c->constEnd() != i; } + inline const T &next() { n = i++; return *n; } + inline const T &peekNext() const { return *i; } + inline bool hasPrevious() const { return c->constBegin() != i; } + inline const T &previous() { n = --i; return *n; } + inline const T &peekPrevious() const { iterator p = i; return *--p; } + inline void remove() + { if (c->constEnd() != n) { i = c->erase(n); n = c->end(); } } + inline const T &value() const { qt_noop(); return *n; } + inline bool findNext(const T &t) + { while (c->constEnd() != (n = i)) if (*i++ == t) return true; return false; } + inline bool findPrevious(const T &t) + { while (c->constBegin() != i) if (*(n = --i) == t) return true; + n = c->end(); return false; } +}; + + + + +# 57 "/usr/include/qt4/QtGui/qevent.h" 2 3 4 +# 1 "/usr/include/qt4/QtCore/qfile.h" 1 3 4 +# 47 "/usr/include/qt4/QtCore/qfile.h" 3 4 +# 1 "/usr/include/stdio.h" 1 3 4 +# 29 "/usr/include/stdio.h" 3 4 +extern "C" { + + + +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 34 "/usr/include/stdio.h" 2 3 4 +# 74 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/libio.h" 1 3 4 +# 31 "/usr/include/libio.h" 3 4 +# 1 "/usr/include/_G_config.h" 1 3 4 +# 15 "/usr/include/_G_config.h" 3 4 +# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/5.2.0/include/stddef.h" 1 3 4 +# 16 "/usr/include/_G_config.h" 2 3 4 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 21 "/usr/include/_G_config.h" 2 3 4 +typedef struct +{ + __off_t __pos; + __mbstate_t __state; +} _G_fpos_t; +typedef struct +{ + __off64_t __pos; + __mbstate_t __state; +} _G_fpos64_t; +# 32 "/usr/include/libio.h" 2 3 4 +# 144 "/usr/include/libio.h" 3 4 +struct _IO_jump_t; struct _IO_FILE; +# 154 "/usr/include/libio.h" 3 4 +typedef void _IO_lock_t; + + + + + +struct _IO_marker { + struct _IO_marker *_next; + struct _IO_FILE *_sbuf; + + + + int _pos; +# 177 "/usr/include/libio.h" 3 4 +}; + + +enum __codecvt_result +{ + __codecvt_ok, + __codecvt_partial, + __codecvt_error, + __codecvt_noconv +}; +# 245 "/usr/include/libio.h" 3 4 +struct _IO_FILE { + int _flags; + + + + + char* _IO_read_ptr; + char* _IO_read_end; + char* _IO_read_base; + char* _IO_write_base; + char* _IO_write_ptr; + char* _IO_write_end; + char* _IO_buf_base; + char* _IO_buf_end; + + char *_IO_save_base; + char *_IO_backup_base; + char *_IO_save_end; + + struct _IO_marker *_markers; + + struct _IO_FILE *_chain; + + int _fileno; + + + + int _flags2; + + __off_t _old_offset; + + + + unsigned short _cur_column; + signed char _vtable_offset; + char _shortbuf[1]; + + + + _IO_lock_t *_lock; +# 293 "/usr/include/libio.h" 3 4 + __off64_t _offset; +# 302 "/usr/include/libio.h" 3 4 + void *__pad1; + void *__pad2; + void *__pad3; + void *__pad4; + size_t __pad5; + + int _mode; + + char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)]; + +}; + + + + + +struct _IO_FILE_plus; + +extern struct _IO_FILE_plus _IO_2_1_stdin_; +extern struct _IO_FILE_plus _IO_2_1_stdout_; +extern struct _IO_FILE_plus _IO_2_1_stderr_; +# 338 "/usr/include/libio.h" 3 4 +typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes); + + + + + + + +typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf, + size_t __n); + + + + + + + +typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w); + + +typedef int __io_close_fn (void *__cookie); + + + + +typedef __io_read_fn cookie_read_function_t; +typedef __io_write_fn cookie_write_function_t; +typedef __io_seek_fn cookie_seek_function_t; +typedef __io_close_fn cookie_close_function_t; + + +typedef struct +{ + __io_read_fn *read; + __io_write_fn *write; + __io_seek_fn *seek; + __io_close_fn *close; +} _IO_cookie_io_functions_t; +typedef _IO_cookie_io_functions_t cookie_io_functions_t; + +struct _IO_cookie_file; + + +extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write, + void *__cookie, _IO_cookie_io_functions_t __fns); + + + + +extern "C" { + + +extern int __underflow (_IO_FILE *); +extern int __uflow (_IO_FILE *); +extern int __overflow (_IO_FILE *, int); +# 434 "/usr/include/libio.h" 3 4 +extern int _IO_getc (_IO_FILE *__fp); +extern int _IO_putc (int __c, _IO_FILE *__fp); +extern int _IO_feof (_IO_FILE *__fp) throw (); +extern int _IO_ferror (_IO_FILE *__fp) throw (); + +extern int _IO_peekc_locked (_IO_FILE *__fp); + + + + + +extern void _IO_flockfile (_IO_FILE *) throw (); +extern void _IO_funlockfile (_IO_FILE *) throw (); +extern int _IO_ftrylockfile (_IO_FILE *) throw (); +# 464 "/usr/include/libio.h" 3 4 +extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict, + __gnuc_va_list, int *__restrict); +extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict, + __gnuc_va_list); +extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t); +extern size_t _IO_sgetn (_IO_FILE *, void *, size_t); + +extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int); +extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int); + +extern void _IO_free_backup_area (_IO_FILE *) throw (); +# 526 "/usr/include/libio.h" 3 4 +} +# 75 "/usr/include/stdio.h" 2 3 4 +# 108 "/usr/include/stdio.h" 3 4 + + +typedef _G_fpos_t fpos_t; + + + + + +typedef _G_fpos64_t fpos64_t; +# 164 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 +# 165 "/usr/include/stdio.h" 2 3 4 + + + +extern struct _IO_FILE *stdin; +extern struct _IO_FILE *stdout; +extern struct _IO_FILE *stderr; + + + + + + + +extern int remove (const char *__filename) throw (); + +extern int rename (const char *__old, const char *__new) throw (); + + + + +extern int renameat (int __oldfd, const char *__old, int __newfd, + const char *__new) throw (); + + + + + + + + +extern FILE *tmpfile (void) ; +# 205 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile64 (void) ; + + + +extern char *tmpnam (char *__s) throw () ; + + + + + +extern char *tmpnam_r (char *__s) throw () ; +# 227 "/usr/include/stdio.h" 3 4 +extern char *tempnam (const char *__dir, const char *__pfx) + throw () __attribute__ ((__malloc__)) ; + + + + + + + + +extern int fclose (FILE *__stream); + + + + +extern int fflush (FILE *__stream); + +# 252 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 262 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); + + + + + + + + + +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) ; + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) ; +# 295 "/usr/include/stdio.h" 3 4 + + +extern FILE *fopen64 (const char *__restrict __filename, + const char *__restrict __modes) ; +extern FILE *freopen64 (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) ; + + + + +extern FILE *fdopen (int __fd, const char *__modes) throw () ; + + + + + +extern FILE *fopencookie (void *__restrict __magic_cookie, + const char *__restrict __modes, + _IO_cookie_io_functions_t __io_funcs) throw () ; + + + + +extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) + throw () ; + + + + +extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ; + + + + + + +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw (); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) throw (); + + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) throw (); + + +extern void setlinebuf (FILE *__stream) throw (); + + + + + + + + +extern int fprintf (FILE *__restrict __stream, + const char *__restrict __format, ...); + + + + +extern int printf (const char *__restrict __format, ...); + +extern int sprintf (char *__restrict __s, + const char *__restrict __format, ...) throw (); + + + + + +extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg); + + + + +extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); + +extern int vsprintf (char *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) throw (); + + + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, ...) + throw () __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, __gnuc_va_list __arg) + throw () __attribute__ ((__format__ (__printf__, 3, 0))); + + + + + + +extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, + __gnuc_va_list __arg) + throw () __attribute__ ((__format__ (__printf__, 2, 0))) ; +extern int __asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; +extern int asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; + + + + +extern int vdprintf (int __fd, const char *__restrict __fmt, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__printf__, 2, 0))); +extern int dprintf (int __fd, const char *__restrict __fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); + + + + + + + + +extern int fscanf (FILE *__restrict __stream, + const char *__restrict __format, ...) ; + + + + +extern int scanf (const char *__restrict __format, ...) ; + +extern int sscanf (const char *__restrict __s, + const char *__restrict __format, ...) throw (); +# 463 "/usr/include/stdio.h" 3 4 + + + + + + + + +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 2, 0))) ; + + + + + +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 1, 0))) ; + + +extern int vsscanf (const char *__restrict __s, + const char *__restrict __format, __gnuc_va_list __arg) + throw () __attribute__ ((__format__ (__scanf__, 2, 0))); +# 522 "/usr/include/stdio.h" 3 4 + + + + + + + + + +extern int fgetc (FILE *__stream); +extern int getc (FILE *__stream); + + + + + +extern int getchar (void); + +# 550 "/usr/include/stdio.h" 3 4 +extern int getc_unlocked (FILE *__stream); +extern int getchar_unlocked (void); +# 561 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream); + + + + + + + + + + + +extern int fputc (int __c, FILE *__stream); +extern int putc (int __c, FILE *__stream); + + + + + +extern int putchar (int __c); + +# 594 "/usr/include/stdio.h" 3 4 +extern int fputc_unlocked (int __c, FILE *__stream); + + + + + + + +extern int putc_unlocked (int __c, FILE *__stream); +extern int putchar_unlocked (int __c); + + + + + + +extern int getw (FILE *__stream); + + +extern int putw (int __w, FILE *__stream); + + + + + + + + +extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) + ; +# 638 "/usr/include/stdio.h" 3 4 +extern char *gets (char *__s) __attribute__ ((__deprecated__)); + + +# 649 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) ; +# 665 "/usr/include/stdio.h" 3 4 +extern __ssize_t __getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) ; +extern __ssize_t getdelim (char **__restrict __lineptr, + size_t *__restrict __n, int __delimiter, + FILE *__restrict __stream) ; + + + + + + + +extern __ssize_t getline (char **__restrict __lineptr, + size_t *__restrict __n, + FILE *__restrict __stream) ; + + + + + + + + +extern int fputs (const char *__restrict __s, FILE *__restrict __stream); + + + + + +extern int puts (const char *__s); + + + + + + +extern int ungetc (int __c, FILE *__stream); + + + + + + +extern size_t fread (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) ; + + + + +extern size_t fwrite (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __s); + +# 726 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream); +# 737 "/usr/include/stdio.h" 3 4 +extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream) ; +extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size, + size_t __n, FILE *__restrict __stream); + + + + + + + + +extern int fseek (FILE *__stream, long int __off, int __whence); + + + + +extern long int ftell (FILE *__stream) ; + + + + +extern void rewind (FILE *__stream); + +# 773 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence); + + + + +extern __off_t ftello (FILE *__stream) ; +# 792 "/usr/include/stdio.h" 3 4 + + + + + + +extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); + + + + +extern int fsetpos (FILE *__stream, const fpos_t *__pos); +# 815 "/usr/include/stdio.h" 3 4 + + + +extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); +extern __off64_t ftello64 (FILE *__stream) ; +extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); +extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); + + + + +extern void clearerr (FILE *__stream) throw (); + +extern int feof (FILE *__stream) throw () ; + +extern int ferror (FILE *__stream) throw () ; + + + + +extern void clearerr_unlocked (FILE *__stream) throw (); +extern int feof_unlocked (FILE *__stream) throw () ; +extern int ferror_unlocked (FILE *__stream) throw () ; + + + + + + + + +extern void perror (const char *__s); + + + + + + +# 1 "/usr/include/bits/sys_errlist.h" 1 3 4 +# 26 "/usr/include/bits/sys_errlist.h" 3 4 +extern int sys_nerr; +extern const char *const sys_errlist[]; + + +extern int _sys_nerr; +extern const char *const _sys_errlist[]; +# 854 "/usr/include/stdio.h" 2 3 4 + + + + +extern int fileno (FILE *__stream) throw () ; + + + + +extern int fileno_unlocked (FILE *__stream) throw () ; +# 872 "/usr/include/stdio.h" 3 4 +extern FILE *popen (const char *__command, const char *__modes) ; + + + + + +extern int pclose (FILE *__stream); + + + + + +extern char *ctermid (char *__s) throw (); + + + + + +extern char *cuserid (char *__s); + + + + +struct obstack; + + +extern int obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __format, ...) + throw () __attribute__ ((__format__ (__printf__, 2, 3))); +extern int obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __format, + __gnuc_va_list __args) + throw () __attribute__ ((__format__ (__printf__, 2, 0))); + + + + + + + +extern void flockfile (FILE *__stream) throw (); + + + +extern int ftrylockfile (FILE *__stream) throw () ; + + +extern void funlockfile (FILE *__stream) throw (); +# 942 "/usr/include/stdio.h" 3 4 +} +# 48 "/usr/include/qt4/QtCore/qfile.h" 2 3 4 +# 56 "/usr/include/qt4/QtCore/qfile.h" 3 4 + + + + +typedef QtValidLicenseForCoreModule QtCoreModule; + +class QAbstractFileEngine; +class QFilePrivate; + +class QFile : public QIODevice +{ + + public: template inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static const QMetaObjectExtraData staticMetaObjectExtraData; __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); + + inline QFilePrivate* d_func() { return reinterpret_cast(qGetPtrHelper(d_ptr)); } inline const QFilePrivate* d_func() const { return reinterpret_cast(qGetPtrHelper(d_ptr)); } friend class QFilePrivate; + +public: + + enum FileError { + NoError = 0, + ReadError = 1, + WriteError = 2, + FatalError = 3, + ResourceError = 4, + OpenError = 5, + AbortError = 6, + TimeOutError = 7, + UnspecifiedError = 8, + RemoveError = 9, + RenameError = 10, + PositionError = 11, + ResizeError = 12, + PermissionsError = 13, + CopyError = 14 + + + + }; + + enum Permission { + ReadOwner = 0x4000, WriteOwner = 0x2000, ExeOwner = 0x1000, + ReadUser = 0x0400, WriteUser = 0x0200, ExeUser = 0x0100, + ReadGroup = 0x0040, WriteGroup = 0x0020, ExeGroup = 0x0010, + ReadOther = 0x0004, WriteOther = 0x0002, ExeOther = 0x0001 + }; + typedef QFlags Permissions; + + enum FileHandleFlag { + AutoCloseHandle = 0x0001, + DontCloseHandle = 0 + }; + typedef QFlags FileHandleFlags; + + QFile(); + QFile(const QString &name); + + explicit QFile(QObject *parent); + QFile(const QString &name, QObject *parent); + + ~QFile(); + + FileError error() const; + void unsetError(); + + QString fileName() const; + void setFileName(const QString &name); + + typedef QByteArray (*EncoderFn)(const QString &fileName); + typedef QString (*DecoderFn)(const QByteArray &localfileName); + static QByteArray encodeName(const QString &fileName); + static QString decodeName(const QByteArray &localFileName); + inline static QString decodeName(const char *localFileName) + { return decodeName(QByteArray(localFileName)); } + static void setEncodingFunction(EncoderFn); + static void setDecodingFunction(DecoderFn); + + bool exists() const; + static bool exists(const QString &fileName); + + QString readLink() const; + static QString readLink(const QString &fileName); + inline QString symLinkTarget() const { return readLink(); } + inline static QString symLinkTarget(const QString &fileName) { return readLink(fileName); } + + bool remove(); + static bool remove(const QString &fileName); + + bool rename(const QString &newName); + static bool rename(const QString &oldName, const QString &newName); + + bool link(const QString &newName); + static bool link(const QString &oldname, const QString &newName); + + bool copy(const QString &newName); + static bool copy(const QString &fileName, const QString &newName); + + bool isSequential() const; + + bool open(OpenMode flags); + bool open(FILE *f, OpenMode flags); + bool open(int fd, OpenMode flags); + + + + bool open(FILE *f, OpenMode ioFlags, FileHandleFlags handleFlags); + bool open(int fd, OpenMode ioFlags, FileHandleFlags handleFlags); + virtual void close(); + + qint64 size() const; + qint64 pos() const; + bool seek(qint64 offset); + bool atEnd() const; + bool flush(); + + bool resize(qint64 sz); + static bool resize(const QString &filename, qint64 sz); + + Permissions permissions() const; + static Permissions permissions(const QString &filename); + bool setPermissions(Permissions permissionSpec); + static bool setPermissions(const QString &filename, Permissions permissionSpec); + + int handle() const; + + enum MemoryMapFlags { + NoOptions = 0 + }; + + uchar *map(qint64 offset, qint64 size, MemoryMapFlags flags = NoOptions); + bool unmap(uchar *address); + + virtual QAbstractFileEngine *fileEngine() const; +# 197 "/usr/include/qt4/QtCore/qfile.h" 3 4 +protected: + + + + QFile(QFilePrivate &dd, QObject *parent = 0); + + + qint64 readData(char *data, qint64 maxlen); + qint64 writeData(const char *data, qint64 len); + qint64 readLineData(char *data, qint64 maxlen); + +private: + QFile(const QFile &); QFile &operator=(const QFile &); +}; + + inline QFlags operator|(QFile::Permissions::enum_type f1, QFile::Permissions::enum_type f2) { return QFlags(f1) | f2; } inline QFlags operator|(QFile::Permissions::enum_type f1, QFlags f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QFile::Permissions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } + + + + +# 58 "/usr/include/qt4/QtGui/qevent.h" 2 3 4 + + + + + + + + + +typedef QtValidLicenseForGuiModule QtGuiModule; + +class QAction; + +class QGesture; + + +class QInputEvent : public QEvent +{ +public: + QInputEvent(Type type, Qt::KeyboardModifiers modifiers = Qt::NoModifier); + ~QInputEvent(); + inline Qt::KeyboardModifiers modifiers() const { return modState; } + inline void setModifiers(Qt::KeyboardModifiers amodifiers) { modState = amodifiers; } +protected: + Qt::KeyboardModifiers modState; +}; + +class QMouseEvent : public QInputEvent +{ +public: + QMouseEvent(Type type, const QPoint &pos, Qt::MouseButton button, + Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers); + QMouseEvent(Type type, const QPoint &pos, const QPoint &globalPos, + Qt::MouseButton button, Qt::MouseButtons buttons, + Qt::KeyboardModifiers modifiers); + ~QMouseEvent(); + + inline const QPoint &pos() const { return p; } + inline const QPoint &globalPos() const { return g; } + inline int x() const { return p.x(); } + inline int y() const { return p.y(); } + inline int globalX() const { return g.x(); } + inline int globalY() const { return g.y(); } + inline Qt::MouseButton button() const { return b; } + inline Qt::MouseButtons buttons() const { return mouseState; } + + static QMouseEvent *createExtendedMouseEvent(Type type, const QPointF &pos, + const QPoint &globalPos, Qt::MouseButton button, + Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers); + inline bool hasExtendedInfo() const { return reinterpret_cast(d) == this; } + QPointF posF() const; +# 119 "/usr/include/qt4/QtGui/qevent.h" 3 4 +protected: + QPoint p, g; + Qt::MouseButton b; + Qt::MouseButtons mouseState; +}; + +class QHoverEvent : public QEvent +{ +public: + QHoverEvent(Type type, const QPoint &pos, const QPoint &oldPos); + ~QHoverEvent(); + + inline const QPoint &pos() const { return p; } + inline const QPoint &oldPos() const { return op; } + +protected: + QPoint p, op; +}; + + +class QWheelEvent : public QInputEvent +{ +public: + QWheelEvent(const QPoint &pos, int delta, + Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, + Qt::Orientation orient = Qt::Vertical); + QWheelEvent(const QPoint &pos, const QPoint& globalPos, int delta, + Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, + Qt::Orientation orient = Qt::Vertical); + ~QWheelEvent(); + + inline int delta() const { return d; } + inline const QPoint &pos() const { return p; } + inline const QPoint &globalPos() const { return g; } + inline int x() const { return p.x(); } + inline int y() const { return p.y(); } + inline int globalX() const { return g.x(); } + inline int globalY() const { return g.y(); } + + inline Qt::MouseButtons buttons() const { return mouseState; } + Qt::Orientation orientation() const { return o; } +# 169 "/usr/include/qt4/QtGui/qevent.h" 3 4 +protected: + QPoint p; + QPoint g; + int d; + Qt::MouseButtons mouseState; + Qt::Orientation o; +}; + + + +class QTabletEvent : public QInputEvent +{ +public: + enum TabletDevice { NoDevice, Puck, Stylus, Airbrush, FourDMouse, + XFreeEraser , RotationStylus }; + enum PointerType { UnknownPointer, Pen, Cursor, Eraser }; + QTabletEvent(Type t, const QPoint &pos, const QPoint &globalPos, const QPointF &hiResGlobalPos, + int device, int pointerType, qreal pressure, int xTilt, int yTilt, + qreal tangentialPressure, qreal rotation, int z, + Qt::KeyboardModifiers keyState, qint64 uniqueID); + ~QTabletEvent(); + + inline const QPoint &pos() const { return mPos; } + inline const QPoint &globalPos() const { return mGPos; } + inline const QPointF &hiResGlobalPos() const { return mHiResGlobalPos; } + inline int x() const { return mPos.x(); } + inline int y() const { return mPos.y(); } + inline int globalX() const { return mGPos.x(); } + inline int globalY() const { return mGPos.y(); } + inline qreal hiResGlobalX() const { return mHiResGlobalPos.x(); } + inline qreal hiResGlobalY() const { return mHiResGlobalPos.y(); } + inline TabletDevice device() const { return TabletDevice(mDev); } + inline PointerType pointerType() const { return PointerType(mPointerType); } + inline qint64 uniqueId() const { return mUnique; } + inline qreal pressure() const { return mPress; } + inline int z() const { return mZ; } + inline qreal tangentialPressure() const { return mTangential; } + inline qreal rotation() const { return mRot; } + inline int xTilt() const { return mXT; } + inline int yTilt() const { return mYT; } + +protected: + QPoint mPos, mGPos; + QPointF mHiResGlobalPos; + int mDev, mPointerType, mXT, mYT, mZ; + qreal mPress, mTangential, mRot; + qint64 mUnique; + + + + + void *mExtra; +}; + + +class QKeyEvent : public QInputEvent +{ +public: + QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text = QString(), + bool autorep = false, ushort count = 1); + ~QKeyEvent(); + + int key() const { return k; } + + bool matches(QKeySequence::StandardKey key) const; + + Qt::KeyboardModifiers modifiers() const; + inline QString text() const { return txt; } + inline bool isAutoRepeat() const { return autor; } + inline int count() const { return int(c); } + + + static QKeyEvent *createExtendedKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, + quint32 nativeScanCode, quint32 nativeVirtualKey, + quint32 nativeModifiers, + const QString& text = QString(), bool autorep = false, + ushort count = 1); + inline bool hasExtendedInfo() const { return reinterpret_cast(d) == this; } + quint32 nativeScanCode() const; + quint32 nativeVirtualKey() const; + quint32 nativeModifiers() const; +# 267 "/usr/include/qt4/QtGui/qevent.h" 3 4 +protected: + QString txt; + int k; + ushort c; + uint autor:1; +}; + + +class QFocusEvent : public QEvent +{ +public: + QFocusEvent(Type type, Qt::FocusReason reason=Qt::OtherFocusReason); + ~QFocusEvent(); + + inline bool gotFocus() const { return type() == FocusIn; } + inline bool lostFocus() const { return type() == FocusOut; } + + + + + + + + Qt::FocusReason reason(); + Qt::FocusReason reason() const; + +private: + Qt::FocusReason m_reason; +}; + + +class QPaintEvent : public QEvent +{ +public: + QPaintEvent(const QRegion& paintRegion); + QPaintEvent(const QRect &paintRect); + ~QPaintEvent(); + + inline const QRect &rect() const { return m_rect; } + inline const QRegion ®ion() const { return m_region; } + + + + + + + +protected: + friend class QApplication; + friend class QCoreApplication; + QRect m_rect; + QRegion m_region; + bool m_erased; +}; + +class QUpdateLaterEvent : public QEvent +{ +public: + QUpdateLaterEvent(const QRegion& paintRegion); + ~QUpdateLaterEvent(); + + inline const QRegion ®ion() const { return m_region; } + +protected: + QRegion m_region; +}; + +class QMoveEvent : public QEvent +{ +public: + QMoveEvent(const QPoint &pos, const QPoint &oldPos); + ~QMoveEvent(); + + inline const QPoint &pos() const { return p; } + inline const QPoint &oldPos() const { return oldp;} +protected: + QPoint p, oldp; + friend class QApplication; + friend class QCoreApplication; +}; + + +class QResizeEvent : public QEvent +{ +public: + QResizeEvent(const QSize &size, const QSize &oldSize); + ~QResizeEvent(); + + inline const QSize &size() const { return s; } + inline const QSize &oldSize()const { return olds;} +protected: + QSize s, olds; + friend class QApplication; + friend class QCoreApplication; +}; + + +class QCloseEvent : public QEvent +{ +public: + QCloseEvent(); + ~QCloseEvent(); +}; + + +class QIconDragEvent : public QEvent +{ +public: + QIconDragEvent(); + ~QIconDragEvent(); +}; + + +class QShowEvent : public QEvent +{ +public: + QShowEvent(); + ~QShowEvent(); +}; + + +class QHideEvent : public QEvent +{ +public: + QHideEvent(); + ~QHideEvent(); +}; + + +class QContextMenuEvent : public QInputEvent +{ +public: + enum Reason { Mouse, Keyboard, Other }; + + QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos, + Qt::KeyboardModifiers modifiers); + QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos); + QContextMenuEvent(Reason reason, const QPoint &pos); + ~QContextMenuEvent(); + + inline int x() const { return p.x(); } + inline int y() const { return p.y(); } + inline int globalX() const { return gp.x(); } + inline int globalY() const { return gp.y(); } + + inline const QPoint& pos() const { return p; } + inline const QPoint& globalPos() const { return gp; } + + inline Reason reason() const { return Reason(reas); } + + + + + + + +protected: + QPoint p; + QPoint gp; + uint reas : 8; +}; + + + +class QInputMethodEvent : public QEvent +{ +public: + enum AttributeType { + TextFormat, + Cursor, + Language, + Ruby, + Selection + }; + class Attribute { + public: + Attribute(AttributeType t, int s, int l, QVariant val) : type(t), start(s), length(l), value(val) {} + AttributeType type; + + int start; + int length; + QVariant value; + }; + QInputMethodEvent(); + QInputMethodEvent(const QString &preeditText, const QList &attributes); + void setCommitString(const QString &commitString, int replaceFrom = 0, int replaceLength = 0); + + inline const QList &attributes() const { return attrs; } + inline const QString &preeditString() const { return preedit; } + + inline const QString &commitString() const { return commit; } + inline int replacementStart() const { return replace_from; } + inline int replacementLength() const { return replace_length; } + + QInputMethodEvent(const QInputMethodEvent &other); + +private: + QString preedit; + QList attrs; + QString commit; + int replace_from; + int replace_length; +}; + + + + +class QMimeData; + +class QDropEvent : public QEvent + + , public QMimeSource + +{ +public: + QDropEvent(const QPoint& pos, Qt::DropActions actions, const QMimeData *data, + Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop); + ~QDropEvent(); + + inline const QPoint &pos() const { return p; } + inline Qt::MouseButtons mouseButtons() const { return mouseState; } + inline Qt::KeyboardModifiers keyboardModifiers() const { return modState; } + + inline Qt::DropActions possibleActions() const { return act; } + inline Qt::DropAction proposedAction() const { return default_action; } + inline void acceptProposedAction() { drop_action = default_action; accept(); } + + inline Qt::DropAction dropAction() const { return drop_action; } + void setDropAction(Qt::DropAction action); + + QWidget* source() const; + inline const QMimeData *mimeData() const { return mdata; } + + + const char* format(int n = 0) const; + QByteArray encodedData(const char*) const; + bool provides(const char*) const; +# 517 "/usr/include/qt4/QtGui/qevent.h" 3 4 +protected: + friend class QApplication; + QPoint p; + Qt::MouseButtons mouseState; + Qt::KeyboardModifiers modState; + Qt::DropActions act; + Qt::DropAction drop_action; + Qt::DropAction default_action; + const QMimeData *mdata; + mutable QList fmts; +}; + + +class QDragMoveEvent : public QDropEvent +{ +public: + QDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, + Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = DragMove); + ~QDragMoveEvent(); + + inline QRect answerRect() const { return rect; } + + inline void accept() { QDropEvent::accept(); } + inline void ignore() { QDropEvent::ignore(); } + + inline void accept(const QRect & r) { accept(); rect = r; } + inline void ignore(const QRect & r) { ignore(); rect = r; } + + + + + +protected: + friend class QApplication; + QRect rect; +}; + + +class QDragEnterEvent : public QDragMoveEvent +{ +public: + QDragEnterEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, + Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers); + ~QDragEnterEvent(); +}; + + + +class QDragResponseEvent : public QEvent +{ +public: + QDragResponseEvent(bool accepted); + ~QDragResponseEvent(); + + inline bool dragAccepted() const { return a; } +protected: + bool a; +}; + + +class QDragLeaveEvent : public QEvent +{ +public: + QDragLeaveEvent(); + ~QDragLeaveEvent(); +}; + + + +class QHelpEvent : public QEvent +{ +public: + QHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos); + ~QHelpEvent(); + + inline int x() const { return p.x(); } + inline int y() const { return p.y(); } + inline int globalX() const { return gp.x(); } + inline int globalY() const { return gp.y(); } + + inline const QPoint& pos() const { return p; } + inline const QPoint& globalPos() const { return gp; } + +private: + QPoint p; + QPoint gp; +}; + + +class QStatusTipEvent : public QEvent +{ +public: + QStatusTipEvent(const QString &tip); + ~QStatusTipEvent(); + + inline QString tip() const { return s; } +private: + QString s; +}; + + + +class QWhatsThisClickedEvent : public QEvent +{ +public: + QWhatsThisClickedEvent(const QString &href); + ~QWhatsThisClickedEvent(); + + inline QString href() const { return s; } +private: + QString s; +}; + + + +class QActionEvent : public QEvent +{ + QAction *act, *bef; +public: + QActionEvent(int type, QAction *action, QAction *before = 0); + ~QActionEvent(); + + inline QAction *action() const { return act; } + inline QAction *before() const { return bef; } +}; + + +class QFileOpenEvent : public QEvent +{ +public: + QFileOpenEvent(const QString &file); + QFileOpenEvent(const QUrl &url); + + + + ~QFileOpenEvent(); + + inline QString file() const { return f; } + QUrl url() const; + bool openFile(QFile &file, QIODevice::OpenMode flags) const; +private: + QString f; +}; + + +class QToolBarChangeEvent : public QEvent +{ +public: + QToolBarChangeEvent(bool t); + ~QToolBarChangeEvent(); + + inline bool toggle() const { return tog; } +private: + uint tog : 1; +}; + + + +class QShortcutEvent : public QEvent +{ +public: + QShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false); + ~QShortcutEvent(); + + inline const QKeySequence &key() { return sequence; } + inline const QKeySequence &key() const { return sequence; } + inline int shortcutId() { return sid; } + inline int shortcutId() const { return sid; } + inline bool isAmbiguous() { return ambig; } + inline bool isAmbiguous() const { return ambig; } +protected: + QKeySequence sequence; + bool ambig; + int sid; +}; + + + +class QClipboardEvent : public QEvent +{ +public: + QClipboardEvent(QEventPrivate *data); + ~QClipboardEvent(); + + QEventPrivate *data() { return d; } +}; + + +class QWindowStateChangeEvent: public QEvent +{ +public: + QWindowStateChangeEvent(Qt::WindowStates aOldState); + QWindowStateChangeEvent(Qt::WindowStates aOldState, bool isOverride); + ~QWindowStateChangeEvent(); + + inline Qt::WindowStates oldState() const { return ostate; } + bool isOverride() const; + +private: + Qt::WindowStates ostate; +}; +# 732 "/usr/include/qt4/QtGui/qevent.h" 3 4 + QDebug operator<<(QDebug, const QEvent *); + + + +inline bool operator==(QKeyEvent *e, QKeySequence::StandardKey key){return (e ? e->matches(key) : false);} +inline bool operator==(QKeySequence::StandardKey key, QKeyEvent *e){return (e ? e->matches(key) : false);} + + +class QTouchEventTouchPointPrivate; +class QTouchEvent : public QInputEvent +{ +public: + class TouchPoint + { + public: + TouchPoint(int id = -1); + TouchPoint(const QTouchEvent::TouchPoint &other); + ~TouchPoint(); + + int id() const; + + Qt::TouchPointState state() const; + bool isPrimary() const; + + QPointF pos() const; + QPointF startPos() const; + QPointF lastPos() const; + + QPointF scenePos() const; + QPointF startScenePos() const; + QPointF lastScenePos() const; + + QPointF screenPos() const; + QPointF startScreenPos() const; + QPointF lastScreenPos() const; + + QPointF normalizedPos() const; + QPointF startNormalizedPos() const; + QPointF lastNormalizedPos() const; + + QRectF rect() const; + QRectF sceneRect() const; + QRectF screenRect() const; + + qreal pressure() const; + + + void setId(int id); + void setState(Qt::TouchPointStates state); + void setPos(const QPointF &pos); + void setScenePos(const QPointF &scenePos); + void setScreenPos(const QPointF &screenPos); + void setNormalizedPos(const QPointF &normalizedPos); + void setStartPos(const QPointF &startPos); + void setStartScenePos(const QPointF &startScenePos); + void setStartScreenPos(const QPointF &startScreenPos); + void setStartNormalizedPos(const QPointF &startNormalizedPos); + void setLastPos(const QPointF &lastPos); + void setLastScenePos(const QPointF &lastScenePos); + void setLastScreenPos(const QPointF &lastScreenPos); + void setLastNormalizedPos(const QPointF &lastNormalizedPos); + void setRect(const QRectF &rect); + void setSceneRect(const QRectF &sceneRect); + void setScreenRect(const QRectF &screenRect); + void setPressure(qreal pressure); + QTouchEvent::TouchPoint &operator=(const QTouchEvent::TouchPoint &other); + + private: + QTouchEventTouchPointPrivate *d; + friend class QApplication; + friend class QApplicationPrivate; + }; + + enum DeviceType { + TouchScreen, + TouchPad + }; + + QTouchEvent(QEvent::Type eventType, + QTouchEvent::DeviceType deviceType = TouchScreen, + Qt::KeyboardModifiers modifiers = Qt::NoModifier, + Qt::TouchPointStates touchPointStates = 0, + const QList &touchPoints = QList()); + ~QTouchEvent(); + + inline QWidget *widget() const { return _widget; } + inline QTouchEvent::DeviceType deviceType() const { return _deviceType; } + inline Qt::TouchPointStates touchPointStates() const { return _touchPointStates; } + inline const QList &touchPoints() const { return _touchPoints; } + + + inline void setWidget(QWidget *awidget) { _widget = awidget; } + inline void setDeviceType(DeviceType adeviceType) { _deviceType = adeviceType; } + inline void setTouchPointStates(Qt::TouchPointStates aTouchPointStates) { _touchPointStates = aTouchPointStates; } + inline void setTouchPoints(const QList &atouchPoints) { _touchPoints = atouchPoints; } + +protected: + QWidget *_widget; + QTouchEvent::DeviceType _deviceType; + Qt::TouchPointStates _touchPointStates; + QList _touchPoints; + + friend class QApplication; + friend class QApplicationPrivate; +}; + + +class QGesture; +class QGestureEventPrivate; +class QGestureEvent : public QEvent +{ +public: + QGestureEvent(const QList &gestures); + ~QGestureEvent(); + + QList gestures() const; + QGesture *gesture(Qt::GestureType type) const; + + QList activeGestures() const; + QList canceledGestures() const; +# 860 "/usr/include/qt4/QtGui/qevent.h" 3 4 + using QEvent::setAccepted; + using QEvent::isAccepted; + using QEvent::accept; + using QEvent::ignore; + + + void setAccepted(QGesture *, bool); + void accept(QGesture *); + void ignore(QGesture *); + bool isAccepted(QGesture *) const; + + void setAccepted(Qt::GestureType, bool); + void accept(Qt::GestureType); + void ignore(Qt::GestureType); + bool isAccepted(Qt::GestureType) const; + + void setWidget(QWidget *widget); + QWidget *widget() const; + + + QPointF mapToGraphicsScene(const QPointF &gesturePoint) const; + + +private: + QGestureEventPrivate *d_func(); + const QGestureEventPrivate *d_func() const; + + friend class QApplication; + friend class QGestureManager; +}; + + + + + +# 1 "/usr/include/qt4/QtGui/QKeyEvent" 2 3 4 +# 3 "../test.cpp" 2 + + +# 4 "../test.cpp" +void send(QObject *obj) +{ + QEvent *event = new QEvent(QEvent::None); + +# 7 "../test.cpp" 3 4 +(static_cast(QCoreApplication::instance())) +# 7 "../test.cpp" + ->postEvent(obj, event); // no-warning +}