Attachment 589811 Details for Bug 829247 – Preprocessed C++ source code

Preprocessed C++ source code

ccsx5JrX.out (text/plain), 1.69 MB, created by Thiago Macieira on 2012-06-06 10:10:31 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Thiago Macieira

Created: 2012-06-06 10:10:31 UTC

Size: 1.69 MB

patch

obsolete

>// /usr/libexec/gcc/x86_64-redhat-linux/4.7.0/cc1plus -quiet -I ../../../../../../src/qt/qt5/qtbase/mkspecs/linux-g++-optimised -I ../../../../../../src/qt/creator/src/libs/languageutils -I ../../../../qt5/qtbase/include/QtCore -I ../../../../qt5/qtbase/include/QtGui -I ../../../../qt5/qtbase/include/QtTest -I ../../../../qt5/qtbase/include/QtConcurrent -I ../../../../qt5/qtbase/include/QtWidgets -I ../../../../qt5/qtbase/include -I ../../../src -I ../../../../../../src/qt/creator/src/libs -I /home/thiago/src/qt/creator/tools -I ../../../../../../src/qt/creator/src/plugins -I ../../../../../../src/qt/creator/src/libs -I .moc/debug-shared -I . -D_GNU_SOURCE -D _REENTRANT -D QT_CREATOR -D WITH_TESTS -D IDE_LIBRARY_BASENAME="lib" -D QT_NO_CAST_TO_ASCII -D QT_USE_FAST_OPERATOR_PLUS -D QT_USE_FAST_CONCATENATION -D QT_DISABLE_DEPRECATED_BEFORE=0x040900 -D LANGUAGEUTILS_BUILD_DIR -D QT_WIDGETS_LIB -D QT_CONCURRENT_LIB -D QT_TESTLIB_LIB -D QT_TESTCASE_BUILDDIR="/home/thiago/obj/qt/creator-qt5/src/libs/languageutils" -D QT_GUI_LIB -D QT_CORE_LIB ../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.cpp -quiet -dumpbase fakemetaobject.cpp -march=core2 -mtune=corei7-avx -auxbase-strip .obj/debug-shared/fakemetaobject.o -g -O3 -Wall -Wextra -std=c++11 -fvisibility=hidden -fvisibility-inlines-hidden -fPIC -o - -frandom-seed=0
># 1 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.cpp"
># 1 "/home/thiago/obj/qt/creator-qt5/src/libs/languageutils//"
># 1 "<command-line>"
># 1 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.cpp"
># 33 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.cpp"
># 1 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.h" 1
># 36 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.h"
># 1 "../../../../../../src/qt/creator/src/libs/languageutils/languageutils_global.h" 1
># 36 "../../../../../../src/qt/creator/src/libs/languageutils/languageutils_global.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 150 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 3 4
>typedef long int ptrdiff_t;
># 213 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 3 4
>typedef long unsigned int size_t;
># 423 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 3 4
>typedef struct {
> long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
> long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
>} max_align_t;
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
># 62 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qconfig.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../src/corelib/global/qconfig.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qconfig.h" 2
># 63 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
>
>
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qsystemdetection.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qsystemdetection.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qsystemdetection.h" 2
># 71 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qcompilerdetection.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qcompilerdetection.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qcompilerdetection.h" 2
># 72 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qprocessordetection.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qprocessordetection.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qprocessordetection.h" 2
># 73 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/algorithm" 1 3
># 59 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/algorithm" 3
> 
># 60 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/algorithm" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/utility" 1 3
># 60 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/utility" 3
> 
># 61 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/utility" 3
># 70 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/utility" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++config.h" 1 3
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 4 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++config.h" 2 3
># 1815 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++config.h" 3
>namespace std
>{
> typedef long unsigned int size_t;
> typedef long int ptrdiff_t;
>
>
> typedef decltype(nullptr) nullptr_t;
>
>}
># 2058 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++config.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/os_defines.h" 1 3
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/os_defines.h" 3
># 1 "/usr/include/features.h" 1 3 4
># 362 "/usr/include/features.h" 3 4
># 1 "/usr/include/sys/cdefs.h" 1 3 4
># 390 "/usr/include/sys/cdefs.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 391 "/usr/include/sys/cdefs.h" 2 3 4
># 363 "/usr/include/features.h" 2 3 4
># 386 "/usr/include/features.h" 3 4
># 1 "/usr/include/gnu/stubs.h" 1 3 4
>
>
>
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 5 "/usr/include/gnu/stubs.h" 2 3 4
>
>
>
>
># 1 "/usr/include/gnu/stubs-64.h" 1 3 4
># 10 "/usr/include/gnu/stubs.h" 2 3 4
># 387 "/usr/include/features.h" 2 3 4
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/os_defines.h" 2 3
># 2059 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++config.h" 2 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
># 2062 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++config.h" 2 3
># 71 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/utility" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_relops.h" 1 3
># 68 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_relops.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
> namespace rel_ops
> {
> 
># 86 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator!=(const _Tp& __x, const _Tp& __y)
> { return !(__x == __y); }
># 99 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>(const _Tp& __x, const _Tp& __y)
> { return __y < __x; }
># 112 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator<=(const _Tp& __x, const _Tp& __y)
> { return !(__y < __x); }
># 125 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_relops.h" 3
> template <class _Tp>
> inline bool
> operator>=(const _Tp& __x, const _Tp& __y)
> { return !(__x < __y); }
>
> 
> }
>
>}
># 72 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/utility" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h" 1 3
># 61 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/move.h" 1 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/move.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/concept_check.h" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/concept_check.h" 3
> 
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/concept_check.h" 3
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/move.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _Tp>
> inline _Tp*
> __addressof(_Tp& __r) noexcept
> {
> return reinterpret_cast<_Tp*>
> (&const_cast<char&>(reinterpret_cast<const volatile char&>(__r)));
> }
>
>
>}
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 1 3
># 32 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
> 
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 56 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
> template<typename _Tp, _Tp __v>
> struct integral_constant
> {
> static constexpr _Tp value = __v;
> typedef _Tp value_type;
> typedef integral_constant<_Tp, __v> type;
> constexpr operator value_type() { return value; }
> };
>
>
> typedef integral_constant<bool, true> true_type;
>
>
> typedef integral_constant<bool, false> false_type;
>
> template<typename _Tp, _Tp __v>
> constexpr _Tp integral_constant<_Tp, __v>::value;
>
>
>
> template<bool, typename, typename>
> struct conditional;
>
> template<typename...>
> struct __or_;
>
> template<>
> struct __or_<>
> : public false_type
> { };
>
> template<typename _B1>
> struct __or_<_B1>
> : public _B1
> { };
>
> template<typename _B1, typename _B2>
> struct __or_<_B1, _B2>
> : public conditional<_B1::value, _B1, _B2>::type
> { };
>
> template<typename _B1, typename _B2, typename _B3, typename... _Bn>
> struct __or_<_B1, _B2, _B3, _Bn...>
> : public conditional<_B1::value, _B1, __or_<_B2, _B3, _Bn...>>::type
> { };
>
> template<typename...>
> struct __and_;
>
> template<>
> struct __and_<>
> : public true_type
> { };
>
> template<typename _B1>
> struct __and_<_B1>
> : public _B1
> { };
>
> template<typename _B1, typename _B2>
> struct __and_<_B1, _B2>
> : public conditional<_B1::value, _B2, _B1>::type
> { };
>
> template<typename _B1, typename _B2, typename _B3, typename... _Bn>
> struct __and_<_B1, _B2, _B3, _Bn...>
> : public conditional<_B1::value, __and_<_B2, _B3, _Bn...>, _B1>::type
> { };
>
> template<typename _Pp>
> struct __not_
> : public integral_constant<bool, !_Pp::value>
> { };
>
> struct __sfinae_types
> {
> typedef char __one;
> typedef struct { char __arr[2]; } __two;
> };
>
>
>
> template<typename>
> struct remove_cv;
>
> template<typename>
> struct __is_void_helper
> : public false_type { };
>
> template<>
> struct __is_void_helper<void>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_void
> : public integral_constant<bool, (__is_void_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
> template<typename>
> struct __is_integral_helper
> : public false_type { };
>
> template<>
> struct __is_integral_helper<bool>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<char>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<signed char>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned char>
> : public true_type { };
>
>
> template<>
> struct __is_integral_helper<wchar_t>
> : public true_type { };
>
>
> template<>
> struct __is_integral_helper<char16_t>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<char32_t>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<short>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned short>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<int>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned int>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<long>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned long>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<long long>
> : public true_type { };
>
> template<>
> struct __is_integral_helper<unsigned long long>
> : public true_type { };
># 233 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
> template<typename _Tp>
> struct is_integral
> : public integral_constant<bool, (__is_integral_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
> template<typename>
> struct __is_floating_point_helper
> : public false_type { };
>
> template<>
> struct __is_floating_point_helper<float>
> : public true_type { };
>
> template<>
> struct __is_floating_point_helper<double>
> : public true_type { };
>
> template<>
> struct __is_floating_point_helper<long double>
> : public true_type { };
># 262 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
> template<typename _Tp>
> struct is_floating_point
> : public integral_constant<bool, (__is_floating_point_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
>
> template<typename>
> struct is_array
> : public false_type { };
>
> template<typename _Tp, std::size_t _Size>
> struct is_array<_Tp[_Size]>
> : public true_type { };
>
> template<typename _Tp>
> struct is_array<_Tp[]>
> : public true_type { };
>
> template<typename>
> struct __is_pointer_helper
> : public false_type { };
>
> template<typename _Tp>
> struct __is_pointer_helper<_Tp*>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_pointer
> : public integral_constant<bool, (__is_pointer_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
>
> template<typename>
> struct is_lvalue_reference
> : public false_type { };
>
> template<typename _Tp>
> struct is_lvalue_reference<_Tp&>
> : public true_type { };
>
>
> template<typename>
> struct is_rvalue_reference
> : public false_type { };
>
> template<typename _Tp>
> struct is_rvalue_reference<_Tp&&>
> : public true_type { };
>
> template<typename>
> struct is_function;
>
> template<typename>
> struct __is_member_object_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_object_pointer_helper<_Tp _Cp::*>
> : public integral_constant<bool, !is_function<_Tp>::value> { };
>
>
> template<typename _Tp>
> struct is_member_object_pointer
> : public integral_constant<bool, (__is_member_object_pointer_helper<
> typename remove_cv<_Tp>::type>::value)>
> { };
>
> template<typename>
> struct __is_member_function_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_function_pointer_helper<_Tp _Cp::*>
> : public integral_constant<bool, is_function<_Tp>::value> { };
>
>
> template<typename _Tp>
> struct is_member_function_pointer
> : public integral_constant<bool, (__is_member_function_pointer_helper<
> typename remove_cv<_Tp>::type>::value)>
> { };
>
>
> template<typename _Tp>
> struct is_enum
> : public integral_constant<bool, __is_enum(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_union
> : public integral_constant<bool, __is_union(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_class
> : public integral_constant<bool, __is_class(_Tp)>
> { };
>
>
> template<typename>
> struct is_function
> : public false_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes...)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes......)>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes...) const>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes......) const>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes...) volatile>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes......) volatile>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes...) const volatile>
> : public true_type { };
>
> template<typename _Res, typename... _ArgTypes>
> struct is_function<_Res(_ArgTypes......) const volatile>
> : public true_type { };
>
> template<typename>
> struct __is_nullptr_t_helper
> : public false_type { };
>
> template<>
> struct __is_nullptr_t_helper<std::nullptr_t>
> : public true_type { };
>
>
> template<typename _Tp>
> struct __is_nullptr_t
> : public integral_constant<bool, (__is_nullptr_t_helper<typename
> remove_cv<_Tp>::type>::value)>
> { };
>
>
>
>
> template<typename _Tp>
> struct is_reference
> : public __or_<is_lvalue_reference<_Tp>,
> is_rvalue_reference<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_arithmetic
> : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_fundamental
> : public __or_<is_arithmetic<_Tp>, is_void<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_object
> : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
> is_void<_Tp>>>::type
> { };
>
> template<typename>
> struct is_member_pointer;
>
>
> template<typename _Tp>
> struct is_scalar
> : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
> is_member_pointer<_Tp>, __is_nullptr_t<_Tp>>::type
> { };
>
>
> template<typename _Tp>
> struct is_compound
> : public integral_constant<bool, !is_fundamental<_Tp>::value> { };
>
> template<typename _Tp>
> struct __is_member_pointer_helper
> : public false_type { };
>
> template<typename _Tp, typename _Cp>
> struct __is_member_pointer_helper<_Tp _Cp::*>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_member_pointer
> : public integral_constant<bool, (__is_member_pointer_helper<
> typename remove_cv<_Tp>::type>::value)>
> { };
>
>
>
>
> template<typename>
> struct is_const
> : public false_type { };
>
> template<typename _Tp>
> struct is_const<_Tp const>
> : public true_type { };
>
>
> template<typename>
> struct is_volatile
> : public false_type { };
>
> template<typename _Tp>
> struct is_volatile<_Tp volatile>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_trivial
> : public integral_constant<bool, __is_trivial(_Tp)>
> { };
>
>
>
>
> template<typename _Tp>
> struct is_standard_layout
> : public integral_constant<bool, __is_standard_layout(_Tp)>
> { };
>
>
>
> template<typename _Tp>
> struct is_pod
> : public integral_constant<bool, __is_pod(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_literal_type
> : public integral_constant<bool, __is_literal_type(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_empty
> : public integral_constant<bool, __is_empty(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_polymorphic
> : public integral_constant<bool, __is_polymorphic(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct is_abstract
> : public integral_constant<bool, __is_abstract(_Tp)>
> { };
>
> template<typename _Tp,
> bool = is_integral<_Tp>::value,
> bool = is_floating_point<_Tp>::value>
> struct __is_signed_helper
> : public false_type { };
>
> template<typename _Tp>
> struct __is_signed_helper<_Tp, false, true>
> : public true_type { };
>
> template<typename _Tp>
> struct __is_signed_helper<_Tp, true, false>
> : public integral_constant<bool, static_cast<bool>(_Tp(-1) < _Tp(0))>
> { };
>
>
> template<typename _Tp>
> struct is_signed
> : public integral_constant<bool, __is_signed_helper<_Tp>::value>
> { };
>
>
> template<typename _Tp>
> struct is_unsigned
> : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type
> { };
>
>
>
>
> template<typename>
> struct add_rvalue_reference;
>
>
>
>
>
> template<typename _Tp>
> typename add_rvalue_reference<_Tp>::type declval() noexcept;
>
> template<typename, unsigned = 0>
> struct extent;
>
> template<typename>
> struct remove_all_extents;
>
> template<typename _Tp>
> struct __is_array_known_bounds
> : public integral_constant<bool, (extent<_Tp>::value > 0)>
> { };
>
> template<typename _Tp>
> struct __is_array_unknown_bounds
> : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>::type
> { };
>
>
>
>
>
>
> struct __do_is_destructible_impl_1
> {
> template<typename _Up>
> struct __w { _Up __u; };
>
> template<typename _Tp, typename
> = decltype(declval<__w<_Tp>&>().~__w<_Tp>())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_destructible_impl_1
> : public __do_is_destructible_impl_1
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
>
> struct __do_is_destructible_impl_2
> {
> template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_destructible_impl_2
> : public __do_is_destructible_impl_2
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp,
> bool = __or_<is_void<_Tp>,
> __is_array_unknown_bounds<_Tp>>::value,
> bool = __or_<is_reference<_Tp>, is_function<_Tp>>::value>
> struct __is_destructible_safe;
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, false, false>
> : public conditional<is_abstract<_Tp>::value,
> __is_destructible_impl_2<_Tp>,
> __is_destructible_impl_1<_Tp>>::type::type
> { };
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, true, false>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_destructible_safe<_Tp, false, true>
> : public true_type { };
>
>
> template<typename _Tp>
> struct is_destructible
> : public integral_constant<bool, (__is_destructible_safe<_Tp>::value)>
> { };
>
> struct __do_is_default_constructible_impl
> {
> template<typename _Tp, typename = decltype(_Tp())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
> };
>
> template<typename _Tp>
> struct __is_default_constructible_impl
> : public __do_is_default_constructible_impl
> {
> typedef decltype(__test<_Tp>(0)) type;
> };
>
> template<typename _Tp>
> struct __is_default_constructible_atom
> : public __and_<__not_<is_void<_Tp>>,
> __is_default_constructible_impl<_Tp>>::type
> { };
>
> template<typename _Tp, bool = is_array<_Tp>::value>
> struct __is_default_constructible_safe;
>
>
>
>
>
>
> template<typename _Tp>
> struct __is_default_constructible_safe<_Tp, true>
> : public __and_<__is_array_known_bounds<_Tp>,
> __is_default_constructible_atom<typename
> remove_all_extents<_Tp>::type>>::type
> { };
>
> template<typename _Tp>
> struct __is_default_constructible_safe<_Tp, false>
> : public __is_default_constructible_atom<_Tp>::type
> { };
>
>
> template<typename _Tp>
> struct is_default_constructible
> : public integral_constant<bool, (__is_default_constructible_safe<
> _Tp>::value)>
> { };
># 726 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
> struct __do_is_static_castable_impl
> {
> template<typename _From, typename _To, typename
> = decltype(static_cast<_To>(declval<_From>()))>
> static true_type __test(int);
>
> template<typename, typename>
> static false_type __test(...);
> };
>
> template<typename _From, typename _To>
> struct __is_static_castable_impl
> : public __do_is_static_castable_impl
> {
> typedef decltype(__test<_From, _To>(0)) type;
> };
>
> template<typename _From, typename _To>
> struct __is_static_castable_safe
> : public __is_static_castable_impl<_From, _To>::type
> { };
>
>
> template<typename _From, typename _To>
> struct __is_static_castable
> : public integral_constant<bool, (__is_static_castable_safe<
> _From, _To>::value)>
> { };
>
>
>
>
>
>
> struct __do_is_direct_constructible_impl
> {
> template<typename _Tp, typename _Arg, typename
> = decltype(::new _Tp(declval<_Arg>()))>
> static true_type __test(int);
>
> template<typename, typename>
> static false_type __test(...);
> };
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible_impl
> : public __do_is_direct_constructible_impl
> {
> typedef decltype(__test<_Tp, _Arg>(0)) type;
> };
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible_new_safe
> : public __and_<is_destructible<_Tp>,
> __is_direct_constructible_impl<_Tp, _Arg>>::type
> { };
>
> template<typename, typename>
> struct is_same;
>
> template<typename, typename>
> struct is_base_of;
>
> template<typename>
> struct remove_reference;
>
> template<typename _From, typename _To, bool
> = __not_<__or_<is_void<_From>,
> is_function<_From>>>::value>
> struct __is_base_to_derived_ref;
>
>
>
> template<typename _From, typename _To>
> struct __is_base_to_derived_ref<_From, _To, true>
> {
> typedef typename remove_cv<typename remove_reference<_From
> >::type>::type __src_t;
> typedef typename remove_cv<typename remove_reference<_To
> >::type>::type __dst_t;
> typedef __and_<__not_<is_same<__src_t, __dst_t>>,
> is_base_of<__src_t, __dst_t>> type;
> static constexpr bool value = type::value;
> };
>
> template<typename _From, typename _To>
> struct __is_base_to_derived_ref<_From, _To, false>
> : public false_type
> { };
>
> template<typename _From, typename _To, bool
> = __and_<is_lvalue_reference<_From>,
> is_rvalue_reference<_To>>::value>
> struct __is_lvalue_to_rvalue_ref;
>
>
>
> template<typename _From, typename _To>
> struct __is_lvalue_to_rvalue_ref<_From, _To, true>
> {
> typedef typename remove_cv<typename remove_reference<
> _From>::type>::type __src_t;
> typedef typename remove_cv<typename remove_reference<
> _To>::type>::type __dst_t;
> typedef __and_<__not_<is_function<__src_t>>,
> __or_<is_same<__src_t, __dst_t>,
> is_base_of<__dst_t, __src_t>>> type;
> static constexpr bool value = type::value;
> };
>
> template<typename _From, typename _To>
> struct __is_lvalue_to_rvalue_ref<_From, _To, false>
> : public false_type
> { };
>
>
>
>
>
>
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible_ref_cast
> : public __and_<__is_static_castable<_Arg, _Tp>,
> __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>,
> __is_lvalue_to_rvalue_ref<_Arg, _Tp>
> >>>::type
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible_new
> : public conditional<is_reference<_Tp>::value,
> __is_direct_constructible_ref_cast<_Tp, _Arg>,
> __is_direct_constructible_new_safe<_Tp, _Arg>
> >::type
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_direct_constructible
> : public integral_constant<bool, (__is_direct_constructible_new<
> _Tp, _Arg>::value)>
> { };
>
>
>
>
>
>
> struct __do_is_nary_constructible_impl
> {
> template<typename _Tp, typename... _Args, typename
> = decltype(_Tp(declval<_Args>()...))>
> static true_type __test(int);
>
> template<typename, typename...>
> static false_type __test(...);
> };
>
> template<typename _Tp, typename... _Args>
> struct __is_nary_constructible_impl
> : public __do_is_nary_constructible_impl
> {
> typedef decltype(__test<_Tp, _Args...>(0)) type;
> };
>
> template<typename _Tp, typename... _Args>
> struct __is_nary_constructible
> : public __is_nary_constructible_impl<_Tp, _Args...>::type
> {
> static_assert(sizeof...(_Args) > 1,
> "Only useful for > 1 arguments");
> };
>
> template<typename _Tp, typename... _Args>
> struct __is_constructible_impl
> : public __is_nary_constructible<_Tp, _Args...>
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_constructible_impl<_Tp, _Arg>
> : public __is_direct_constructible<_Tp, _Arg>
> { };
>
> template<typename _Tp>
> struct __is_constructible_impl<_Tp>
> : public is_default_constructible<_Tp>
> { };
>
>
> template<typename _Tp, typename... _Args>
> struct is_constructible
> : public integral_constant<bool, (__is_constructible_impl<_Tp,
> _Args...>::value)>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_copy_constructible_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_copy_constructible_impl<_Tp, false>
> : public is_constructible<_Tp, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_copy_constructible
> : public __is_copy_constructible_impl<_Tp>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_move_constructible_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_move_constructible_impl<_Tp, false>
> : public is_constructible<_Tp, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_move_constructible
> : public __is_move_constructible_impl<_Tp>
> { };
>
> template<typename _Tp>
> struct __is_nt_default_constructible_atom
> : public integral_constant<bool, noexcept(_Tp())>
> { };
>
> template<typename _Tp, bool = is_array<_Tp>::value>
> struct __is_nt_default_constructible_impl;
>
> template<typename _Tp>
> struct __is_nt_default_constructible_impl<_Tp, true>
> : public __and_<__is_array_known_bounds<_Tp>,
> __is_nt_default_constructible_atom<typename
> remove_all_extents<_Tp>::type>>::type
> { };
>
> template<typename _Tp>
> struct __is_nt_default_constructible_impl<_Tp, false>
> : public __is_nt_default_constructible_atom<_Tp>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_default_constructible
> : public __and_<is_default_constructible<_Tp>,
> __is_nt_default_constructible_impl<_Tp>>::type
> { };
>
> template<typename _Tp, typename... _Args>
> struct __is_nt_constructible_impl
> : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
> { };
>
> template<typename _Tp, typename _Arg>
> struct __is_nt_constructible_impl<_Tp, _Arg>
> : public integral_constant<bool,
> noexcept(static_cast<_Tp>(declval<_Arg>()))>
> { };
>
> template<typename _Tp>
> struct __is_nt_constructible_impl<_Tp>
> : public is_nothrow_default_constructible<_Tp>
> { };
>
>
> template<typename _Tp, typename... _Args>
> struct is_nothrow_constructible
> : public __and_<is_constructible<_Tp, _Args...>,
> __is_nt_constructible_impl<_Tp, _Args...>>::type
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_nothrow_copy_constructible_impl;
>
> template<typename _Tp>
> struct __is_nothrow_copy_constructible_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nothrow_copy_constructible_impl<_Tp, false>
> : public is_nothrow_constructible<_Tp, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_copy_constructible
> : public __is_nothrow_copy_constructible_impl<_Tp>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_nothrow_move_constructible_impl;
>
> template<typename _Tp>
> struct __is_nothrow_move_constructible_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nothrow_move_constructible_impl<_Tp, false>
> : public is_nothrow_constructible<_Tp, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_move_constructible
> : public __is_nothrow_move_constructible_impl<_Tp>
> { };
>
> template<typename _Tp, typename _Up>
> class __is_assignable_helper
> : public __sfinae_types
> {
> template<typename _Tp1, typename _Up1>
> static decltype(declval<_Tp1>() = declval<_Up1>(), __one())
> __test(int);
>
> template<typename, typename>
> static __two __test(...);
>
> public:
> static constexpr bool value = sizeof(__test<_Tp, _Up>(0)) == 1;
> };
>
>
> template<typename _Tp, typename _Up>
> struct is_assignable
> : public integral_constant<bool,
> __is_assignable_helper<_Tp, _Up>::value>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_copy_assignable_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_copy_assignable_impl<_Tp, false>
> : public is_assignable<_Tp&, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_copy_assignable
> : public __is_copy_assignable_impl<_Tp>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_move_assignable_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_move_assignable_impl<_Tp, false>
> : public is_assignable<_Tp&, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_move_assignable
> : public __is_move_assignable_impl<_Tp>
> { };
>
> template<typename _Tp, typename _Up>
> struct __is_nt_assignable_impl
> : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Up>())>
> { };
>
>
> template<typename _Tp, typename _Up>
> struct is_nothrow_assignable
> : public __and_<is_assignable<_Tp, _Up>,
> __is_nt_assignable_impl<_Tp, _Up>>::type
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_nt_copy_assignable_impl;
>
> template<typename _Tp>
> struct __is_nt_copy_assignable_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_copy_assignable_impl<_Tp, false>
> : public is_nothrow_assignable<_Tp&, const _Tp&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_copy_assignable
> : public __is_nt_copy_assignable_impl<_Tp>
> { };
>
> template<typename _Tp, bool = is_void<_Tp>::value>
> struct __is_nt_move_assignable_impl;
>
> template<typename _Tp>
> struct __is_nt_move_assignable_impl<_Tp, true>
> : public false_type { };
>
> template<typename _Tp>
> struct __is_nt_move_assignable_impl<_Tp, false>
> : public is_nothrow_assignable<_Tp&, _Tp&&>
> { };
>
>
> template<typename _Tp>
> struct is_nothrow_move_assignable
> : public __is_nt_move_assignable_impl<_Tp>
> { };
>
>
> template<typename _Tp>
> struct has_trivial_default_constructor
> : public integral_constant<bool, __has_trivial_constructor(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct has_trivial_copy_constructor
> : public integral_constant<bool, __has_trivial_copy(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct has_trivial_copy_assign
> : public integral_constant<bool, __has_trivial_assign(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct has_trivial_destructor
> : public integral_constant<bool, __has_trivial_destructor(_Tp)>
> { };
>
>
> template<typename _Tp>
> struct has_virtual_destructor
> : public integral_constant<bool, __has_virtual_destructor(_Tp)>
> { };
>
>
>
>
>
> template<typename _Tp>
> struct alignment_of
> : public integral_constant<std::size_t, __alignof__(_Tp)> { };
>
>
> template<typename>
> struct rank
> : public integral_constant<std::size_t, 0> { };
>
> template<typename _Tp, std::size_t _Size>
> struct rank<_Tp[_Size]>
> : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
>
> template<typename _Tp>
> struct rank<_Tp[]>
> : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
>
>
> template<typename, unsigned _Uint>
> struct extent
> : public integral_constant<std::size_t, 0> { };
>
> template<typename _Tp, unsigned _Uint, std::size_t _Size>
> struct extent<_Tp[_Size], _Uint>
> : public integral_constant<std::size_t,
> _Uint == 0 ? _Size : extent<_Tp,
> _Uint - 1>::value>
> { };
>
> template<typename _Tp, unsigned _Uint>
> struct extent<_Tp[], _Uint>
> : public integral_constant<std::size_t,
> _Uint == 0 ? 0 : extent<_Tp,
> _Uint - 1>::value>
> { };
>
>
>
>
>
> template<typename, typename>
> struct is_same
> : public false_type { };
>
> template<typename _Tp>
> struct is_same<_Tp, _Tp>
> : public true_type { };
>
>
> template<typename _Base, typename _Derived>
> struct is_base_of
> : public integral_constant<bool, __is_base_of(_Base, _Derived)>
> { };
>
> template<typename _From, typename _To,
> bool = __or_<is_void<_From>, is_function<_To>,
> is_array<_To>>::value>
> struct __is_convertible_helper
> { static constexpr bool value = is_void<_To>::value; };
>
> template<typename _From, typename _To>
> class __is_convertible_helper<_From, _To, false>
> : public __sfinae_types
> {
> template<typename _To1>
> static void __test_aux(_To1);
>
> template<typename _From1, typename _To1>
> static decltype(__test_aux<_To1>(std::declval<_From1>()), __one())
> __test(int);
>
> template<typename, typename>
> static __two __test(...);
>
> public:
> static constexpr bool value = sizeof(__test<_From, _To>(0)) == 1;
> };
>
>
> template<typename _From, typename _To>
> struct is_convertible
> : public integral_constant<bool,
> __is_convertible_helper<_From, _To>::value>
> { };
>
>
> template<typename _From, typename _To>
> struct is_explicitly_convertible
> : public is_constructible<_To, _From>
> { };
>
>
>
>
>
> template<typename _Tp>
> struct remove_const
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_const<_Tp const>
> { typedef _Tp type; };
>
>
> template<typename _Tp>
> struct remove_volatile
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_volatile<_Tp volatile>
> { typedef _Tp type; };
>
>
> template<typename _Tp>
> struct remove_cv
> {
> typedef typename
> remove_const<typename remove_volatile<_Tp>::type>::type type;
> };
>
>
> template<typename _Tp>
> struct add_const
> { typedef _Tp const type; };
>
>
> template<typename _Tp>
> struct add_volatile
> { typedef _Tp volatile type; };
>
>
> template<typename _Tp>
> struct add_cv
> {
> typedef typename
> add_const<typename add_volatile<_Tp>::type>::type type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct remove_reference
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_reference<_Tp&>
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_reference<_Tp&&>
> { typedef _Tp type; };
>
> template<typename _Tp,
> bool = __and_<__not_<is_reference<_Tp>>,
> __not_<is_void<_Tp>>>::value,
> bool = is_rvalue_reference<_Tp>::value>
> struct __add_lvalue_reference_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_lvalue_reference_helper<_Tp, true, false>
> { typedef _Tp& type; };
>
> template<typename _Tp>
> struct __add_lvalue_reference_helper<_Tp, false, true>
> { typedef typename remove_reference<_Tp>::type& type; };
>
>
> template<typename _Tp>
> struct add_lvalue_reference
> : public __add_lvalue_reference_helper<_Tp>
> { };
>
> template<typename _Tp,
> bool = __and_<__not_<is_reference<_Tp>>,
> __not_<is_void<_Tp>>>::value>
> struct __add_rvalue_reference_helper
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct __add_rvalue_reference_helper<_Tp, true>
> { typedef _Tp&& type; };
>
>
> template<typename _Tp>
> struct add_rvalue_reference
> : public __add_rvalue_reference_helper<_Tp>
> { };
>
>
>
>
>
> template<typename _Unqualified, bool _IsConst, bool _IsVol>
> struct __cv_selector;
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, false, false>
> { typedef _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, false, true>
> { typedef volatile _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, true, false>
> { typedef const _Unqualified __type; };
>
> template<typename _Unqualified>
> struct __cv_selector<_Unqualified, true, true>
> { typedef const volatile _Unqualified __type; };
>
> template<typename _Qualified, typename _Unqualified,
> bool _IsConst = is_const<_Qualified>::value,
> bool _IsVol = is_volatile<_Qualified>::value>
> class __match_cv_qualifiers
> {
> typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
>
> public:
> typedef typename __match::__type __type;
> };
>
>
> template<typename _Tp>
> struct __make_unsigned
> { typedef _Tp __type; };
>
> template<>
> struct __make_unsigned<char>
> { typedef unsigned char __type; };
>
> template<>
> struct __make_unsigned<signed char>
> { typedef unsigned char __type; };
>
> template<>
> struct __make_unsigned<short>
> { typedef unsigned short __type; };
>
> template<>
> struct __make_unsigned<int>
> { typedef unsigned int __type; };
>
> template<>
> struct __make_unsigned<long>
> { typedef unsigned long __type; };
>
> template<>
> struct __make_unsigned<long long>
> { typedef unsigned long long __type; };
># 1444 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
> template<typename _Tp,
> bool _IsInt = is_integral<_Tp>::value,
> bool _IsEnum = is_enum<_Tp>::value>
> class __make_unsigned_selector;
>
> template<typename _Tp>
> class __make_unsigned_selector<_Tp, true, false>
> {
> typedef __make_unsigned<typename remove_cv<_Tp>::type> __unsignedt;
> typedef typename __unsignedt::__type __unsigned_type;
> typedef __match_cv_qualifiers<_Tp, __unsigned_type> __cv_unsigned;
>
> public:
> typedef typename __cv_unsigned::__type __type;
> };
>
> template<typename _Tp>
> class __make_unsigned_selector<_Tp, false, true>
> {
>
> typedef unsigned char __smallest;
> static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
> static const bool __b1 = sizeof(_Tp) <= sizeof(unsigned short);
> static const bool __b2 = sizeof(_Tp) <= sizeof(unsigned int);
> typedef conditional<__b2, unsigned int, unsigned long> __cond2;
> typedef typename __cond2::type __cond2_type;
> typedef conditional<__b1, unsigned short, __cond2_type> __cond1;
> typedef typename __cond1::type __cond1_type;
>
> public:
> typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct make_unsigned
> { typedef typename __make_unsigned_selector<_Tp>::__type type; };
>
>
> template<>
> struct make_unsigned<bool>;
>
>
>
> template<typename _Tp>
> struct __make_signed
> { typedef _Tp __type; };
>
> template<>
> struct __make_signed<char>
> { typedef signed char __type; };
>
> template<>
> struct __make_signed<unsigned char>
> { typedef signed char __type; };
>
> template<>
> struct __make_signed<unsigned short>
> { typedef signed short __type; };
>
> template<>
> struct __make_signed<unsigned int>
> { typedef signed int __type; };
>
> template<>
> struct __make_signed<unsigned long>
> { typedef signed long __type; };
>
> template<>
> struct __make_signed<unsigned long long>
> { typedef signed long long __type; };
># 1526 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
> template<typename _Tp,
> bool _IsInt = is_integral<_Tp>::value,
> bool _IsEnum = is_enum<_Tp>::value>
> class __make_signed_selector;
>
> template<typename _Tp>
> class __make_signed_selector<_Tp, true, false>
> {
> typedef __make_signed<typename remove_cv<_Tp>::type> __signedt;
> typedef typename __signedt::__type __signed_type;
> typedef __match_cv_qualifiers<_Tp, __signed_type> __cv_signed;
>
> public:
> typedef typename __cv_signed::__type __type;
> };
>
> template<typename _Tp>
> class __make_signed_selector<_Tp, false, true>
> {
>
> typedef signed char __smallest;
> static const bool __b0 = sizeof(_Tp) <= sizeof(__smallest);
> static const bool __b1 = sizeof(_Tp) <= sizeof(signed short);
> static const bool __b2 = sizeof(_Tp) <= sizeof(signed int);
> typedef conditional<__b2, signed int, signed long> __cond2;
> typedef typename __cond2::type __cond2_type;
> typedef conditional<__b1, signed short, __cond2_type> __cond1;
> typedef typename __cond1::type __cond1_type;
>
> public:
> typedef typename conditional<__b0, __smallest, __cond1_type>::type __type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct make_signed
> { typedef typename __make_signed_selector<_Tp>::__type type; };
>
>
> template<>
> struct make_signed<bool>;
>
>
>
>
>
> template<typename _Tp>
> struct remove_extent
> { typedef _Tp type; };
>
> template<typename _Tp, std::size_t _Size>
> struct remove_extent<_Tp[_Size]>
> { typedef _Tp type; };
>
> template<typename _Tp>
> struct remove_extent<_Tp[]>
> { typedef _Tp type; };
>
>
> template<typename _Tp>
> struct remove_all_extents
> { typedef _Tp type; };
>
> template<typename _Tp, std::size_t _Size>
> struct remove_all_extents<_Tp[_Size]>
> { typedef typename remove_all_extents<_Tp>::type type; };
>
> template<typename _Tp>
> struct remove_all_extents<_Tp[]>
> { typedef typename remove_all_extents<_Tp>::type type; };
>
>
>
>
> template<typename _Tp, typename>
> struct __remove_pointer_helper
> { typedef _Tp type; };
>
> template<typename _Tp, typename _Up>
> struct __remove_pointer_helper<_Tp, _Up*>
> { typedef _Up type; };
>
>
> template<typename _Tp>
> struct remove_pointer
> : public __remove_pointer_helper<_Tp, typename remove_cv<_Tp>::type>
> { };
>
>
> template<typename _Tp>
> struct add_pointer
> { typedef typename remove_reference<_Tp>::type* type; };
>
>
> template<std::size_t _Len>
> struct __aligned_storage_msa
> {
> union __type
> {
> unsigned char __data[_Len];
> struct __attribute__((__aligned__)) { } __align;
> };
> };
># 1643 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
> template<std::size_t _Len, std::size_t _Align =
> __alignof__(typename __aligned_storage_msa<_Len>::__type)>
> struct aligned_storage
> {
> union type
> {
> unsigned char __data[_Len];
> struct __attribute__((__aligned__((_Align)))) { } __align;
> };
> };
>
>
>
>
> template<typename _Up,
> bool _IsArray = is_array<_Up>::value,
> bool _IsFunction = is_function<_Up>::value>
> struct __decay_selector;
>
>
> template<typename _Up>
> struct __decay_selector<_Up, false, false>
> { typedef typename remove_cv<_Up>::type __type; };
>
> template<typename _Up>
> struct __decay_selector<_Up, true, false>
> { typedef typename remove_extent<_Up>::type* __type; };
>
> template<typename _Up>
> struct __decay_selector<_Up, false, true>
> { typedef typename add_pointer<_Up>::type __type; };
>
>
> template<typename _Tp>
> class decay
> {
> typedef typename remove_reference<_Tp>::type __remove_type;
>
> public:
> typedef typename __decay_selector<__remove_type>::__type type;
> };
>
> template<typename _Tp>
> class reference_wrapper;
>
>
> template<typename _Tp>
> struct __strip_reference_wrapper
> {
> typedef _Tp __type;
> };
>
> template<typename _Tp>
> struct __strip_reference_wrapper<reference_wrapper<_Tp> >
> {
> typedef _Tp& __type;
> };
>
> template<typename _Tp>
> struct __strip_reference_wrapper<const reference_wrapper<_Tp> >
> {
> typedef _Tp& __type;
> };
>
> template<typename _Tp>
> struct __decay_and_strip
> {
> typedef typename __strip_reference_wrapper<
> typename decay<_Tp>::type>::__type __type;
> };
>
>
>
>
> template<bool, typename _Tp = void>
> struct enable_if
> { };
>
>
> template<typename _Tp>
> struct enable_if<true, _Tp>
> { typedef _Tp type; };
>
>
>
>
> template<bool _Cond, typename _Iftrue, typename _Iffalse>
> struct conditional
> { typedef _Iftrue type; };
>
>
> template<typename _Iftrue, typename _Iffalse>
> struct conditional<false, _Iftrue, _Iffalse>
> { typedef _Iffalse type; };
>
>
>
> template<typename... _Tp>
> struct common_type;
>
> template<typename _Tp>
> struct common_type<_Tp>
> { typedef _Tp type; };
>
> template<typename _Tp, typename _Up>
> struct common_type<_Tp, _Up>
> { typedef decltype(true ? declval<_Tp>() : declval<_Up>()) type; };
>
> template<typename _Tp, typename _Up, typename... _Vp>
> struct common_type<_Tp, _Up, _Vp...>
> {
> typedef typename
> common_type<typename common_type<_Tp, _Up>::type, _Vp...>::type type;
> };
>
>
> template<typename _Tp>
> struct underlying_type
> {
> typedef __underlying_type(_Tp) type;
> };
>
> template<typename _Tp>
> struct __declval_protector
> {
> static const bool __stop = false;
> static typename add_rvalue_reference<_Tp>::type __delegate();
> };
>
> template<typename _Tp>
> inline typename add_rvalue_reference<_Tp>::type
> declval() noexcept
> {
> static_assert(__declval_protector<_Tp>::__stop,
> "declval() must not be used!");
> return __declval_protector<_Tp>::__delegate();
> }
>
>
> template<typename _Signature>
> class result_of;
>
> template<typename _MemPtr, typename _Arg>
> struct _Result_of_memobj;
>
> template<typename _Res, typename _Class, typename _Arg>
> struct _Result_of_memobj<_Res _Class::*, _Arg>
> {
> private:
> typedef _Res _Class::* _Func;
>
> template<typename _Tp>
> static _Tp _S_get(const _Class&);
> template<typename _Tp>
> static decltype(*std::declval<_Tp>()) _S_get(...);
>
> public:
> typedef
> decltype(_S_get<_Arg>(std::declval<_Arg>()).*std::declval<_Func>())
> __type;
> };
>
> template<typename _MemPtr, typename _Arg, typename... _ArgTypes>
> struct _Result_of_memfun;
>
> template<typename _Res, typename _Class, typename _Arg, typename... _Args>
> struct _Result_of_memfun<_Res _Class::*, _Arg, _Args...>
> {
> private:
> typedef _Res _Class::* _Func;
>
> template<typename _Tp>
> static _Tp _S_get(const _Class&);
> template<typename _Tp>
> static decltype(*std::declval<_Tp>()) _S_get(...);
>
> public:
> typedef
> decltype((_S_get<_Arg>(std::declval<_Arg>()).*std::declval<_Func>())
> (std::declval<_Args>()...) )
> __type;
> };
>
> template<bool, bool, typename _Functor, typename... _ArgTypes>
> struct _Result_of_impl;
>
> template<typename _Functor, typename... _ArgTypes>
> struct _Result_of_impl<false, false, _Functor, _ArgTypes...>
> {
> typedef
> decltype( std::declval<_Functor>()(std::declval<_ArgTypes>()...) )
> __type;
> };
>
> template<typename _MemPtr, typename _Arg>
> struct _Result_of_impl<true, false, _MemPtr, _Arg>
> : _Result_of_memobj<typename remove_reference<_MemPtr>::type, _Arg>
> {
> typedef typename _Result_of_memobj<
> typename remove_reference<_MemPtr>::type, _Arg>::__type
> __type;
> };
>
> template<typename _MemPtr, typename _Arg, typename... _ArgTypes>
> struct _Result_of_impl<false, true, _MemPtr, _Arg, _ArgTypes...>
> : _Result_of_memfun<typename remove_reference<_MemPtr>::type, _Arg,
> _ArgTypes...>
> {
> typedef typename _Result_of_memfun<
> typename remove_reference<_MemPtr>::type, _Arg, _ArgTypes...>::__type
> __type;
> };
>
> template<typename _Functor, typename... _ArgTypes>
> struct result_of<_Functor(_ArgTypes...)>
> : _Result_of_impl<is_member_object_pointer<
> typename remove_reference<_Functor>::type >::value,
> is_member_function_pointer<
> typename remove_reference<_Functor>::type >::value,
> _Functor, _ArgTypes...>
> {
> typedef typename _Result_of_impl<
> is_member_object_pointer<
> typename remove_reference<_Functor>::type >::value,
> is_member_function_pointer<
> typename remove_reference<_Functor>::type >::value,
> _Functor, _ArgTypes...>::__type
> type;
> };
># 1903 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/type_traits" 3
>
>}
># 58 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/move.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 75 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/move.h" 3
> template<typename _Tp>
> constexpr _Tp&&
> forward(typename std::remove_reference<_Tp>::type& __t) noexcept
> { return static_cast<_Tp&&>(__t); }
>
>
>
>
>
>
>
> template<typename _Tp>
> constexpr _Tp&&
> forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
> {
> static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
> " substituting _Tp is an lvalue reference type");
> return static_cast<_Tp&&>(__t);
> }
>
>
>
>
>
>
> template<typename _Tp>
> constexpr typename std::remove_reference<_Tp>::type&&
> move(_Tp&& __t) noexcept
> { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
>
>
> template<typename _Tp>
> struct __move_if_noexcept_cond
> : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
> is_copy_constructible<_Tp>>::type { };
># 119 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/move.h" 3
> template<typename _Tp>
> inline typename
> conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
> move_if_noexcept(_Tp& __x) noexcept
> { return std::move(__x); }
># 134 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/move.h" 3
> template<typename _Tp>
> inline _Tp*
> addressof(_Tp& __r) noexcept
> { return std::__addressof(__r); }
>
>
>
>}
># 150 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/move.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 165 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/move.h" 3
> template<typename _Tp>
> inline void
> swap(_Tp& __a, _Tp& __b)
>
> noexcept(__and_<is_nothrow_move_constructible<_Tp>,
> is_nothrow_move_assignable<_Tp>>::value)
>
> {
>
> 
>
> _Tp __tmp = std::move(__a);
> __a = std::move(__b);
> __b = std::move(__tmp);
> }
>
>
>
>
> template<typename _Tp, size_t _Nm>
> inline void
> swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
>
> noexcept(noexcept(swap(*__a, *__b)))
>
> {
> for (size_t __n = 0; __n < _Nm; ++__n)
> swap(__a[__n], __b[__n]);
> }
>
>
>
>}
># 62 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> struct piecewise_construct_t { };
>
>
> constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
>
>
> template<typename...>
> class tuple;
>
> template<std::size_t...>
> struct _Index_tuple;
>
>
>
> template<class _T1, class _T2>
> struct pair
> {
> typedef _T1 first_type;
> typedef _T2 second_type;
>
> _T1 first;
> _T2 second;
>
>
>
>
>
> constexpr pair()
> : first(), second() { }
>
>
> constexpr pair(const _T1& __a, const _T2& __b)
> : first(__a), second(__b) { }
>
>
>
>
>
>
>
> template<class _U1, class _U2, class = typename
> enable_if<__and_<is_convertible<const _U1&, _T1>,
> is_convertible<const _U2&, _T2>>::value>::type>
> constexpr pair(const pair<_U1, _U2>& __p)
> : first(__p.first), second(__p.second) { }
>
> constexpr pair(const pair&) = default;
>
>
> pair(pair&& __p)
> noexcept(__and_<is_nothrow_move_constructible<_T1>,
> is_nothrow_move_constructible<_T2>>::value)
> : first(std::forward<first_type>(__p.first)),
> second(std::forward<second_type>(__p.second)) { }
>
>
> template<class _U1, class = typename
> enable_if<is_convertible<_U1, _T1>::value>::type>
> constexpr pair(_U1&& __x, const _T2& __y)
> : first(std::forward<_U1>(__x)), second(__y) { }
>
> template<class _U2, class = typename
> enable_if<is_convertible<_U2, _T2>::value>::type>
> constexpr pair(const _T1& __x, _U2&& __y)
> : first(__x), second(std::forward<_U2>(__y)) { }
>
> template<class _U1, class _U2, class = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> constexpr pair(_U1&& __x, _U2&& __y)
> : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
>
> template<class _U1, class _U2, class = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> constexpr pair(pair<_U1, _U2>&& __p)
> : first(std::forward<_U1>(__p.first)),
> second(std::forward<_U2>(__p.second)) { }
>
> template<typename... _Args1, typename... _Args2>
> pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
>
> pair&
> operator=(const pair& __p)
> {
> first = __p.first;
> second = __p.second;
> return *this;
> }
>
> pair&
> operator=(pair&& __p)
> noexcept(__and_<is_nothrow_move_assignable<_T1>,
> is_nothrow_move_assignable<_T2>>::value)
> {
> first = std::forward<first_type>(__p.first);
> second = std::forward<second_type>(__p.second);
> return *this;
> }
>
> template<class _U1, class _U2>
> pair&
> operator=(const pair<_U1, _U2>& __p)
> {
> first = __p.first;
> second = __p.second;
> return *this;
> }
>
> template<class _U1, class _U2>
> pair&
> operator=(pair<_U1, _U2>&& __p)
> {
> first = std::forward<_U1>(__p.first);
> second = std::forward<_U2>(__p.second);
> return *this;
> }
>
> void
> swap(pair& __p)
> noexcept(noexcept(swap(first, __p.first))
> && noexcept(swap(second, __p.second)))
> {
> using std::swap;
> swap(first, __p.first);
> swap(second, __p.second);
> }
>
> private:
> template<typename... _Args1, std::size_t... _Indexes1,
> typename... _Args2, std::size_t... _Indexes2>
> pair(tuple<_Args1...>&, tuple<_Args2...>&,
> _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
>
> };
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first == __y.first && __x.second == __y.second; }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __x.first < __y.first
> || (!(__y.first < __x.first) && __x.second < __y.second); }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x == __y); }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return __y < __x; }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__y < __x); }
>
>
> template<class _T1, class _T2>
> inline constexpr bool
> operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
> { return !(__x < __y); }
>
>
>
>
>
> template<class _T1, class _T2>
> inline void
> swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
># 271 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_pair.h" 3
> template<class _T1, class _T2>
> constexpr pair<typename __decay_and_strip<_T1>::__type,
> typename __decay_and_strip<_T2>::__type>
> make_pair(_T1&& __x, _T2&& __y)
> {
> typedef typename __decay_and_strip<_T1>::__type __ds_type1;
> typedef typename __decay_and_strip<_T2>::__type __ds_type2;
> typedef pair<__ds_type1, __ds_type2> __pair_type;
> return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
> }
>
>
>
>
>
>
>
>
>}
># 73 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/utility" 2 3
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/initializer_list" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/initializer_list" 3
> 
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/initializer_list" 3
>
>
>
>
>
>#pragma GCC visibility push(default)
>
>
>
>namespace std
>{
>
> template<class _E>
> class initializer_list
> {
> public:
> typedef _E value_type;
> typedef const _E& reference;
> typedef const _E& const_reference;
> typedef size_t size_type;
> typedef const _E* iterator;
> typedef const _E* const_iterator;
>
> private:
> iterator _M_array;
> size_type _M_len;
>
>
> constexpr initializer_list(const_iterator __a, size_type __l)
> : _M_array(__a), _M_len(__l) { }
>
> public:
> constexpr initializer_list() noexcept
> : _M_array(0), _M_len(0) { }
>
>
> constexpr size_type
> size() const noexcept { return _M_len; }
>
>
> constexpr const_iterator
> begin() const noexcept { return _M_array; }
>
>
> constexpr const_iterator
> end() const noexcept { return begin() + size(); }
> };
>
>
>
>
>
>
> template<class _Tp>
> constexpr const _Tp*
> begin(initializer_list<_Tp> __ils) noexcept
> { return __ils.begin(); }
>
>
>
>
>
>
> template<class _Tp>
> constexpr const _Tp*
> end(initializer_list<_Tp> __ils) noexcept
> { return __ils.end(); }
>}
>
>#pragma GCC visibility pop
># 77 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/utility" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<class _Tp>
> class tuple_size;
>
> template<std::size_t _Int, class _Tp>
> class tuple_element;
>
>
> template<class _Tp1, class _Tp2>
> struct tuple_size<std::pair<_Tp1, _Tp2>>
> : public integral_constant<std::size_t, 2> { };
>
> template<class _Tp1, class _Tp2>
> struct tuple_element<0, std::pair<_Tp1, _Tp2>>
> { typedef _Tp1 type; };
>
> template<class _Tp1, class _Tp2>
> struct tuple_element<1, std::pair<_Tp1, _Tp2>>
> { typedef _Tp2 type; };
>
> template<std::size_t _Int>
> struct __pair_get;
>
> template<>
> struct __pair_get<0>
> {
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp1&
> __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.first; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp1&&
> __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<_Tp1>(__pair.first); }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp1&
> __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.first; }
> };
>
> template<>
> struct __pair_get<1>
> {
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp2&
> __get(std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.second; }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr _Tp2&&
> __move_get(std::pair<_Tp1, _Tp2>&& __pair) noexcept
> { return std::forward<_Tp2>(__pair.second); }
>
> template<typename _Tp1, typename _Tp2>
> static constexpr const _Tp2&
> __const_get(const std::pair<_Tp1, _Tp2>& __pair) noexcept
> { return __pair.second; }
> };
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
> get(std::pair<_Tp1, _Tp2>& __in) noexcept
> { return __pair_get<_Int>::__get(__in); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&&
> get(std::pair<_Tp1, _Tp2>&& __in) noexcept
> { return __pair_get<_Int>::__move_get(std::move(__in)); }
>
> template<std::size_t _Int, class _Tp1, class _Tp2>
> constexpr const typename tuple_element<_Int, std::pair<_Tp1, _Tp2>>::type&
> get(const std::pair<_Tp1, _Tp2>& __in) noexcept
> { return __pair_get<_Int>::__const_get(__in); }
>
>
>}
># 62 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/algorithm" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 1 3
># 61 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/functexcept.h" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/functexcept.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/exception_defines.h" 1 3
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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_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__));
>
>
>}
># 62 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/cpp_type_traits.h" 1 3
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/cpp_type_traits.h" 3
> 
># 37 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/cpp_type_traits.h" 3
># 69 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/cpp_type_traits.h" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Iterator, typename _Container>
> class __normal_iterator;
>
>
>}
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> struct __true_type { };
> struct __false_type { };
>
> template<bool>
> struct __truth_type
> { typedef __false_type __type; };
>
> template<>
> struct __truth_type<true>
> { typedef __true_type __type; };
>
>
>
> template<class _Sp, class _Tp>
> struct __traitor
> {
> enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
> typedef typename __truth_type<__value>::__type __type;
> };
>
>
> template<typename, typename>
> struct __are_same
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Tp>
> struct __are_same<_Tp, _Tp>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<typename _Tp>
> struct __is_void
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_void<void>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_integer
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
>
>
> template<>
> struct __is_integer<bool>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<signed char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_integer<wchar_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
> template<>
> struct __is_integer<char16_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<char32_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_integer<short>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned short>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<int>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned int>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<long long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_integer<unsigned long long>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_floating
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
> template<>
> struct __is_floating<float>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_floating<double>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_floating<long double>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_pointer
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Tp>
> struct __is_pointer<_Tp*>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_normal_iterator
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<typename _Iterator, typename _Container>
> struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
> _Container> >
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_arithmetic
> : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_fundamental
> : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_scalar
> : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
> { };
>
>
>
>
> template<typename _Tp>
> struct __is_char
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_char<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<>
> struct __is_char<wchar_t>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
> template<typename _Tp>
> struct __is_byte
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
> template<>
> struct __is_byte<char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_byte<signed char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
> template<>
> struct __is_byte<unsigned char>
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>
> template<typename _Tp>
> struct __is_move_iterator
> {
> enum { __value = 0 };
> typedef __false_type __type;
> };
>
>
> template<typename _Iterator>
> class move_iterator;
>
> template<typename _Iterator>
> struct __is_move_iterator< move_iterator<_Iterator> >
> {
> enum { __value = 1 };
> typedef __true_type __type;
> };
>
>
>
>}
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/type_traits.h" 1 3
># 32 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/type_traits.h" 3
> 
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/type_traits.h" 3
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<bool, typename>
> struct __enable_if
> { };
>
> template<typename _Tp>
> struct __enable_if<true, _Tp>
> { typedef _Tp __type; };
>
>
>
> template<bool _Cond, typename _Iftrue, typename _Iffalse>
> struct __conditional_type
> { typedef _Iftrue __type; };
>
> template<typename _Iftrue, typename _Iffalse>
> struct __conditional_type<false, _Iftrue, _Iffalse>
> { typedef _Iffalse __type; };
>
>
>
> template<typename _Tp>
> struct __add_unsigned
> {
> private:
> typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
>
> public:
> typedef typename __if_type::__type __type;
> };
>
> template<>
> struct __add_unsigned<char>
> { typedef unsigned char __type; };
>
> template<>
> struct __add_unsigned<signed char>
> { typedef unsigned char __type; };
>
> template<>
> struct __add_unsigned<short>
> { typedef unsigned short __type; };
>
> template<>
> struct __add_unsigned<int>
> { typedef unsigned int __type; };
>
> template<>
> struct __add_unsigned<long>
> { typedef unsigned long __type; };
>
> template<>
> struct __add_unsigned<long long>
> { typedef unsigned long long __type; };
>
>
> template<>
> struct __add_unsigned<bool>;
>
> template<>
> struct __add_unsigned<wchar_t>;
>
>
>
> template<typename _Tp>
> struct __remove_unsigned
> {
> private:
> typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
>
> public:
> typedef typename __if_type::__type __type;
> };
>
> template<>
> struct __remove_unsigned<char>
> { typedef signed char __type; };
>
> template<>
> struct __remove_unsigned<unsigned char>
> { typedef signed char __type; };
>
> template<>
> struct __remove_unsigned<unsigned short>
> { typedef short __type; };
>
> template<>
> struct __remove_unsigned<unsigned int>
> { typedef int __type; };
>
> template<>
> struct __remove_unsigned<unsigned long>
> { typedef long __type; };
>
> template<>
> struct __remove_unsigned<unsigned long long>
> { typedef long long __type; };
>
>
> template<>
> struct __remove_unsigned<bool>;
>
> template<>
> struct __remove_unsigned<wchar_t>;
>
>
>
> template<typename _Type>
> inline bool
> __is_null_pointer(_Type* __ptr)
> { return __ptr == 0; }
>
> template<typename _Type>
> inline bool
> __is_null_pointer(_Type)
> { return false; }
>
>
>
> template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
> struct __promote
> { typedef double __type; };
>
>
>
>
> template<typename _Tp>
> struct __promote<_Tp, false>
> { };
>
> template<>
> struct __promote<long double>
> { typedef long double __type; };
>
> template<>
> struct __promote<double>
> { typedef double __type; };
>
> template<>
> struct __promote<float>
> { typedef float __type; };
>
> template<typename _Tp, typename _Up,
> typename _Tp2 = typename __promote<_Tp>::__type,
> typename _Up2 = typename __promote<_Up>::__type>
> struct __promote_2
> {
> typedef __typeof__(_Tp2() + _Up2()) __type;
> };
>
> template<typename _Tp, typename _Up, typename _Vp,
> typename _Tp2 = typename __promote<_Tp>::__type,
> typename _Up2 = typename __promote<_Up>::__type,
> typename _Vp2 = typename __promote<_Vp>::__type>
> struct __promote_3
> {
> typedef __typeof__(_Tp2() + _Up2() + _Vp2()) __type;
> };
>
> template<typename _Tp, typename _Up, typename _Vp, typename _Wp,
> typename _Tp2 = typename __promote<_Tp>::__type,
> typename _Up2 = typename __promote<_Up>::__type,
> typename _Vp2 = typename __promote<_Vp>::__type,
> typename _Wp2 = typename __promote<_Wp>::__type>
> struct __promote_4
> {
> typedef __typeof__(_Tp2() + _Up2() + _Vp2() + _Wp2()) __type;
> };
>
>
>}
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/numeric_traits.h" 1 3
># 32 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/numeric_traits.h" 3
> 
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/numeric_traits.h" 3
>
>
>
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 54 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/numeric_traits.h" 3
> template<typename _Value>
> 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<typename _Value>
> const _Value __numeric_traits_integer<_Value>::__min;
>
> template<typename _Value>
> const _Value __numeric_traits_integer<_Value>::__max;
>
> template<typename _Value>
> const bool __numeric_traits_integer<_Value>::__is_signed;
>
> template<typename _Value>
> const int __numeric_traits_integer<_Value>::__digits;
># 99 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/numeric_traits.h" 3
> template<typename _Value>
> 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<typename _Value>
> const int __numeric_traits_floating<_Value>::__max_digits10;
>
> template<typename _Value>
> const bool __numeric_traits_floating<_Value>::__is_signed;
>
> template<typename _Value>
> const int __numeric_traits_floating<_Value>::__digits10;
>
> template<typename _Value>
> const int __numeric_traits_floating<_Value>::__max_exponent10;
>
> template<typename _Value>
> struct __numeric_traits
> : public __conditional_type<std::__is_integer<_Value>::__value,
> __numeric_traits_integer<_Value>,
> __numeric_traits_floating<_Value> >::__type
> { };
>
>
>}
># 65 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 2 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_types.h" 1 3
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_types.h" 3
> 
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_types.h" 3
>
>
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 90 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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 { };
># 117 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_types.h" 3
> template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
> typename _Pointer = _Tp*, typename _Reference = _Tp&>
> struct iterator
> {
>
> typedef _Category iterator_category;
>
> typedef _Tp value_type;
>
> typedef _Distance difference_type;
>
> typedef _Pointer pointer;
>
> typedef _Reference reference;
> };
># 143 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_types.h" 3
>template<typename _Tp> class __has_iterator_category_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::iterator_category>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_iterator_category : integral_constant<bool, __has_iterator_category_helper <typename remove_cv<_Tp>::type>::value> { };
>
> template<typename _Iterator,
> bool = __has_iterator_category<_Iterator>::value>
> struct __iterator_traits { };
>
> template<typename _Iterator>
> struct __iterator_traits<_Iterator, true>
> {
> 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<typename _Iterator>
> struct iterator_traits
> : public __iterator_traits<_Iterator> { };
># 175 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_types.h" 3
> template<typename _Tp>
> 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<typename _Tp>
> struct iterator_traits<const _Tp*>
> {
> typedef random_access_iterator_tag iterator_category;
> typedef _Tp value_type;
> typedef ptrdiff_t difference_type;
> typedef const _Tp* pointer;
> typedef const _Tp& reference;
> };
>
>
>
>
>
> template<typename _Iter>
> inline typename iterator_traits<_Iter>::iterator_category
> __iterator_category(const _Iter&)
> { return typename iterator_traits<_Iter>::iterator_category(); }
>
>
>
>
>
> template<typename _Iterator, bool _HasBase>
> struct _Iter_base
> {
> typedef _Iterator iterator_type;
> static iterator_type _S_base(_Iterator __it)
> { return __it; }
> };
>
> template<typename _Iterator>
> struct _Iter_base<_Iterator, true>
> {
> typedef typename _Iterator::iterator_type iterator_type;
> static iterator_type _S_base(_Iterator __it)
> { return __it.base(); }
> };
>
>
>}
># 67 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_funcs.h" 1 3
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_funcs.h" 3
> 
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_funcs.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _InputIterator>
> 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<typename _RandomAccessIterator>
> 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-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_funcs.h" 3
> template<typename _InputIterator>
> inline typename iterator_traits<_InputIterator>::difference_type
> distance(_InputIterator __first, _InputIterator __last)
> {
>
> return std::__distance(__first, __last,
> std::__iterator_category(__first));
> }
>
> template<typename _InputIterator, typename _Distance>
> inline void
> __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
> {
>
> 
> while (__n--)
> ++__i;
> }
>
> template<typename _BidirectionalIterator, typename _Distance>
> inline void
> __advance(_BidirectionalIterator& __i, _Distance __n,
> bidirectional_iterator_tag)
> {
>
> 
>
> if (__n > 0)
> while (__n--)
> ++__i;
> else
> while (__n++)
> --__i;
> }
>
> template<typename _RandomAccessIterator, typename _Distance>
> inline void
> __advance(_RandomAccessIterator& __i, _Distance __n,
> random_access_iterator_tag)
> {
>
> 
>
> __i += __n;
> }
># 170 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator_base_funcs.h" 3
> template<typename _InputIterator, typename _Distance>
> inline void
> advance(_InputIterator& __i, _Distance __n)
> {
>
> typename iterator_traits<_InputIterator>::difference_type __d = __n;
> std::__advance(__i, __d, std::__iterator_category(__i));
> }
>
>
>
> template<typename _ForwardIterator>
> inline _ForwardIterator
> next(_ForwardIterator __x, typename
> iterator_traits<_ForwardIterator>::difference_type __n = 1)
> {
> std::advance(__x, __n);
> return __x;
> }
>
> template<typename _BidirectionalIterator>
> inline _BidirectionalIterator
> prev(_BidirectionalIterator __x, typename
> iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
> {
> std::advance(__x, -__n);
> return __x;
> }
>
>
>
>
>}
># 68 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 1 3
># 69 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 97 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _Iterator>
> class reverse_iterator
> : public iterator<typename iterator_traits<_Iterator>::iterator_category,
> typename iterator_traits<_Iterator>::value_type,
> typename iterator_traits<_Iterator>::difference_type,
> typename iterator_traits<_Iterator>::pointer,
> typename iterator_traits<_Iterator>::reference>
> {
> protected:
> _Iterator current;
>
> typedef iterator_traits<_Iterator> __traits_type;
>
> public:
> typedef _Iterator iterator_type;
> typedef typename __traits_type::difference_type difference_type;
> typedef typename __traits_type::pointer pointer;
> typedef typename __traits_type::reference reference;
>
>
>
>
>
>
>
> reverse_iterator() : current() { }
>
>
>
>
> explicit
> reverse_iterator(iterator_type __x) : current(__x) { }
>
>
>
>
> reverse_iterator(const reverse_iterator& __x)
> : current(__x.current) { }
>
>
>
>
>
> template<typename _Iter>
> reverse_iterator(const reverse_iterator<_Iter>& __x)
> : current(__x.base()) { }
>
>
>
>
> iterator_type
> base() const
> { return current; }
># 161 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
> };
># 291 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _Iterator>
> inline bool
> operator==(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _Iterator>
> inline bool
> operator<(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y.base() < __x.base(); }
>
> template<typename _Iterator>
> inline bool
> operator!=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__x == __y); }
>
> template<typename _Iterator>
> inline bool
> operator>(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y < __x; }
>
> template<typename _Iterator>
> inline bool
> operator<=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__y < __x); }
>
> template<typename _Iterator>
> inline bool
> operator>=(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return !(__x < __y); }
>
> template<typename _Iterator>
> inline typename reverse_iterator<_Iterator>::difference_type
> operator-(const reverse_iterator<_Iterator>& __x,
> const reverse_iterator<_Iterator>& __y)
> { return __y.base() - __x.base(); }
>
> template<typename _Iterator>
> inline reverse_iterator<_Iterator>
> operator+(typename reverse_iterator<_Iterator>::difference_type __n,
> const reverse_iterator<_Iterator>& __x)
> { return reverse_iterator<_Iterator>(__x.base() - __n); }
>
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator==(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __y.base() < __x.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator!=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__x == __y); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return __y < __x; }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__y < __x); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>=(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> { return !(__x < __y); }
>
> template<typename _IteratorL, typename _IteratorR>
>
>
> inline auto
> operator-(const reverse_iterator<_IteratorL>& __x,
> const reverse_iterator<_IteratorR>& __y)
> -> decltype(__y.base() - __x.base())
>
>
>
>
>
> { return __y.base() - __x.base(); }
># 403 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _Container>
> class back_insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
>
> public:
>
> typedef _Container container_type;
>
>
> explicit
> back_insert_iterator(_Container& __x) : container(&__x) { }
># 437 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> back_insert_iterator&
> operator=(const typename _Container::value_type& __value)
> {
> container->push_back(__value);
> return *this;
> }
>
> back_insert_iterator&
> operator=(typename _Container::value_type&& __value)
> {
> container->push_back(std::move(__value));
> return *this;
> }
>
>
>
> back_insert_iterator&
> operator*()
> { return *this; }
>
>
> back_insert_iterator&
> operator++()
> { return *this; }
>
>
> back_insert_iterator
> operator++(int)
> { return *this; }
> };
># 479 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _Container>
> inline back_insert_iterator<_Container>
> back_inserter(_Container& __x)
> { return back_insert_iterator<_Container>(__x); }
># 494 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _Container>
> class front_insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
>
> public:
>
> typedef _Container container_type;
>
>
> explicit front_insert_iterator(_Container& __x) : container(&__x) { }
># 527 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> front_insert_iterator&
> operator=(const typename _Container::value_type& __value)
> {
> container->push_front(__value);
> return *this;
> }
>
> front_insert_iterator&
> operator=(typename _Container::value_type&& __value)
> {
> container->push_front(std::move(__value));
> return *this;
> }
>
>
>
> front_insert_iterator&
> operator*()
> { return *this; }
>
>
> front_insert_iterator&
> operator++()
> { return *this; }
>
>
> front_insert_iterator
> operator++(int)
> { return *this; }
> };
># 569 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _Container>
> inline front_insert_iterator<_Container>
> front_inserter(_Container& __x)
> { return front_insert_iterator<_Container>(__x); }
># 588 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _Container>
> class insert_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> protected:
> _Container* container;
> typename _Container::iterator iter;
>
> public:
>
> typedef _Container container_type;
>
>
>
>
>
> insert_iterator(_Container& __x, typename _Container::iterator __i)
> : container(&__x), iter(__i) {}
># 639 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> insert_iterator&
> operator=(const typename _Container::value_type& __value)
> {
> iter = container->insert(iter, __value);
> ++iter;
> return *this;
> }
>
> insert_iterator&
> operator=(typename _Container::value_type&& __value)
> {
> iter = container->insert(iter, std::move(__value));
> ++iter;
> return *this;
> }
>
>
>
> insert_iterator&
> operator*()
> { return *this; }
>
>
> insert_iterator&
> operator++()
> { return *this; }
>
>
> insert_iterator&
> operator++(int)
> { return *this; }
> };
># 683 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _Container, typename _Iterator>
> inline insert_iterator<_Container>
> inserter(_Container& __x, _Iterator __i)
> {
> return insert_iterator<_Container>(__x,
> typename _Container::iterator(__i));
> }
>
>
>
>
>}
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 707 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> using std::iterator_traits;
> using std::iterator;
> template<typename _Iterator, typename _Container>
> class __normal_iterator
> {
> protected:
> _Iterator _M_current;
>
> typedef iterator_traits<_Iterator> __traits_type;
>
> public:
> typedef _Iterator iterator_type;
> typedef typename __traits_type::iterator_category iterator_category;
> typedef typename __traits_type::value_type value_type;
> typedef typename __traits_type::difference_type difference_type;
> typedef typename __traits_type::reference reference;
> typedef typename __traits_type::pointer pointer;
>
> constexpr __normal_iterator() : _M_current(_Iterator()) { }
>
> explicit
> __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
>
>
> template<typename _Iter>
> __normal_iterator(const __normal_iterator<_Iter,
> typename __enable_if<
> (std::__are_same<_Iter, typename _Container::pointer>::__value),
> _Container>::__type>& __i)
> : _M_current(__i.base()) { }
>
>
> reference
> operator*() const
> { return *_M_current; }
>
> pointer
> operator->() const
> { return _M_current; }
>
> __normal_iterator&
> operator++()
> {
> ++_M_current;
> return *this;
> }
>
> __normal_iterator
> operator++(int)
> { return __normal_iterator(_M_current++); }
>
>
> __normal_iterator&
> operator--()
> {
> --_M_current;
> return *this;
> }
>
> __normal_iterator
> operator--(int)
> { return __normal_iterator(_M_current--); }
>
>
> reference
> operator[](const difference_type& __n) const
> { return _M_current[__n]; }
>
> __normal_iterator&
> operator+=(const difference_type& __n)
> { _M_current += __n; return *this; }
>
> __normal_iterator
> operator+(const difference_type& __n) const
> { return __normal_iterator(_M_current + __n); }
>
> __normal_iterator&
> operator-=(const difference_type& __n)
> { _M_current -= __n; return *this; }
>
> __normal_iterator
> operator-(const difference_type& __n) const
> { return __normal_iterator(_M_current - __n); }
>
> const _Iterator&
> base() const
> { return _M_current; }
> };
># 805 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() == __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() == __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() != __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() != __rhs.base(); }
>
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() < __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() < __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() > __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() > __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() <= __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() <= __rhs.base(); }
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
> inline bool
> operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> { return __lhs.base() >= __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline bool
> operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() >= __rhs.base(); }
>
>
>
>
>
> template<typename _IteratorL, typename _IteratorR, typename _Container>
>
>
> inline auto
> operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
> const __normal_iterator<_IteratorR, _Container>& __rhs)
> -> decltype(__lhs.base() - __rhs.base())
>
>
>
>
>
> { return __lhs.base() - __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline typename __normal_iterator<_Iterator, _Container>::difference_type
> operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
> const __normal_iterator<_Iterator, _Container>& __rhs)
> { return __lhs.base() - __rhs.base(); }
>
> template<typename _Iterator, typename _Container>
> inline __normal_iterator<_Iterator, _Container>
> operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
> __n, const __normal_iterator<_Iterator, _Container>& __i)
> { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
>
>
>}
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 931 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_iterator.h" 3
> template<typename _Iterator>
> class move_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 _Iterator pointer;
> typedef value_type&& reference;
>
> move_iterator()
> : _M_current() { }
>
> explicit
> move_iterator(iterator_type __i)
> : _M_current(__i) { }
>
> template<typename _Iter>
> move_iterator(const move_iterator<_Iter>& __i)
> : _M_current(__i.base()) { }
>
> iterator_type
> base() const
> { return _M_current; }
>
> reference
> operator*() const
> { return std::move(*_M_current); }
>
> pointer
> operator->() const
> { return _M_current; }
>
> move_iterator&
> operator++()
> {
> ++_M_current;
> return *this;
> }
>
> move_iterator
> operator++(int)
> {
> move_iterator __tmp = *this;
> ++_M_current;
> return __tmp;
> }
>
> move_iterator&
> operator--()
> {
> --_M_current;
> return *this;
> }
>
> move_iterator
> operator--(int)
> {
> move_iterator __tmp = *this;
> --_M_current;
> return __tmp;
> }
>
> move_iterator
> operator+(difference_type __n) const
> { return move_iterator(_M_current + __n); }
>
> move_iterator&
> operator+=(difference_type __n)
> {
> _M_current += __n;
> return *this;
> }
>
> move_iterator
> operator-(difference_type __n) const
> { return move_iterator(_M_current - __n); }
>
> move_iterator&
> operator-=(difference_type __n)
> {
> _M_current -= __n;
> return *this;
> }
>
> reference
> operator[](difference_type __n) const
> { return std::move(_M_current[__n]); }
> };
>
>
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator==(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _Iterator>
> inline bool
> operator==(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return __x.base() == __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator!=(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return !(__x == __y); }
>
> template<typename _Iterator>
> inline bool
> operator!=(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return !(__x == __y); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return __x.base() < __y.base(); }
>
> template<typename _Iterator>
> inline bool
> operator<(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return __x.base() < __y.base(); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator<=(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return !(__y < __x); }
>
> template<typename _Iterator>
> inline bool
> operator<=(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return !(__y < __x); }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return __y < __x; }
>
> template<typename _Iterator>
> inline bool
> operator>(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return __y < __x; }
>
> template<typename _IteratorL, typename _IteratorR>
> inline bool
> operator>=(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> { return !(__x < __y); }
>
> template<typename _Iterator>
> inline bool
> operator>=(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> { return !(__x < __y); }
>
>
> template<typename _IteratorL, typename _IteratorR>
> inline auto
> operator-(const move_iterator<_IteratorL>& __x,
> const move_iterator<_IteratorR>& __y)
> -> decltype(__x.base() - __y.base())
> { return __x.base() - __y.base(); }
>
> template<typename _Iterator>
> inline auto
> operator-(const move_iterator<_Iterator>& __x,
> const move_iterator<_Iterator>& __y)
> -> decltype(__x.base() - __y.base())
> { return __x.base() - __y.base(); }
>
> template<typename _Iterator>
> inline move_iterator<_Iterator>
> operator+(typename move_iterator<_Iterator>::difference_type __n,
> const move_iterator<_Iterator>& __x)
> { return __x + __n; }
>
> template<typename _Iterator>
> inline move_iterator<_Iterator>
> make_move_iterator(_Iterator __i)
> { return move_iterator<_Iterator>(__i); }
>
> template<typename _Iterator, typename _ReturnType
> = typename conditional<__move_if_noexcept_cond
> <typename iterator_traits<_Iterator>::value_type>::value,
> _Iterator, move_iterator<_Iterator>>::type>
> inline _ReturnType
> __make_move_if_noexcept_iterator(_Iterator __i)
> { return _ReturnType(__i); }
>
>
>
>
>}
># 69 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 2 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/debug/debug.h" 1 3
># 47 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/debug/debug.h" 3
>namespace std
>{
> namespace __debug { }
>}
>
>
>
>
>namespace __gnu_debug
>{
> using namespace std::__debug;
>}
># 71 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
> template<bool _BoolType>
> struct __iter_swap
> {
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> static void
> iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
> {
> typedef typename iterator_traits<_ForwardIterator1>::value_type
> _ValueType1;
> _ValueType1 __tmp = std::move(*__a);
> *__a = std::move(*__b);
> *__b = std::move(__tmp);
> }
> };
>
> template<>
> struct __iter_swap<true>
> {
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> static void
> iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
> {
> swap(*__a, *__b);
> }
> };
># 116 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> inline void
> iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
> {
> typedef typename iterator_traits<_ForwardIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_ForwardIterator2>::value_type
> _ValueType2;
>
>
> 
>
> 
>
> 
>
> 
>
>
> typedef typename iterator_traits<_ForwardIterator1>::reference
> _ReferenceType1;
> typedef typename iterator_traits<_ForwardIterator2>::reference
> _ReferenceType2;
> std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
> && __are_same<_ValueType1&, _ReferenceType1>::__value
> && __are_same<_ValueType2&, _ReferenceType2>::__value>::
> iter_swap(__a, __b);
> }
># 157 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator2
> swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2)
> {
>
> 
>
> 
>
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> std::iter_swap(__first1, __first2);
> return __first2;
> }
># 185 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _Tp>
> inline const _Tp&
> min(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> if (__b < __a)
> return __b;
> return __a;
> }
># 208 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _Tp>
> inline const _Tp&
> max(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> if (__a < __b)
> return __b;
> return __a;
> }
># 231 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _Tp, typename _Compare>
> inline const _Tp&
> min(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
>
> if (__comp(__b, __a))
> return __b;
> return __a;
> }
># 252 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _Tp, typename _Compare>
> inline const _Tp&
> max(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
>
> if (__comp(__a, __b))
> return __b;
> return __a;
> }
>
>
>
> template<typename _Iterator>
> struct _Niter_base
> : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
> { };
>
> template<typename _Iterator>
> inline typename _Niter_base<_Iterator>::iterator_type
> __niter_base(_Iterator __it)
> { return std::_Niter_base<_Iterator>::_S_base(__it); }
>
>
> template<typename _Iterator>
> struct _Miter_base
> : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
> { };
>
> template<typename _Iterator>
> inline typename _Miter_base<_Iterator>::iterator_type
> __miter_base(_Iterator __it)
> { return std::_Miter_base<_Iterator>::_S_base(__it); }
>
>
>
>
>
>
>
> template<bool, bool, typename>
> struct __copy_move
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> for (; __first != __last; ++__result, ++__first)
> *__result = *__first;
> return __result;
> }
> };
>
>
> template<typename _Category>
> struct __copy_move<true, false, _Category>
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> for (; __first != __last; ++__result, ++__first)
> *__result = std::move(*__first);
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move<false, false, random_access_iterator_tag>
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::difference_type _Distance;
> for(_Distance __n = __last - __first; __n > 0; --__n)
> {
> *__result = *__first;
> ++__first;
> ++__result;
> }
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move<true, false, random_access_iterator_tag>
> {
> template<typename _II, typename _OI>
> static _OI
> __copy_m(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::difference_type _Distance;
> for(_Distance __n = __last - __first; __n > 0; --__n)
> {
> *__result = std::move(*__first);
> ++__first;
> ++__result;
> }
> return __result;
> }
> };
>
>
> template<bool _IsMove>
> struct __copy_move<_IsMove, true, random_access_iterator_tag>
> {
> template<typename _Tp>
> static _Tp*
> __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
> const ptrdiff_t _Num = __last - __first;
> if (_Num)
> __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
> return __result + _Num;
> }
> };
>
> template<bool _IsMove, typename _II, typename _OI>
> inline _OI
> __copy_move_a(_II __first, _II __last, _OI __result)
> {
> typedef typename iterator_traits<_II>::value_type _ValueTypeI;
> typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
> typedef typename iterator_traits<_II>::iterator_category _Category;
> const bool __simple = (__is_trivial(_ValueTypeI)
> && __is_pointer<_II>::__value
> && __is_pointer<_OI>::__value
> && __are_same<_ValueTypeI, _ValueTypeO>::__value);
>
> return std::__copy_move<_IsMove, __simple,
> _Category>::__copy_m(__first, __last, __result);
> }
>
>
>
> template<typename _CharT>
> struct char_traits;
>
> template<typename _CharT, typename _Traits>
> class istreambuf_iterator;
>
> template<typename _CharT, typename _Traits>
> class ostreambuf_iterator;
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
> __copy_move_a2(_CharT*, _CharT*,
> ostreambuf_iterator<_CharT, char_traits<_CharT> >);
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
> __copy_move_a2(const _CharT*, const _CharT*,
> ostreambuf_iterator<_CharT, char_traits<_CharT> >);
>
> template<bool _IsMove, typename _CharT>
> 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<bool _IsMove, typename _II, typename _OI>
> inline _OI
> __copy_move_a2(_II __first, _II __last, _OI __result)
> {
> return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
> std::__niter_base(__last),
> std::__niter_base(__result)));
> }
># 442 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _II, typename _OI>
> inline _OI
> copy(_II __first, _II __last, _OI __result)
> {
>
> 
> 
>
> ;
>
> return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
> (std::__miter_base(__first), std::__miter_base(__last),
> __result));
> }
># 475 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _II, typename _OI>
> inline _OI
> move(_II __first, _II __last, _OI __result)
> {
>
> 
> 
>
> ;
>
> return std::__copy_move_a2<true>(std::__miter_base(__first),
> std::__miter_base(__last), __result);
> }
>
>
>
>
>
>
> template<bool, bool, typename>
> struct __copy_move_backward
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> while (__first != __last)
> *--__result = *--__last;
> return __result;
> }
> };
>
>
> template<typename _Category>
> struct __copy_move_backward<true, false, _Category>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> while (__first != __last)
> *--__result = std::move(*--__last);
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move_backward<false, false, random_access_iterator_tag>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typename iterator_traits<_BI1>::difference_type __n;
> for (__n = __last - __first; __n > 0; --__n)
> *--__result = *--__last;
> return __result;
> }
> };
>
>
> template<>
> struct __copy_move_backward<true, false, random_access_iterator_tag>
> {
> template<typename _BI1, typename _BI2>
> static _BI2
> __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typename iterator_traits<_BI1>::difference_type __n;
> for (__n = __last - __first; __n > 0; --__n)
> *--__result = std::move(*--__last);
> return __result;
> }
> };
>
>
> template<bool _IsMove>
> struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
> {
> template<typename _Tp>
> static _Tp*
> __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
> {
> const ptrdiff_t _Num = __last - __first;
> if (_Num)
> __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
> return __result - _Num;
> }
> };
>
> template<bool _IsMove, typename _BI1, typename _BI2>
> inline _BI2
> __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> typedef typename iterator_traits<_BI1>::value_type _ValueType1;
> typedef typename iterator_traits<_BI2>::value_type _ValueType2;
> typedef typename iterator_traits<_BI1>::iterator_category _Category;
> const bool __simple = (__is_trivial(_ValueType1)
> && __is_pointer<_BI1>::__value
> && __is_pointer<_BI2>::__value
> && __are_same<_ValueType1, _ValueType2>::__value);
>
> return std::__copy_move_backward<_IsMove, __simple,
> _Category>::__copy_move_b(__first,
> __last,
> __result);
> }
>
> template<bool _IsMove, typename _BI1, typename _BI2>
> inline _BI2
> __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
> {
> return _BI2(std::__copy_move_backward_a<_IsMove>
> (std::__niter_base(__first), std::__niter_base(__last),
> std::__niter_base(__result)));
> }
># 611 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _BI1, typename _BI2>
> inline _BI2
> copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
> {
>
> 
> 
> 
>
>
> ;
>
> return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
> (std::__miter_base(__first), std::__miter_base(__last),
> __result));
> }
># 647 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _BI1, typename _BI2>
> inline _BI2
> move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
> {
>
> 
> 
> 
>
>
> ;
>
> return std::__copy_move_backward_a2<true>(std::__miter_base(__first),
> std::__miter_base(__last),
> __result);
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
> __fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
> for (; __first != __last; ++__first)
> *__first = __value;
> }
>
> template<typename _ForwardIterator, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
> __fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
> const _Tp __tmp = __value;
> for (; __first != __last; ++__first)
> *__first = __tmp;
> }
>
>
> template<typename _Tp>
> 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;
> __builtin_memset(__first, static_cast<unsigned char>(__tmp),
> __last - __first);
> }
># 713 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline void
> fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
> {
>
> 
>
> ;
>
> std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
> __value);
> }
>
> template<typename _OutputIterator, typename _Size, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
> __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
> for (__decltype(__n + 0) __niter = __n;
> __niter > 0; --__niter, ++__first)
> *__first = __value;
> return __first;
> }
>
> template<typename _OutputIterator, typename _Size, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
> __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
> {
> const _Tp __tmp = __value;
> for (__decltype(__n + 0) __niter = __n;
> __niter > 0; --__niter, ++__first)
> *__first = __tmp;
> return __first;
> }
>
> template<typename _Size, typename _Tp>
> inline typename
> __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
> __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
> {
> std::__fill_a(__first, __first + __n, __c);
> return __first + __n;
> }
># 773 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _OI, typename _Size, typename _Tp>
> inline _OI
> fill_n(_OI __first, _Size __n, const _Tp& __value)
> {
>
> 
>
> return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
> }
>
> template<bool _BoolType>
> struct __equal
> {
> template<typename _II1, typename _II2>
> static bool
> equal(_II1 __first1, _II1 __last1, _II2 __first2)
> {
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!(*__first1 == *__first2))
> return false;
> return true;
> }
> };
>
> template<>
> struct __equal<true>
> {
> template<typename _Tp>
> static bool
> equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
> {
> return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
> * (__last1 - __first1));
> }
> };
>
> template<typename _II1, typename _II2>
> inline bool
> __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
> {
> typedef typename iterator_traits<_II1>::value_type _ValueType1;
> typedef typename iterator_traits<_II2>::value_type _ValueType2;
> const bool __simple = ((__is_integer<_ValueType1>::__value
> || __is_pointer<_ValueType1>::__value)
> && __is_pointer<_II1>::__value
> && __is_pointer<_II2>::__value
> && __are_same<_ValueType1, _ValueType2>::__value);
>
> return std::__equal<__simple>::equal(__first1, __last1, __first2);
> }
>
>
> template<typename, typename>
> struct __lc_rai
> {
> template<typename _II1, typename _II2>
> static _II1
> __newlast1(_II1, _II1 __last1, _II2, _II2)
> { return __last1; }
>
> template<typename _II>
> static bool
> __cnd2(_II __first, _II __last)
> { return __first != __last; }
> };
>
> template<>
> struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
> {
> template<typename _RAI1, typename _RAI2>
> static _RAI1
> __newlast1(_RAI1 __first1, _RAI1 __last1,
> _RAI2 __first2, _RAI2 __last2)
> {
> const typename iterator_traits<_RAI1>::difference_type
> __diff1 = __last1 - __first1;
> const typename iterator_traits<_RAI2>::difference_type
> __diff2 = __last2 - __first2;
> return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
> }
>
> template<typename _RAI>
> static bool
> __cnd2(_RAI, _RAI)
> { return true; }
> };
>
> template<bool _BoolType>
> struct __lexicographical_compare
> {
> template<typename _II1, typename _II2>
> static bool __lc(_II1, _II1, _II2, _II2);
> };
>
> template<bool _BoolType>
> template<typename _II1, typename _II2>
> bool
> __lexicographical_compare<_BoolType>::
> __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
> {
> 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 (*__first1 < *__first2)
> return true;
> if (*__first2 < *__first1)
> return false;
> }
> return __first1 == __last1 && __first2 != __last2;
> }
>
> template<>
> struct __lexicographical_compare<true>
> {
> template<typename _Tp, typename _Up>
> static bool
> __lc(const _Tp* __first1, const _Tp* __last1,
> const _Up* __first2, const _Up* __last2)
> {
> const size_t __len1 = __last1 - __first1;
> const size_t __len2 = __last2 - __first2;
> const int __result = __builtin_memcmp(__first1, __first2,
> std::min(__len1, __len2));
> return __result != 0 ? __result < 0 : __len1 < __len2;
> }
> };
>
> template<typename _II1, typename _II2>
> inline bool
> __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
> _II2 __first2, _II2 __last2)
> {
> typedef typename iterator_traits<_II1>::value_type _ValueType1;
> typedef typename iterator_traits<_II2>::value_type _ValueType2;
> const bool __simple =
> (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
> && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
> && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
> && __is_pointer<_II1>::__value
> && __is_pointer<_II2>::__value);
>
> return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
> __first2, __last2);
> }
># 935 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> 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 (*__middle < __val)
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
>
>
>
> template<typename _Size>
> inline _Size
> __lg(_Size __n)
> {
> _Size __k;
> for (__k = 0; __n != 0; __n >>= 1)
> ++__k;
> return __k - 1;
> }
>
> 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); }
>
>
>
>
># 1021 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2>
> inline bool
> equal(_II1 __first1, _II1 __last1, _II2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> return std::__equal_aux(std::__niter_base(__first1),
> std::__niter_base(__last1),
> std::__niter_base(__first2));
> }
># 1053 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> inline bool
> equal(_IIter1 __first1, _IIter1 __last1,
> _IIter2 __first2, _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!bool(__binary_pred(*__first1, *__first2)))
> return false;
> return true;
> }
># 1084 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2>
> inline bool
> lexicographical_compare(_II1 __first1, _II1 __last1,
> _II2 __first2, _II2 __last2)
> {
>
> typedef typename iterator_traits<_II1>::value_type _ValueType1;
> typedef typename iterator_traits<_II2>::value_type _ValueType2;
> 
> 
> 
> 
> ;
> ;
>
> return std::__lexicographical_compare_aux(std::__niter_base(__first1),
> std::__niter_base(__last1),
> std::__niter_base(__first2),
> std::__niter_base(__last2));
> }
># 1118 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _II1, typename _II2, typename _Compare>
> bool
> lexicographical_compare(_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;
> }
># 1158 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2)
> {
>
> 
> 
> 
>
>
> ;
>
> while (__first1 != __last1 && *__first1 == *__first2)
> {
> ++__first1;
> ++__first2;
> }
> return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
> }
># 1195 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algobase.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _BinaryPredicate>
> pair<_InputIterator1, _InputIterator2>
> mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _BinaryPredicate __binary_pred)
> {
>
> 
> 
> ;
>
> while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
> {
> ++__first1;
> ++__first2;
> }
> return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
> }
>
>
>}
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/algorithm" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 1 3
># 61 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 3
># 66 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 3
># 1 "/usr/include/stdlib.h" 1 3 4
># 33 "/usr/include/stdlib.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 34 "/usr/include/stdlib.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>
># 1 "/usr/include/bits/waitflags.h" 1 3 4
># 43 "/usr/include/stdlib.h" 2 3 4
># 1 "/usr/include/bits/waitstatus.h" 1 3 4
># 65 "/usr/include/bits/waitstatus.h" 3 4
># 1 "/usr/include/endian.h" 1 3 4
># 37 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/endian.h" 1 3 4
># 38 "/usr/include/endian.h" 2 3 4
># 61 "/usr/include/endian.h" 3 4
># 1 "/usr/include/bits/byteswap.h" 1 3 4
># 28 "/usr/include/bits/byteswap.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/bits/byteswap.h" 2 3 4
># 62 "/usr/include/endian.h" 2 3 4
># 66 "/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;
> };
># 44 "/usr/include/stdlib.h" 2 3 4
># 96 "/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;
>
>
># 140 "/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))) ;
>
># 236 "/usr/include/stdlib.h" 3 4
># 1 "/usr/include/xlocale.h" 1 3 4
># 28 "/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;
># 237 "/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))) ;
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) double
>__attribute__ ((__leaf__)) atof (__const char *__nptr) throw ()
>{
> return strtod (__nptr, (char **) __null);
>}
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) atoi (__const char *__nptr) throw ()
>{
> return (int) strtol (__nptr, (char **) __null, 10);
>}
>extern __inline __attribute__ ((__gnu_inline__)) long int
>__attribute__ ((__leaf__)) atol (__const char *__nptr) throw ()
>{
> return strtol (__nptr, (char **) __null, 10);
>}
>
>
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
>__attribute__ ((__leaf__)) atoll (__const char *__nptr) throw ()
>{
> return strtoll (__nptr, (char **) __null, 10);
>}
>
># 311 "/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
># 28 "/usr/include/sys/types.h" 3 4
>extern "C" {
>
># 1 "/usr/include/bits/types.h" 1 3 4
># 28 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/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;
># 131 "/usr/include/bits/types.h" 3 4
># 1 "/usr/include/bits/typesizes.h" 1 3 4
># 132 "/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 long int __swblk_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 __ssize_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;
># 31 "/usr/include/sys/types.h" 2 3 4
>
>
>
>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;
># 133 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/time.h" 1 3 4
># 58 "/usr/include/time.h" 3 4
>
>
>typedef __clock_t clock_t;
>
>
>
># 74 "/usr/include/time.h" 3 4
>
>
>typedef __time_t time_t;
>
>
>
># 92 "/usr/include/time.h" 3 4
>typedef __clockid_t clockid_t;
># 104 "/usr/include/time.h" 3 4
>typedef __timer_t timer_t;
># 134 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef __useconds_t useconds_t;
>
>
>
>typedef __suseconds_t suseconds_t;
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 148 "/usr/include/sys/types.h" 2 3 4
>
>
>
>typedef unsigned long int ulong;
>typedef unsigned short int ushort;
>typedef unsigned int uint;
># 195 "/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__)));
># 220 "/usr/include/sys/types.h" 3 4
># 1 "/usr/include/sys/select.h" 1 3 4
># 31 "/usr/include/sys/select.h" 3 4
># 1 "/usr/include/bits/select.h" 1 3 4
># 23 "/usr/include/bits/select.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 24 "/usr/include/bits/select.h" 2 3 4
># 32 "/usr/include/sys/select.h" 2 3 4
>
>
># 1 "/usr/include/bits/sigset.h" 1 3 4
># 24 "/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;
># 35 "/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;
> long int tv_nsec;
> };
># 45 "/usr/include/sys/select.h" 2 3 4
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 31 "/usr/include/bits/time.h" 3 4
>struct timeval
> {
> __time_t tv_sec;
> __suseconds_t tv_usec;
> };
># 47 "/usr/include/sys/select.h" 2 3 4
># 55 "/usr/include/sys/select.h" 3 4
>typedef long int __fd_mask;
># 65 "/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;
># 97 "/usr/include/sys/select.h" 3 4
>extern "C" {
># 107 "/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);
># 119 "/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);
># 132 "/usr/include/sys/select.h" 3 4
>}
># 221 "/usr/include/sys/types.h" 2 3 4
>
>
># 1 "/usr/include/sys/sysmacros.h" 1 3 4
># 30 "/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__));
>
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
>__attribute__ ((__leaf__)) gnu_dev_major (unsigned long long int __dev) throw ()
>{
> return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
>}
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned int
>__attribute__ ((__leaf__)) gnu_dev_minor (unsigned long long int __dev) throw ()
>{
> return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
>}
>
>__extension__ extern __inline __attribute__ ((__gnu_inline__)) __attribute__ ((__const__)) unsigned long long int
>__attribute__ ((__leaf__)) gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
>{
> return ((__minor & 0xff) | ((__major & 0xfff) << 8)
> | (((unsigned long long int) (__minor & ~0xff)) << 12)
> | (((unsigned long long int) (__major & ~0xfff)) << 32));
>}
>
>}
># 224 "/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;
># 263 "/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
># 23 "/usr/include/bits/pthreadtypes.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
># 50 "/usr/include/bits/pthreadtypes.h" 3 4
>typedef unsigned long int pthread_t;
>
>
>typedef union
>{
> char __size[56];
> long int __align;
>} pthread_attr_t;
>
>
>
>typedef struct __pthread_internal_list
>{
> struct __pthread_internal_list *__prev;
> struct __pthread_internal_list *__next;
>} __pthread_list_t;
># 76 "/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;
>
> int __spins;
> __pthread_list_t __list;
># 101 "/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;
> unsigned long int __pad1;
> unsigned long int __pad2;
>
>
> unsigned int __flags;
> } __data;
># 187 "/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;
># 272 "/usr/include/sys/types.h" 2 3 4
>
>
>}
># 321 "/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;
> 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
># 25 "/usr/include/alloca.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 26 "/usr/include/alloca.h" 2 3 4
>
>extern "C" {
>
>
>
>
>
>extern void *alloca (size_t __size) throw ();
>
>
>
>
>
>}
># 498 "/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 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))) ;
># 620 "/usr/include/stdlib.h" 3 4
>extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 630 "/usr/include/stdlib.h" 3 4
>extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
># 642 "/usr/include/stdlib.h" 3 4
>extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
># 652 "/usr/include/stdlib.h" 3 4
>extern int mkstemps64 (char *__template, int __suffixlen)
> __attribute__ ((__nonnull__ (1))) ;
># 663 "/usr/include/stdlib.h" 3 4
>extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
># 674 "/usr/include/stdlib.h" 3 4
>extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
># 684 "/usr/include/stdlib.h" 3 4
>extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
># 694 "/usr/include/stdlib.h" 3 4
>extern int mkostemps (char *__template, int __suffixlen, int __flags)
> __attribute__ ((__nonnull__ (1))) ;
># 706 "/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))) ;
># 734 "/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__)) ;
>
># 808 "/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))) ;
># 896 "/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)));
># 964 "/usr/include/stdlib.h" 3 4
>}
># 67 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 2 3
># 98 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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 labs(__i); }
>
> inline ldiv_t
> div(long __i, long __j) { return ldiv(__i, __j); }
>
>
>
>}
># 160 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> using ::lldiv_t;
>
>
>
>
>
> using ::_Exit;
>
>
> inline long long
> abs(long long __x) { return __x >= 0 ? __x : -__x; }
>
>
> 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;
># 195 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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::abs;
>
> 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;
>}
>
>
>
>namespace std
>{
>
>
> using std::lldiv_t;
>
>
> using std::llabs;
> using std::lldiv;
>
>
> using std::atoll;
> using std::strtoll;
> using std::strtoull;
>
> using std::strtof;
> using std::strtold;
>
>
> using std::abs;
>
> using std::div;
>
>}
># 62 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/algorithmfwd.h" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/algorithmfwd.h" 3
> 
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/algorithmfwd.h" 3
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/algorithmfwd.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 194 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/algorithmfwd.h" 3
> template<typename _IIter, typename _Predicate>
> bool
> all_of(_IIter, _IIter, _Predicate);
>
> template<typename _IIter, typename _Predicate>
> bool
> any_of(_IIter, _IIter, _Predicate);
>
>
> template<typename _FIter, typename _Tp>
> bool
> binary_search(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> bool
> binary_search(_FIter, _FIter, const _Tp&, _Compare);
>
> template<typename _IIter, typename _OIter>
> _OIter
> copy(_IIter, _IIter, _OIter);
>
> template<typename _BIter1, typename _BIter2>
> _BIter2
> copy_backward(_BIter1, _BIter1, _BIter2);
>
>
> template<typename _IIter, typename _OIter, typename _Predicate>
> _OIter
> copy_if(_IIter, _IIter, _OIter, _Predicate);
>
> template<typename _IIter, typename _Size, typename _OIter>
> _OIter
> copy_n(_IIter, _Size, _OIter);
>
>
>
>
>
> template<typename _FIter, typename _Tp>
> pair<_FIter, _FIter>
> equal_range(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> pair<_FIter, _FIter>
> equal_range(_FIter, _FIter, const _Tp&, _Compare);
>
> template<typename _FIter, typename _Tp>
> void
> fill(_FIter, _FIter, const _Tp&);
>
> template<typename _OIter, typename _Size, typename _Tp>
> _OIter
> fill_n(_OIter, _Size, const _Tp&);
>
>
>
> template<typename _FIter1, typename _FIter2>
> _FIter1
> find_end(_FIter1, _FIter1, _FIter2, _FIter2);
>
> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
> _FIter1
> find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
>
>
>
>
> template<typename _IIter, typename _Predicate>
> _IIter
> find_if_not(_IIter, _IIter, _Predicate);
>
>
>
>
>
>
> template<typename _IIter1, typename _IIter2>
> bool
> includes(_IIter1, _IIter1, _IIter2, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _Compare>
> bool
> includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
>
> template<typename _BIter>
> void
> inplace_merge(_BIter, _BIter, _BIter);
>
> template<typename _BIter, typename _Compare>
> void
> inplace_merge(_BIter, _BIter, _BIter, _Compare);
>
>
> template<typename _RAIter>
> bool
> is_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> bool
> is_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _RAIter>
> _RAIter
> is_heap_until(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> _RAIter
> is_heap_until(_RAIter, _RAIter, _Compare);
>
> template<typename _IIter, typename _Predicate>
> bool
> is_partitioned(_IIter, _IIter, _Predicate);
>
> template<typename _FIter1, typename _FIter2>
> bool
> is_permutation(_FIter1, _FIter1, _FIter2);
>
> template<typename _FIter1, typename _FIter2,
> typename _BinaryPredicate>
> bool
> is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
>
> template<typename _FIter>
> bool
> is_sorted(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> bool
> is_sorted(_FIter, _FIter, _Compare);
>
> template<typename _FIter>
> _FIter
> is_sorted_until(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> _FIter
> is_sorted_until(_FIter, _FIter, _Compare);
>
>
> template<typename _FIter1, typename _FIter2>
> void
> iter_swap(_FIter1, _FIter2);
>
> template<typename _FIter, typename _Tp>
> _FIter
> lower_bound(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> _FIter
> lower_bound(_FIter, _FIter, const _Tp&, _Compare);
>
> template<typename _RAIter>
> void
> make_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> make_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _Tp>
> const _Tp&
> max(const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> const _Tp&
> max(const _Tp&, const _Tp&, _Compare);
>
>
>
>
> template<typename _Tp>
> const _Tp&
> min(const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> const _Tp&
> min(const _Tp&, const _Tp&, _Compare);
>
>
>
>
> template<typename _Tp>
> pair<const _Tp&, const _Tp&>
> minmax(const _Tp&, const _Tp&);
>
> template<typename _Tp, typename _Compare>
> pair<const _Tp&, const _Tp&>
> minmax(const _Tp&, const _Tp&, _Compare);
>
> template<typename _FIter>
> pair<_FIter, _FIter>
> minmax_element(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> pair<_FIter, _FIter>
> minmax_element(_FIter, _FIter, _Compare);
>
> template<typename _Tp>
> _Tp
> min(initializer_list<_Tp>);
>
> template<typename _Tp, typename _Compare>
> _Tp
> min(initializer_list<_Tp>, _Compare);
>
> template<typename _Tp>
> _Tp
> max(initializer_list<_Tp>);
>
> template<typename _Tp, typename _Compare>
> _Tp
> max(initializer_list<_Tp>, _Compare);
>
> template<typename _Tp>
> pair<_Tp, _Tp>
> minmax(initializer_list<_Tp>);
>
> template<typename _Tp, typename _Compare>
> pair<_Tp, _Tp>
> minmax(initializer_list<_Tp>, _Compare);
>
>
>
>
> template<typename _BIter>
> bool
> next_permutation(_BIter, _BIter);
>
> template<typename _BIter, typename _Compare>
> bool
> next_permutation(_BIter, _BIter, _Compare);
>
>
> template<typename _IIter, typename _Predicate>
> bool
> none_of(_IIter, _IIter, _Predicate);
>
>
>
>
>
> template<typename _IIter, typename _RAIter>
> _RAIter
> partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
>
> template<typename _IIter, typename _RAIter, typename _Compare>
> _RAIter
> partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
>
>
>
>
> template<typename _IIter, typename _OIter1,
> typename _OIter2, typename _Predicate>
> pair<_OIter1, _OIter2>
> partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
>
> template<typename _FIter, typename _Predicate>
> _FIter
> partition_point(_FIter, _FIter, _Predicate);
>
>
> template<typename _RAIter>
> void
> pop_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> pop_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _BIter>
> bool
> prev_permutation(_BIter, _BIter);
>
> template<typename _BIter, typename _Compare>
> bool
> prev_permutation(_BIter, _BIter, _Compare);
>
> template<typename _RAIter>
> void
> push_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> push_heap(_RAIter, _RAIter, _Compare);
>
>
>
> template<typename _FIter, typename _Tp>
> _FIter
> remove(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Predicate>
> _FIter
> remove_if(_FIter, _FIter, _Predicate);
>
> template<typename _IIter, typename _OIter, typename _Tp>
> _OIter
> remove_copy(_IIter, _IIter, _OIter, const _Tp&);
>
> template<typename _IIter, typename _OIter, typename _Predicate>
> _OIter
> remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
>
>
>
> template<typename _IIter, typename _OIter, typename _Tp>
> _OIter
> replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
>
> template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
> _OIter
> replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
>
>
>
> template<typename _BIter>
> void
> reverse(_BIter, _BIter);
>
> template<typename _BIter, typename _OIter>
> _OIter
> reverse_copy(_BIter, _BIter, _OIter);
>
> template<typename _FIter>
> void
> rotate(_FIter, _FIter, _FIter);
>
> template<typename _FIter, typename _OIter>
> _OIter
> rotate_copy(_FIter, _FIter, _FIter, _OIter);
># 535 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/algorithmfwd.h" 3
> template<typename _RAIter, typename _UGenerator>
> void
> shuffle(_RAIter, _RAIter, _UGenerator&&);
>
>
> template<typename _RAIter>
> void
> sort_heap(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> sort_heap(_RAIter, _RAIter, _Compare);
>
> template<typename _BIter, typename _Predicate>
> _BIter
> stable_partition(_BIter, _BIter, _Predicate);
>
> template<typename _Tp>
> void
> swap(_Tp&, _Tp&)
>
> noexcept(__and_<is_nothrow_move_constructible<_Tp>,
> is_nothrow_move_assignable<_Tp>>::value)
>
> ;
>
> template<typename _Tp, size_t _Nm>
> void
> swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
>
> noexcept(noexcept(swap(*__a, *__b)))
>
> ;
>
> template<typename _FIter1, typename _FIter2>
> _FIter2
> swap_ranges(_FIter1, _FIter1, _FIter2);
>
>
>
> template<typename _FIter>
> _FIter
> unique(_FIter, _FIter);
>
> template<typename _FIter, typename _BinaryPredicate>
> _FIter
> unique(_FIter, _FIter, _BinaryPredicate);
>
>
>
> template<typename _FIter, typename _Tp>
> _FIter
> upper_bound(_FIter, _FIter, const _Tp&);
>
> template<typename _FIter, typename _Tp, typename _Compare>
> _FIter
> upper_bound(_FIter, _FIter, const _Tp&, _Compare);
>
>
>
>
>
> template<typename _FIter>
> _FIter
> adjacent_find(_FIter, _FIter);
>
> template<typename _FIter, typename _BinaryPredicate>
> _FIter
> adjacent_find(_FIter, _FIter, _BinaryPredicate);
>
> template<typename _IIter, typename _Tp>
> typename iterator_traits<_IIter>::difference_type
> count(_IIter, _IIter, const _Tp&);
>
> template<typename _IIter, typename _Predicate>
> typename iterator_traits<_IIter>::difference_type
> count_if(_IIter, _IIter, _Predicate);
>
> template<typename _IIter1, typename _IIter2>
> bool
> equal(_IIter1, _IIter1, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> bool
> equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
>
> template<typename _IIter, typename _Tp>
> _IIter
> find(_IIter, _IIter, const _Tp&);
>
> template<typename _FIter1, typename _FIter2>
> _FIter1
> find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
>
> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
> _FIter1
> find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
> template<typename _IIter, typename _Predicate>
> _IIter
> find_if(_IIter, _IIter, _Predicate);
>
> template<typename _IIter, typename _Funct>
> _Funct
> for_each(_IIter, _IIter, _Funct);
>
> template<typename _FIter, typename _Generator>
> void
> generate(_FIter, _FIter, _Generator);
>
> template<typename _OIter, typename _Size, typename _Generator>
> _OIter
> generate_n(_OIter, _Size, _Generator);
>
> template<typename _IIter1, typename _IIter2>
> bool
> lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _Compare>
> bool
> lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
>
> template<typename _FIter>
> _FIter
> max_element(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> _FIter
> max_element(_FIter, _FIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _FIter>
> _FIter
> min_element(_FIter, _FIter);
>
> template<typename _FIter, typename _Compare>
> _FIter
> min_element(_FIter, _FIter, _Compare);
>
> template<typename _IIter1, typename _IIter2>
> pair<_IIter1, _IIter2>
> mismatch(_IIter1, _IIter1, _IIter2);
>
> template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
> pair<_IIter1, _IIter2>
> mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
>
> template<typename _RAIter>
> void
> nth_element(_RAIter, _RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> nth_element(_RAIter, _RAIter, _RAIter, _Compare);
>
> template<typename _RAIter>
> void
> partial_sort(_RAIter, _RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
>
> template<typename _BIter, typename _Predicate>
> _BIter
> partition(_BIter, _BIter, _Predicate);
>
> template<typename _RAIter>
> void
> random_shuffle(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Generator>
> void
> random_shuffle(_RAIter, _RAIter,
>
> _Generator&&);
>
>
>
>
> template<typename _FIter, typename _Tp>
> void
> replace(_FIter, _FIter, const _Tp&, const _Tp&);
>
> template<typename _FIter, typename _Predicate, typename _Tp>
> void
> replace_if(_FIter, _FIter, _Predicate, const _Tp&);
>
> template<typename _FIter1, typename _FIter2>
> _FIter1
> search(_FIter1, _FIter1, _FIter2, _FIter2);
>
> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
> _FIter1
> search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
>
> template<typename _FIter, typename _Size, typename _Tp>
> _FIter
> search_n(_FIter, _FIter, _Size, const _Tp&);
>
> template<typename _FIter, typename _Size, typename _Tp,
> typename _BinaryPredicate>
> _FIter
> search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
> _OIter, _Compare);
>
> template<typename _IIter1, typename _IIter2, typename _OIter>
> _OIter
> set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _Compare>
> _OIter
> set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
>
> template<typename _RAIter>
> void
> sort(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> sort(_RAIter, _RAIter, _Compare);
>
> template<typename _RAIter>
> void
> stable_sort(_RAIter, _RAIter);
>
> template<typename _RAIter, typename _Compare>
> void
> stable_sort(_RAIter, _RAIter, _Compare);
>
> template<typename _IIter, typename _OIter, typename _UnaryOperation>
> _OIter
> transform(_IIter, _IIter, _OIter, _UnaryOperation);
>
> template<typename _IIter1, typename _IIter2, typename _OIter,
> typename _BinaryOperation>
> _OIter
> transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
>
> template<typename _IIter, typename _OIter>
> _OIter
> unique_copy(_IIter, _IIter, _OIter);
>
> template<typename _IIter, typename _OIter, typename _BinaryPredicate>
> _OIter
> unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
>
>
>}
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 1 3
># 62 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _RandomAccessIterator, typename _Distance>
> _Distance
> __is_heap_until(_RandomAccessIterator __first, _Distance __n)
> {
> _Distance __parent = 0;
> for (_Distance __child = 1; __child < __n; ++__child)
> {
> if (__first[__parent] < __first[__child])
> return __child;
> if ((__child & 1) == 0)
> ++__parent;
> }
> return __n;
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Compare>
> _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<typename _RandomAccessIterator, typename _Distance>
> inline bool
> __is_heap(_RandomAccessIterator __first, _Distance __n)
> { return std::__is_heap_until(__first, __n) == __n; }
>
> template<typename _RandomAccessIterator, typename _Compare,
> typename _Distance>
> inline bool
> __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
> { return std::__is_heap_until(__first, __n, __comp) == __n; }
>
> template<typename _RandomAccessIterator>
> inline bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> { return std::__is_heap(__first, std::distance(__first, __last)); }
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline bool
> __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
>
>
>
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
> void
> __push_heap(_RandomAccessIterator __first,
> _Distance __holeIndex, _Distance __topIndex, _Tp __value)
> {
> _Distance __parent = (__holeIndex - 1) / 2;
> while (__holeIndex > __topIndex && *(__first + __parent) < __value)
> {
> *(__first + __holeIndex) = std::move(*(__first + __parent));
> __holeIndex = __parent;
> __parent = (__holeIndex - 1) / 2;
> }
> *(__first + __holeIndex) = std::move(__value);
> }
># 155 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> 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 = std::move(*(__last - 1));
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), std::move(__value));
> }
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
> typename _Compare>
> 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) = std::move(*(__first + __parent));
> __holeIndex = __parent;
> __parent = (__holeIndex - 1) / 2;
> }
> *(__first + __holeIndex) = std::move(__value);
> }
># 205 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> 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 = std::move(*(__last - 1));
> std::__push_heap(__first, _DistanceType((__last - __first) - 1),
> _DistanceType(0), std::move(__value), __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
> void
> __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
> _Distance __len, _Tp __value)
> {
> const _Distance __topIndex = __holeIndex;
> _Distance __secondChild = __holeIndex;
> while (__secondChild < (__len - 1) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
> __secondChild--;
> *(__first + __holeIndex) = std::move(*(__first + __secondChild));
> __holeIndex = __secondChild;
> }
> if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)))
> ;
> __holeIndex = __secondChild - 1;
> }
> std::__push_heap(__first, __holeIndex, __topIndex,
> std::move(__value));
> }
>
> template<typename _RandomAccessIterator>
> inline void
> __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _RandomAccessIterator __result)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
> _ValueType __value = std::move(*__result);
> *__result = std::move(*__first);
> std::__adjust_heap(__first, _DistanceType(0),
> _DistanceType(__last - __first),
> std::move(__value));
> }
># 280 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline void
> pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
> ;
>
> --__last;
> std::__pop_heap(__first, __last, __last);
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Tp, typename _Compare>
> 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) = std::move(*(__first + __secondChild));
> __holeIndex = __secondChild;
> }
> if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
> {
> __secondChild = 2 * (__secondChild + 1);
> *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)))
> ;
> __holeIndex = __secondChild - 1;
> }
> std::__push_heap(__first, __holeIndex, __topIndex,
> std::move(__value), __comp);
> }
>
> template<typename _RandomAccessIterator, typename _Compare>
> 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 = std::move(*__result);
> *__result = std::move(*__first);
> std::__adjust_heap(__first, _DistanceType(0),
> _DistanceType(__last - __first),
> std::move(__value), __comp);
> }
># 355 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> pop_heap(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
>
> 
>
> ;
> ;
> ;
>
> --__last;
> std::__pop_heap(__first, __last, __last, __comp);
> }
># 379 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> void
> make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> 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 = std::move(*(__first + __parent));
> std::__adjust_heap(__first, __parent, __len, std::move(__value));
> if (__parent == 0)
> return;
> __parent--;
> }
> }
># 419 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> 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 = std::move(*(__first + __parent));
> std::__adjust_heap(__first, __parent, __len, std::move(__value),
> __comp);
> if (__parent == 0)
> return;
> __parent--;
> }
> }
># 458 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
> ;
>
> while (__last - __first > 1)
> {
> --__last;
> std::__pop_heap(__first, __last, __last);
> }
> }
># 487 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> void
> sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
> ;
>
> while (__last - __first > 1)
> {
> --__last;
> std::__pop_heap(__first, __last, __last, __comp);
> }
> }
># 516 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline _RandomAccessIterator
> is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> 
>
> ;
>
> return __first + std::__is_heap_until(__first, std::distance(__first,
> __last));
> }
># 542 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline _RandomAccessIterator
> is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
>
> 
>
> ;
>
> return __first + std::__is_heap_until(__first, std::distance(__first,
> __last),
> __comp);
> }
># 564 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator>
> inline bool
> is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
> { return std::is_heap_until(__first, __last) == __last; }
># 577 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_heap.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline bool
> is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> { return std::is_heap_until(__first, __last, __comp) == __last; }
>
>
>
>}
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_tempbuf.h" 1 3
># 62 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_tempbuf.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_construct.h" 1 3
># 61 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_construct.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/new" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/new" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/new" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/exception" 1 3
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/exception" 3
> 
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/exception" 3
>
>#pragma GCC visibility push(default)
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/atomic_lockfree_defines.h" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/atomic_lockfree_defines.h" 3
> 
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/atomic_lockfree_defines.h" 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/exception" 2 3
>
>extern "C++" {
>
>namespace std
>{
># 62 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/exception" 3
> class exception
> {
> public:
> exception() noexcept { }
> virtual ~exception() noexcept;
>
>
>
> virtual const char* what() const noexcept;
> };
>
>
>
> class bad_exception : public exception
> {
> public:
> bad_exception() noexcept { }
>
>
>
> virtual ~bad_exception() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>
>
> typedef void (*terminate_handler) ();
>
>
> typedef void (*unexpected_handler) ();
>
>
> terminate_handler set_terminate(terminate_handler) noexcept;
>
>
>
> void terminate() noexcept __attribute__ ((__noreturn__));
>
>
> unexpected_handler set_unexpected(unexpected_handler) noexcept;
>
>
>
> void unexpected() __attribute__ ((__noreturn__));
># 119 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/exception" 3
> bool uncaught_exception() noexcept __attribute__ ((__pure__));
>
>
>}
>
>namespace __gnu_cxx
>{
>
># 144 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/exception" 3
> void __verbose_terminate_handler();
>
>
>}
>
>}
>
>#pragma GCC visibility pop
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/exception_ptr.h" 1 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/exception_ptr.h" 3
>#pragma GCC visibility push(default)
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/exception_ptr.h" 3
>extern "C++" {
>
>namespace std
>{
>
>
>
>
> namespace __exception_ptr
> {
> class exception_ptr;
> }
>
> using __exception_ptr::exception_ptr;
>
>
>
>
>
> exception_ptr current_exception() noexcept;
>
>
> void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
>
> namespace __exception_ptr
> {
>
>
>
>
> class exception_ptr
> {
> void* _M_exception_object;
>
> explicit exception_ptr(void* __e) noexcept;
>
> void _M_addref() noexcept;
> void _M_release() noexcept;
>
> void *_M_get() const noexcept __attribute__ ((__pure__));
>
> friend exception_ptr std::current_exception() noexcept;
> friend void std::rethrow_exception(exception_ptr);
>
> public:
> exception_ptr() noexcept;
>
> exception_ptr(const exception_ptr&) noexcept;
>
>
> exception_ptr(nullptr_t) noexcept
> : _M_exception_object(0)
> { }
>
> exception_ptr(exception_ptr&& __o) noexcept
> : _M_exception_object(__o._M_exception_object)
> { __o._M_exception_object = 0; }
># 109 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/exception_ptr.h" 3
> exception_ptr&
> operator=(const exception_ptr&) noexcept;
>
>
> exception_ptr&
> operator=(exception_ptr&& __o) noexcept
> {
> exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
> return *this;
> }
>
>
> ~exception_ptr() noexcept;
>
> void
> swap(exception_ptr&) noexcept;
># 136 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/exception_ptr.h" 3
> explicit operator bool() const
> { return _M_exception_object; }
>
>
> friend bool
> operator==(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> const class type_info*
> __cxa_exception_type() const noexcept
> __attribute__ ((__pure__));
> };
>
> bool
> operator==(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> bool
> operator!=(const exception_ptr&, const exception_ptr&)
> noexcept __attribute__ ((__pure__));
>
> inline void
> swap(exception_ptr& __lhs, exception_ptr& __rhs)
> { __lhs.swap(__rhs); }
>
> }
>
>
>
> template<typename _Ex>
> exception_ptr
> copy_exception(_Ex __ex) noexcept
> {
> try
> {
>
> throw __ex;
>
> }
> catch(...)
> {
> return current_exception();
> }
> }
>
>
>
>
> template<typename _Ex>
> exception_ptr
> make_exception_ptr(_Ex __ex) noexcept
> { return std::copy_exception<_Ex>(__ex); }
>
>
>}
>
>}
>
>#pragma GCC visibility pop
># 155 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/exception" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/nested_exception.h" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/nested_exception.h" 3
>#pragma GCC visibility push(default)
># 45 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/nested_exception.h" 3
>extern "C++" {
>
>namespace std
>{
>
>
>
>
>
>
> class nested_exception
> {
> exception_ptr _M_ptr;
>
> public:
> nested_exception() noexcept : _M_ptr(current_exception()) { }
>
> nested_exception(const nested_exception&) = default;
>
> nested_exception& operator=(const nested_exception&) = default;
>
> virtual ~nested_exception() noexcept;
>
> void
> rethrow_nested() const __attribute__ ((__noreturn__))
> { rethrow_exception(_M_ptr); }
>
> exception_ptr
> nested_ptr() const
> { return _M_ptr; }
> };
>
> template<typename _Except>
> struct _Nested_exception : public _Except, public nested_exception
> {
> explicit _Nested_exception(_Except&& __ex)
> : _Except(static_cast<_Except&&>(__ex))
> { }
> };
>
> template<typename _Ex>
> struct __get_nested_helper
> {
> static const nested_exception*
> _S_get(const _Ex& __ex)
> { return dynamic_cast<const nested_exception*>(&__ex); }
> };
>
> template<typename _Ex>
> struct __get_nested_helper<_Ex*>
> {
> static const nested_exception*
> _S_get(const _Ex* __ex)
> { return dynamic_cast<const nested_exception*>(__ex); }
> };
>
> template<typename _Ex>
> inline const nested_exception*
> __get_nested_exception(const _Ex& __ex)
> { return __get_nested_helper<_Ex>::_S_get(__ex); }
>
> template<typename _Ex>
> void
> __throw_with_nested(_Ex&&, const nested_exception* = 0)
> __attribute__ ((__noreturn__));
>
> template<typename _Ex>
> void
> __throw_with_nested(_Ex&&, ...) __attribute__ ((__noreturn__));
>
>
>
>
> template<typename _Ex>
> inline void
> __throw_with_nested(_Ex&& __ex, const nested_exception*)
> { throw __ex; }
>
> template<typename _Ex>
> inline void
> __throw_with_nested(_Ex&& __ex, ...)
> { throw _Nested_exception<_Ex>(static_cast<_Ex&&>(__ex)); }
>
> template<typename _Ex>
> void
> throw_with_nested(_Ex __ex) __attribute__ ((__noreturn__));
>
>
>
> template<typename _Ex>
> inline void
> throw_with_nested(_Ex __ex)
> {
> if (__get_nested_exception(__ex))
> throw __ex;
> __throw_with_nested(static_cast<_Ex&&>(__ex), &__ex);
> }
>
>
> template<typename _Ex>
> inline void
> rethrow_if_nested(const _Ex& __ex)
> {
> if (const nested_exception* __nested = __get_nested_exception(__ex))
> __nested->rethrow_nested();
> }
>
>
> inline void
> rethrow_if_nested(const nested_exception& __ex)
> { __ex.rethrow_nested(); }
>
>
>}
>
>}
>
>
>
>#pragma GCC visibility pop
># 156 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/exception" 2 3
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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();
> };
>
> struct nothrow_t { };
>
> extern const nothrow_t nothrow;
>
>
>
> typedef void (*new_handler)();
>
>
>
> new_handler set_new_handler(new_handler) throw();
>}
># 93 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/new" 3
>void* operator new(std::size_t)
> __attribute__((__externally_visible__));
>void* operator new[](std::size_t)
> __attribute__((__externally_visible__));
>void operator delete(void*) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*) noexcept
> __attribute__((__externally_visible__));
>void* operator new(std::size_t, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void* operator new[](std::size_t, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void operator delete(void*, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>void operator delete[](void*, const std::nothrow_t&) noexcept
> __attribute__((__externally_visible__));
>
>
>inline void* operator new(std::size_t, void* __p) noexcept
>{ return __p; }
>inline void* operator new[](std::size_t, void* __p) noexcept
>{ return __p; }
>
>
>inline void operator delete (void*, void*) noexcept { }
>inline void operator delete[](void*, void*) noexcept { }
>
>}
>
>#pragma GCC visibility pop
># 62 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_construct.h" 2 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/alloc_traits.h" 1 3
># 32 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/alloc_traits.h" 3
> 
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/alloc_traits.h" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 1 3
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ptr_traits.h" 1 3
># 37 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ptr_traits.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>template<typename _Tp> class __has_element_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::element_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_element_type : integral_constant<bool, __has_element_type_helper <typename remove_cv<_Tp>::type>::value> { };
>template<typename _Tp> class __has_difference_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::difference_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_difference_type : integral_constant<bool, __has_difference_type_helper <typename remove_cv<_Tp>::type>::value> { };
>
> template<typename _Tp, bool = __has_element_type<_Tp>::value>
> struct __ptrtr_elt_type;
>
> template<typename _Tp>
> struct __ptrtr_elt_type<_Tp, true>
> {
> typedef typename _Tp::element_type __type;
> };
>
> template<template<typename, typename...> class _SomePtr, typename _Tp,
> typename... _Args>
> struct __ptrtr_elt_type<_SomePtr<_Tp, _Args...>, false>
> {
> typedef _Tp __type;
> };
>
> template<typename _Tp, bool = __has_difference_type<_Tp>::value>
> struct __ptrtr_diff_type
> {
> typedef typename _Tp::difference_type __type;
> };
>
> template<typename _Tp>
> struct __ptrtr_diff_type<_Tp, false>
> {
> typedef ptrdiff_t __type;
> };
>
> template<typename _Ptr, typename _Up>
> class __ptrtr_rebind_helper
> {
> template<typename _Ptr2, typename _Up2>
> static constexpr bool
> _S_chk(typename _Ptr2::template rebind<_Up2>*)
> { return true; }
>
> template<typename, typename>
> static constexpr bool
> _S_chk(...)
> { return false; }
>
> public:
> static const bool __value = _S_chk<_Ptr, _Up>(nullptr);
> };
>
> template<typename _Tp, typename _Up,
> bool = __ptrtr_rebind_helper<_Tp, _Up>::__value>
> struct __ptrtr_rebind;
>
> template<typename _Tp, typename _Up>
> struct __ptrtr_rebind<_Tp, _Up, true>
> {
> typedef typename _Tp::template rebind<_Up> __type;
> };
>
> template<template<typename, typename...> class _SomePtr, typename _Up,
> typename _Tp, typename... _Args>
> struct __ptrtr_rebind<_SomePtr<_Tp, _Args...>, _Up, false>
> {
> typedef _SomePtr<_Up, _Args...> __type;
> };
>
> template<typename _Tp, typename = typename remove_cv<_Tp>::type>
> struct __ptrtr_not_void
> {
> typedef _Tp __type;
> };
>
> template<typename _Tp>
> struct __ptrtr_not_void<_Tp, void>
> {
> struct __type { };
> };
>
> template<typename _Ptr>
> class __ptrtr_pointer_to
> {
> typedef typename __ptrtr_elt_type<_Ptr>::__type __orig_type;
> typedef typename __ptrtr_not_void<__orig_type>::__type __element_type;
>
> public:
> static _Ptr pointer_to(__element_type& __e)
> { return _Ptr::pointer_to(__e); }
> };
>
>
>
>
>
> template<typename _Ptr>
> struct pointer_traits : __ptrtr_pointer_to<_Ptr>
> {
>
> typedef _Ptr pointer;
>
> typedef typename __ptrtr_elt_type<_Ptr>::__type element_type;
>
> typedef typename __ptrtr_diff_type<_Ptr>::__type difference_type;
>
> template<typename _Up>
> using rebind = typename __ptrtr_rebind<_Ptr, _Up>::__type;
> };
>
>
>
>
>
> template<typename _Tp>
> struct pointer_traits<_Tp*>
> {
>
> typedef _Tp* pointer;
>
> typedef _Tp element_type;
>
> typedef ptrdiff_t difference_type;
>
> template<typename _Up>
> using rebind = _Up*;
>
>
>
>
>
>
> static pointer
> pointer_to(typename __ptrtr_not_void<element_type>::__type& __r) noexcept
> { return std::addressof(__r); }
> };
>
>
>}
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Alloc, typename _Tp>
> class __alloctr_rebind_helper
> {
> template<typename _Alloc2, typename _Tp2>
> static constexpr bool
> _S_chk(typename _Alloc2::template rebind<_Tp2>::other*)
> { return true; }
>
> template<typename, typename>
> static constexpr bool
> _S_chk(...)
> { return false; }
>
> public:
> static const bool __value = _S_chk<_Alloc, _Tp>(nullptr);
> };
>
> template<typename _Alloc, typename _Tp,
> bool = __alloctr_rebind_helper<_Alloc, _Tp>::__value>
> struct __alloctr_rebind;
>
> template<typename _Alloc, typename _Tp>
> struct __alloctr_rebind<_Alloc, _Tp, true>
> {
> typedef typename _Alloc::template rebind<_Tp>::other __type;
> };
>
> template<template<typename, typename...> class _Alloc, typename _Tp,
> typename _Up, typename... _Args>
> struct __alloctr_rebind<_Alloc<_Up, _Args...>, _Tp, false>
> {
> typedef _Alloc<_Tp, _Args...> __type;
> };
>
>
>
>
>
> template<typename _Alloc>
> struct allocator_traits
> {
>
> typedef _Alloc allocator_type;
>
> typedef typename _Alloc::value_type value_type;
># 96 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
>private: template<typename _Tp> static typename _Tp::pointer _S_pointer_helper(_Tp*); static value_type* _S_pointer_helper(...); typedef decltype(_S_pointer_helper((_Alloc*)0)) __pointer; public:
>
>
>
>
>
>
> typedef __pointer pointer;
>
>private: template<typename _Tp> static typename _Tp::const_pointer
> _S_const_pointer_helper
># 105 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (_Tp*); static typename pointer_traits<pointer>::template rebind<const value_type>
> _S_const_pointer_helper
># 105 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (...); typedef decltype(
> _S_const_pointer_helper
># 105 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ((_Alloc*)0))
> __const_pointer
># 105 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ; public:
># 114 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> typedef __const_pointer const_pointer;
>
>private: template<typename _Tp> static typename _Tp::void_pointer
> _S_void_pointer_helper
># 116 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (_Tp*); static typename pointer_traits<pointer>::template rebind<void>
> _S_void_pointer_helper
># 116 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (...); typedef decltype(
> _S_void_pointer_helper
># 116 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ((_Alloc*)0))
> __void_pointer
># 116 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ; public:
># 125 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> typedef __void_pointer void_pointer;
>
>private: template<typename _Tp> static typename _Tp::const_void_pointer
> _S_const_void_pointer_helper
># 127 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (_Tp*); static typename pointer_traits<pointer>::template rebind<const void>
> _S_const_void_pointer_helper
># 127 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (...); typedef decltype(
> _S_const_void_pointer_helper
># 127 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ((_Alloc*)0))
> __const_void_pointer
># 127 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ; public:
># 136 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> typedef __const_void_pointer const_void_pointer;
>
>private: template<typename _Tp> static typename _Tp::difference_type
> _S_difference_type_helper
># 138 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (_Tp*); static typename pointer_traits<pointer>::difference_type
> _S_difference_type_helper
># 138 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (...); typedef decltype(
> _S_difference_type_helper
># 138 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ((_Alloc*)0))
> __difference_type
># 138 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ; public:
># 147 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> typedef __difference_type difference_type;
>
>private: template<typename _Tp> static typename _Tp::size_type
> _S_size_type_helper
># 149 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (_Tp*); static typename make_unsigned<difference_type>::type
> _S_size_type_helper
># 149 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (...); typedef decltype(
> _S_size_type_helper
># 149 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ((_Alloc*)0))
> __size_type
># 149 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ; public:
># 158 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> typedef __size_type size_type;
>
>private: template<typename _Tp> static typename _Tp::propagate_on_container_copy_assignment
> _S_propagate_on_container_copy_assignment_helper
># 160 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (_Tp*); static false_type
> _S_propagate_on_container_copy_assignment_helper
># 160 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (...); typedef decltype(
> _S_propagate_on_container_copy_assignment_helper
># 160 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ((_Alloc*)0))
> __propagate_on_container_copy_assignment
># 160 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ; public:
># 169 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> typedef __propagate_on_container_copy_assignment
> propagate_on_container_copy_assignment;
>
>private: template<typename _Tp> static typename _Tp::propagate_on_container_move_assignment
> _S_propagate_on_container_move_assignment_helper
># 172 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (_Tp*); static false_type
> _S_propagate_on_container_move_assignment_helper
># 172 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (...); typedef decltype(
> _S_propagate_on_container_move_assignment_helper
># 172 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ((_Alloc*)0))
> __propagate_on_container_move_assignment
># 172 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ; public:
># 181 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> typedef __propagate_on_container_move_assignment
> propagate_on_container_move_assignment;
>
>private: template<typename _Tp> static typename _Tp::propagate_on_container_swap
> _S_propagate_on_container_swap_helper
># 184 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (_Tp*); static false_type
> _S_propagate_on_container_swap_helper
># 184 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> (...); typedef decltype(
> _S_propagate_on_container_swap_helper
># 184 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ((_Alloc*)0))
> __propagate_on_container_swap
># 184 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> ; public:
># 193 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> typedef __propagate_on_container_swap propagate_on_container_swap;
>
>
>
> template<typename _Tp>
> using rebind_alloc = typename __alloctr_rebind<_Alloc, _Tp>::__type;
> template<typename _Tp>
> using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
>
> private:
> template<typename _Alloc2>
> struct __allocate_helper
> {
> template<typename _Alloc3,
> typename = decltype(std::declval<_Alloc3*>()->allocate(
> std::declval<size_type>(),
> std::declval<const_void_pointer>()))>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc>(0)) type;
> static const bool value = type::value;
> };
>
> template<typename _Alloc2>
> static typename
> enable_if<__allocate_helper<_Alloc2>::value, pointer>::type
> _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint)
> { return __a.allocate(__n, __hint); }
>
> template<typename _Alloc2>
> static typename
> enable_if<!__allocate_helper<_Alloc2>::value, pointer>::type
> _S_allocate(_Alloc2& __a, size_type __n, ...)
> { return __a.allocate(__n); }
>
> template<typename _Tp, typename... _Args>
> struct __construct_helper
> {
> template<typename _Alloc2,
> typename = decltype(std::declval<_Alloc2*>()->construct(
> std::declval<_Tp*>(), std::declval<_Args>()...))>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc>(0)) type;
> static const bool value = type::value;
> };
>
> template<typename _Tp, typename... _Args>
> static typename
> enable_if<__construct_helper<_Tp, _Args...>::value, void>::type
> _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
> { __a.construct(__p, std::forward<_Args>(__args)...); }
>
> template<typename _Tp, typename... _Args>
> static typename
> enable_if<!__construct_helper<_Tp, _Args...>::value, void>::type
> _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
> { ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); }
>
> template<typename _Tp>
> struct __destroy_helper
> {
> template<typename _Alloc2,
> typename = decltype(std::declval<_Alloc2*>()->destroy(
> std::declval<_Tp*>()))>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc>(0)) type;
> static const bool value = type::value;
> };
>
> template<typename _Tp>
> static typename enable_if<__destroy_helper<_Tp>::value, void>::type
> _S_destroy(_Alloc& __a, _Tp* __p)
> { __a.destroy(__p); }
>
> template<typename _Tp>
> static typename enable_if<!__destroy_helper<_Tp>::value, void>::type
> _S_destroy(_Alloc&, _Tp* __p)
> { __p->~_Tp(); }
>
> template<typename _Alloc2>
> struct __maxsize_helper
> {
> template<typename _Alloc3,
> typename = decltype(std::declval<_Alloc3*>()->max_size())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc2>(0)) type;
> static const bool value = type::value;
> };
>
> template<typename _Alloc2>
> static typename
> enable_if<__maxsize_helper<_Alloc2>::value, size_type>::type
> _S_max_size(_Alloc2& __a)
> { return __a.max_size(); }
>
> template<typename _Alloc2>
> static typename
> enable_if<!__maxsize_helper<_Alloc2>::value, size_type>::type
> _S_max_size(_Alloc2&)
> { return __gnu_cxx::__numeric_traits<size_type>::__max; }
>
> template<typename _Alloc2>
> struct __select_helper
> {
> template<typename _Alloc3, typename
> = decltype(std::declval<_Alloc3*>()
> ->select_on_container_copy_construction())>
> static true_type __test(int);
>
> template<typename>
> static false_type __test(...);
>
> typedef decltype(__test<_Alloc2>(0)) type;
> static const bool value = type::value;
> };
> template<typename _Alloc2>
> static typename
> enable_if<__select_helper<_Alloc2>::value, _Alloc2>::type
> _S_select(_Alloc2& __a)
> { return __a.select_on_container_copy_construction(); }
>
> template<typename _Alloc2>
> static typename
> enable_if<!__select_helper<_Alloc2>::value, _Alloc2>::type
> _S_select(_Alloc2& __a)
> { return __a; }
>
> public:
># 344 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> static pointer
> allocate(_Alloc& __a, size_type __n)
> { return __a.allocate(__n); }
># 359 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> static pointer
> allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
> { return _S_allocate(__a, __n, __hint); }
># 371 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> static void deallocate(_Alloc& __a, pointer __p, size_type __n)
> { __a.deallocate(__p, __n); }
># 385 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> template<typename _Tp, typename... _Args>
> static void construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
> { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
># 397 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> template <class _Tp>
> static void destroy(_Alloc& __a, _Tp* __p)
> { _S_destroy(__a, __p); }
># 409 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> static size_type max_size(const _Alloc& __a)
> { return _S_max_size(__a); }
># 420 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/alloc_traits.h" 3
> static _Alloc
> select_on_container_copy_construction(const _Alloc& __rhs)
> { return _S_select(__rhs); }
> };
>
> template<typename _Alloc>
> inline void
> __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
> { __one = __two; }
>
> template<typename _Alloc>
> inline void
> __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
> { }
>
> template<typename _Alloc>
> inline void __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
> {
> typedef allocator_traits<_Alloc> __traits;
> typedef typename __traits::propagate_on_container_copy_assignment __pocca;
> __do_alloc_on_copy(__one, __two, __pocca());
> }
>
> template<typename _Alloc>
> inline _Alloc __alloc_on_copy(const _Alloc& __a)
> {
> typedef allocator_traits<_Alloc> __traits;
> return __traits::select_on_container_copy_construction(__a);
> }
>
> template<typename _Alloc>
> inline void __do_alloc_on_move(_Alloc& __one, _Alloc& __two, true_type)
> { __one = std::move(__two); }
>
> template<typename _Alloc>
> inline void __do_alloc_on_move(_Alloc&, _Alloc&, false_type)
> { }
>
> template<typename _Alloc>
> inline void __alloc_on_move(_Alloc& __one, _Alloc& __two)
> {
> typedef allocator_traits<_Alloc> __traits;
> typedef typename __traits::propagate_on_container_move_assignment __pocma;
> __do_alloc_on_move(__one, __two, __pocma());
> }
>
> template<typename _Alloc>
> inline void __do_alloc_on_swap(_Alloc& __one, _Alloc& __two, true_type)
> {
> using std::swap;
> swap(__one, __two);
> }
>
> template<typename _Alloc>
> inline void __do_alloc_on_swap(_Alloc&, _Alloc&, false_type)
> { }
>
> template<typename _Alloc>
> inline void __alloc_on_swap(_Alloc& __one, _Alloc& __two)
> {
> typedef allocator_traits<_Alloc> __traits;
> typedef typename __traits::propagate_on_container_swap __pocs;
> __do_alloc_on_swap(__one, __two, __pocs());
> }
>
>
>}
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/alloc_traits.h" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
> template<typename> struct allocator;
>
>}
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>template<typename _Alloc>
> struct __allocator_always_compares_equal
> { static const bool value = false; };
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<std::allocator<_Tp>>
> { static const bool value = true; };
>
> template<typename, typename> struct array_allocator;
>
> template<typename _Tp, typename _Array>
> struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>>
> { static const bool value = true; };
>
> template<typename> struct mt_allocator;
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<mt_allocator<_Tp>>
> { static const bool value = true; };
>
> template<typename> struct new_allocator;
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<new_allocator<_Tp>>
> { static const bool value = true; };
>
> template<typename> struct pool_allocator;
>
> template<typename _Tp>
> struct __allocator_always_compares_equal<pool_allocator<_Tp>>
> { static const bool value = true; };
>
>
>
>
>
>
>template<typename _Alloc>
> struct __alloc_traits
>
> : std::allocator_traits<_Alloc>
>
> {
> typedef _Alloc allocator_type;
>
> typedef std::allocator_traits<_Alloc> _Base_type;
> typedef typename _Base_type::value_type value_type;
> typedef typename _Base_type::pointer pointer;
> typedef typename _Base_type::const_pointer const_pointer;
> typedef typename _Base_type::size_type size_type;
>
> typedef value_type& reference;
> typedef const value_type& const_reference;
> using _Base_type::allocate;
> using _Base_type::deallocate;
> using _Base_type::construct;
> using _Base_type::destroy;
> using _Base_type::max_size;
>
> private:
> template<typename _Ptr>
> struct __is_custom_pointer
> : std::integral_constant<bool, std::is_same<pointer, _Ptr>::value
> && !std::is_pointer<_Ptr>::value>
> { };
>
> public:
>
> template<typename _Ptr, typename... _Args>
> static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
> construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
> {
> _Base_type::construct(__a, std::addressof(*__p),
> std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Ptr>
> static typename std::enable_if<__is_custom_pointer<_Ptr>::value>::type
> destroy(_Alloc& __a, _Ptr __p)
> { _Base_type::destroy(__a, std::addressof(*__p)); }
>
> static _Alloc _S_select_on_copy(const _Alloc& __a)
> { return _Base_type::select_on_container_copy_construction(__a); }
>
> static void _S_on_swap(_Alloc& __a, _Alloc& __b)
> { std::__alloc_on_swap(__a, __b); }
>
> static constexpr bool _S_propagate_on_copy_assign()
> { return _Base_type::propagate_on_container_copy_assignment::value; }
>
> static constexpr bool _S_propagate_on_move_assign()
> { return _Base_type::propagate_on_container_move_assignment::value; }
>
> static constexpr bool _S_propagate_on_swap()
> { return _Base_type::propagate_on_container_swap::value; }
>
> static constexpr bool _S_always_equal()
> { return __allocator_always_compares_equal<_Alloc>::value; }
>
> static constexpr bool _S_nothrow_move()
> { return _S_propagate_on_move_assign() || _S_always_equal(); }
>
> static constexpr bool _S_nothrow_swap()
> {
> using std::swap;
> return !_S_propagate_on_swap()
> || noexcept(swap(std::declval<_Alloc&>(), std::declval<_Alloc&>()));
> }
>
> template<typename _Tp>
> struct rebind
> { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
># 204 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/alloc_traits.h" 3
> };
>
>
>}
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_construct.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<typename _T1, typename... _Args>
> inline void
> _Construct(_T1* __p, _Args&&... __args)
> { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
># 92 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_construct.h" 3
> template<typename _Tp>
> inline void
> _Destroy(_Tp* __pointer)
> { __pointer->~_Tp(); }
>
> template<bool>
> struct _Destroy_aux
> {
> template<typename _ForwardIterator>
> static void
> __destroy(_ForwardIterator __first, _ForwardIterator __last)
> {
> for (; __first != __last; ++__first)
> std::_Destroy(std::__addressof(*__first));
> }
> };
>
> template<>
> struct _Destroy_aux<true>
> {
> template<typename _ForwardIterator>
> static void
> __destroy(_ForwardIterator, _ForwardIterator) { }
> };
>
>
>
>
>
>
> template<typename _ForwardIterator>
> 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 <typename _Tp> class allocator;
>
> template<typename _ForwardIterator, typename _Allocator>
> 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<typename _ForwardIterator, typename _Tp>
> inline void
> _Destroy(_ForwardIterator __first, _ForwardIterator __last,
> allocator<_Tp>&)
> {
> _Destroy(__first, __last);
> }
>
>
>}
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_tempbuf.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 85 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_tempbuf.h" 3
> template<typename _Tp>
> pair<_Tp*, ptrdiff_t>
> get_temporary_buffer(ptrdiff_t __len) noexcept
> {
> const ptrdiff_t __max =
> __gnu_cxx::__numeric_traits<ptrdiff_t>::__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);
> }
># 112 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_tempbuf.h" 3
> template<typename _Tp>
> inline void
> return_temporary_buffer(_Tp* __p)
> { ::operator delete(__p, std::nothrow); }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Tp>
> 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<bool>
> struct __uninitialized_construct_buf_dispatch
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> __ucr(_ForwardIterator __first, _ForwardIterator __last,
> _Tp& __value)
> {
> if(__first == __last)
> return;
>
> _ForwardIterator __cur = __first;
> try
> {
> std::_Construct(std::__addressof(*__first),
> std::move(__value));
> _ForwardIterator __prev = __cur;
> ++__cur;
> for(; __cur != __last; ++__cur, ++__prev)
> std::_Construct(std::__addressof(*__cur),
> std::move(*__prev));
> __value = std::move(*__prev);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_construct_buf_dispatch<true>
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> __ucr(_ForwardIterator, _ForwardIterator, _Tp&) { }
> };
># 231 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_tempbuf.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline void
> __uninitialized_construct_buf(_ForwardIterator __first,
> _ForwardIterator __last,
> _Tp& __value)
> {
> typedef typename std::iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_construct_buf_dispatch<
> __has_trivial_constructor(_ValueType)>::
> __ucr(__first, __last, __value);
> }
>
> template<typename _ForwardIterator, typename _Tp>
> _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<pointer, size_type> __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;
> }
> }
>
>
>}
># 65 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 2 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 1 3
># 32 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 3
> 
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 3
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cmath" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cmath" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cmath" 3
>
>
>
>
># 1 "/usr/include/math.h" 1 3 4
># 30 "/usr/include/math.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/include/bits/huge_val.h" 1 3 4
># 35 "/usr/include/math.h" 2 3 4
>
># 1 "/usr/include/bits/huge_valf.h" 1 3 4
># 37 "/usr/include/math.h" 2 3 4
># 1 "/usr/include/bits/huge_vall.h" 1 3 4
># 38 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/inf.h" 1 3 4
># 41 "/usr/include/math.h" 2 3 4
>
>
># 1 "/usr/include/bits/nan.h" 1 3 4
># 44 "/usr/include/math.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/mathdef.h" 1 3 4
># 26 "/usr/include/bits/mathdef.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 27 "/usr/include/bits/mathdef.h" 2 3 4
>
>
>
>
>typedef float float_t;
>typedef double double_t;
># 48 "/usr/include/math.h" 2 3 4
># 71 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
>
>extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
>
>extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
>
>extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
>
>
>extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
>
>extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
>
>extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
>
>
>
>
>extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
>
>extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
>
>extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
>
>
>
>
>extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
> ;
>
>
>
>
>
>extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
>
>extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
>
>extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
>
>
>
>
>
>
>
>extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
>
>
>extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
>
>
>extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
>
>
>extern double log (double __x) throw (); extern double __log (double __x) throw ();
>
>
>extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
>
>
>extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ()
> __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
>
>extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
>
>
>
>
>
>extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
>
>
>extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
>
>
>extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
>
>
>
>
>
>
>extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
>
>
>extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
>
>
>extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
>
>
>
>
>
>extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
>
>
>
>
>
>
>extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
>
>
>
>
>
>
>
>
>extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
>
>
>extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
>
>
>extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
>
>
>
>
>extern int __isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finite (double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinf (double __value) throw () __attribute__ ((__const__));
>
>
>extern int finite (double __value) throw () __attribute__ ((__const__));
>
>
>extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
>
>
>
>extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
>
>
>
>
>
>extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnan (double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnan (double __value) throw () __attribute__ ((__const__));
>
>
>extern double j0 (double) throw (); extern double __j0 (double) throw ();
>extern double j1 (double) throw (); extern double __j1 (double) throw ();
>extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
>extern double y0 (double) throw (); extern double __y0 (double) throw ();
>extern double y1 (double) throw (); extern double __y1 (double) throw ();
>extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
>
>
>
>
>
>
>extern double erf (double) throw (); extern double __erf (double) throw ();
>extern double erfc (double) throw (); extern double __erfc (double) throw ();
>extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
>
>
>
>
>
>
>extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
>
>
>
>
>
>extern double gamma (double) throw (); extern double __gamma (double) throw ();
>
>
>
>
>
>
>extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
>
>
>extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
>
>extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
>
>
>
>extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
>
>
>
>extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
>
>
>
>
>extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
>
>
>
>extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
>
>
>
>extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
>
>
>
>extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
>extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
>
>
>
>extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
>extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
>
>
>
>extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
>
>
>extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();
>
>
>extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw ();
>
>
>
>extern int __fpclassify (double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbit (double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
>
>
>
>
>
>
>
>
>extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
># 72 "/usr/include/math.h" 2 3 4
># 94 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
>
>extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
>
>extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
>
>extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
>
>
>extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
>
>extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
>
>extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
>
>
>
>
>extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
>
>extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
>
>extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
>
>
>
>
>extern void
> sincosf
># 82 "/usr/include/bits/mathcalls.h" 3 4
> (float __x, float *__sinx, float *__cosx) throw (); extern void
> __sincosf
># 82 "/usr/include/bits/mathcalls.h" 3 4
> (float __x, float *__sinx, float *__cosx) throw ()
> ;
>
>
>
>
>
>extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
>
>extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
>
>extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
>
>
>
>
>
>
>
>extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
>
>
>extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
>
>
>extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
>
>
>extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
>
>
>extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
>
>
>extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ()
> __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
>
>extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
>
>
>
>
>
>extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
>
>
>extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
>
>
>extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
>
>
>
>
>
>
>extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
>
>
>extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
>
>
>extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
>
>
>
>
>
>extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
>
>
>
>
>
>
>extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
>
>
>
>
>
>
>
>
>extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
>
>
>extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
>
>
>
>
>extern int __isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitef (float __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinff (float __value) throw () __attribute__ ((__const__));
>
>
>extern int finitef (float __value) throw () __attribute__ ((__const__));
>
>
>extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
>
>
>
>extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
>
>
>
>
>
>extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanf (float __value) throw () __attribute__ ((__const__));
>
>
>extern float j0f (float) throw (); extern float __j0f (float) throw ();
>extern float j1f (float) throw (); extern float __j1f (float) throw ();
>extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
>extern float y0f (float) throw (); extern float __y0f (float) throw ();
>extern float y1f (float) throw (); extern float __y1f (float) throw ();
>extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
>
>
>
>
>
>
>extern float erff (float) throw (); extern float __erff (float) throw ();
>extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
>extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
>
>
>
>
>
>
>extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
>
>
>
>
>
>extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
>
>
>
>
>
>
>extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
>
>
>extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
>
>extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
>
>
>
>extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
>
>
>
>extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
>
>
>
>
>extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
>
>
>
>extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
>
>
>
>extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
>
>
>
>extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
>extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
>
>
>
>extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
>extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
>
>
>
>extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
>
>
>extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();
>
>
>extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw ();
>
>
>
>extern int __fpclassifyf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitf (float __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
>
>
>
>
>
>
>
>
>extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
># 95 "/usr/include/math.h" 2 3 4
># 143 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathcalls.h" 1 3 4
># 53 "/usr/include/bits/mathcalls.h" 3 4
>
>
>extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
>
>extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
>
>extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
>
>extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
>
>
>extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
>
>extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
>
>extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
>
>
>
>
>extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
>
>extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
>
>extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
>
>
>
>
>extern void
> sincosl
># 82 "/usr/include/bits/mathcalls.h" 3 4
> (long double __x, long double *__sinx, long double *__cosx) throw (); extern void
> __sincosl
># 82 "/usr/include/bits/mathcalls.h" 3 4
> (long double __x, long double *__sinx, long double *__cosx) throw ()
> ;
>
>
>
>
>
>extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
>
>extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
>
>extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
>
>
>
>
>
>
>
>extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
>
>
>extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
>
>
>extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
>
>
>extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
>
>
>extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
>
>
>extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ()
> __attribute__ ((__nonnull__ (2)));
>
>
>
>
>extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
>
>extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
>
>
>
>
>
>extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
>
>
>extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
>
>
>extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
>
>
>
>
>
>
>extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
>
>
>extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
>
>
>extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
>
>
>
>
>
>extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
>
>
>
>
>
>
>extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
>
>
>
>
>
>
>
>
>extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
>
>
>extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
>
>
>
>
>extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int __finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int isinfl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern int finitel (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
>
>
>
>extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
>
>
>
>
>
>extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>
>
>
>extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));
>
>
>
>
>
>extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>
>extern int isnanl (long double __value) throw () __attribute__ ((__const__));
>
>
>extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
>extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
>extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
>extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
>extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
>extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
>
>
>
>
>
>
>extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
>extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
>extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
>
>
>
>
>
>
>extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
>
>
>
>
>
>extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
>
>
>
>
>
>
>extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
>
>
>
>
>
>
>
>extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
>
>
>extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
>
>
>
>extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
>
>
>
>extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
>
>
>
>extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
>
>
>
>
>extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
>
>
>
>extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
>
>
>
>extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
>
>
>
>
>extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
>
>
>
>
>
>
>extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
>extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
>
>
>
>extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
>extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
>
>
>
>extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
>
>
>extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();
>
>
>extern long double fminl (long double __x, long double __y) throw (); extern long double __fminl (long double __x, long double __y) throw ();
>
>
>
>extern int __fpclassifyl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>extern int __signbitl (long double __value) throw ()
> __attribute__ ((__const__));
>
>
>
>extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
>
>
>
>
>
>
>
>
>extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
># 144 "/usr/include/math.h" 2 3 4
># 159 "/usr/include/math.h" 3 4
>extern int signgam;
># 200 "/usr/include/math.h" 3 4
>enum
> {
> FP_NAN,
>
> FP_INFINITE,
>
> FP_ZERO,
>
> FP_SUBNORMAL,
>
> FP_NORMAL
>
> };
># 293 "/usr/include/math.h" 3 4
>typedef enum
>{
> _IEEE_ = -1,
> _SVID_,
> _XOPEN_,
> _POSIX_,
> _ISOC_
>} _LIB_VERSION_TYPE;
>
>
>
>
>extern _LIB_VERSION_TYPE _LIB_VERSION;
># 316 "/usr/include/math.h" 3 4
>struct __exception
>
>
>
> {
> int type;
> char *name;
> double arg1;
> double arg2;
> double retval;
> };
>
>
>extern int matherr (struct __exception *__exc) throw ();
># 418 "/usr/include/math.h" 3 4
># 1 "/usr/include/bits/mathinline.h" 1 3 4
># 24 "/usr/include/bits/mathinline.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 25 "/usr/include/bits/mathinline.h" 2 3 4
># 36 "/usr/include/bits/mathinline.h" 3 4
>
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
>__attribute__ ((__leaf__)) __signbitf (float __x) throw ()
>{
>
>
>
>
> int __m;
> __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
> return __m & 0x8;
>
>}
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
>__attribute__ ((__leaf__)) __signbit (double __x) throw ()
>{
>
>
>
>
> int __m;
> __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
> return __m & 0x80;
>
>}
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
>__attribute__ ((__leaf__)) __signbitl (long double __x) throw ()
>{
> __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
> return (__u.__i[2] & 0x8000) != 0;
>}
>
>
># 419 "/usr/include/math.h" 2 3 4
># 480 "/usr/include/math.h" 3 4
>}
># 47 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cmath" 2 3
># 77 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cmath" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> inline constexpr double
> abs(double __x)
> { return __builtin_fabs(__x); }
>
>
>
> inline constexpr float
> abs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline constexpr long double
> abs(long double __x)
> { return __builtin_fabsl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> abs(_Tp __x)
> { return __builtin_fabs(__x); }
>
> using ::acos;
>
>
> inline constexpr float
> acos(float __x)
> { return __builtin_acosf(__x); }
>
> inline constexpr long double
> acos(long double __x)
> { return __builtin_acosl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> acos(_Tp __x)
> { return __builtin_acos(__x); }
>
> using ::asin;
>
>
> inline constexpr float
> asin(float __x)
> { return __builtin_asinf(__x); }
>
> inline constexpr long double
> asin(long double __x)
> { return __builtin_asinl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> asin(_Tp __x)
> { return __builtin_asin(__x); }
>
> using ::atan;
>
>
> inline constexpr float
> atan(float __x)
> { return __builtin_atanf(__x); }
>
> inline constexpr long double
> atan(long double __x)
> { return __builtin_atanl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> atan(_Tp __x)
> { return __builtin_atan(__x); }
>
> using ::atan2;
>
>
> inline constexpr float
> atan2(float __y, float __x)
> { return __builtin_atan2f(__y, __x); }
>
> inline constexpr long double
> atan2(long double __y, long double __x)
> { return __builtin_atan2l(__y, __x); }
>
>
> template<typename _Tp, typename _Up>
> inline constexpr
> typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> atan2(_Tp __y, _Up __x)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return atan2(__type(__y), __type(__x));
> }
>
> using ::ceil;
>
>
> inline constexpr float
> ceil(float __x)
> { return __builtin_ceilf(__x); }
>
> inline constexpr long double
> ceil(long double __x)
> { return __builtin_ceill(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> ceil(_Tp __x)
> { return __builtin_ceil(__x); }
>
> using ::cos;
>
>
> inline constexpr float
> cos(float __x)
> { return __builtin_cosf(__x); }
>
> inline constexpr long double
> cos(long double __x)
> { return __builtin_cosl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> cos(_Tp __x)
> { return __builtin_cos(__x); }
>
> using ::cosh;
>
>
> inline constexpr float
> cosh(float __x)
> { return __builtin_coshf(__x); }
>
> inline constexpr long double
> cosh(long double __x)
> { return __builtin_coshl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> cosh(_Tp __x)
> { return __builtin_cosh(__x); }
>
> using ::exp;
>
>
> inline constexpr float
> exp(float __x)
> { return __builtin_expf(__x); }
>
> inline constexpr long double
> exp(long double __x)
> { return __builtin_expl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> exp(_Tp __x)
> { return __builtin_exp(__x); }
>
> using ::fabs;
>
>
> inline constexpr float
> fabs(float __x)
> { return __builtin_fabsf(__x); }
>
> inline constexpr long double
> fabs(long double __x)
> { return __builtin_fabsl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> fabs(_Tp __x)
> { return __builtin_fabs(__x); }
>
> using ::floor;
>
>
> inline constexpr float
> floor(float __x)
> { return __builtin_floorf(__x); }
>
> inline constexpr long double
> floor(long double __x)
> { return __builtin_floorl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> floor(_Tp __x)
> { return __builtin_floor(__x); }
>
> using ::fmod;
>
>
> inline constexpr float
> fmod(float __x, float __y)
> { return __builtin_fmodf(__x, __y); }
>
> inline constexpr long double
> fmod(long double __x, long double __y)
> { return __builtin_fmodl(__x, __y); }
>
>
> template<typename _Tp, typename _Up>
> inline constexpr
> typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> fmod(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return fmod(__type(__x), __type(__y));
> }
>
> using ::frexp;
>
>
> inline float
> frexp(float __x, int* __exp)
> { return __builtin_frexpf(__x, __exp); }
>
> inline long double
> frexp(long double __x, int* __exp)
> { return __builtin_frexpl(__x, __exp); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> frexp(_Tp __x, int* __exp)
> { return __builtin_frexp(__x, __exp); }
>
> using ::ldexp;
>
>
> inline constexpr float
> ldexp(float __x, int __exp)
> { return __builtin_ldexpf(__x, __exp); }
>
> inline constexpr long double
> ldexp(long double __x, int __exp)
> { return __builtin_ldexpl(__x, __exp); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> ldexp(_Tp __x, int __exp)
> { return __builtin_ldexp(__x, __exp); }
>
> using ::log;
>
>
> inline constexpr float
> log(float __x)
> { return __builtin_logf(__x); }
>
> inline constexpr long double
> log(long double __x)
> { return __builtin_logl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log(_Tp __x)
> { return __builtin_log(__x); }
>
> using ::log10;
>
>
> inline constexpr float
> log10(float __x)
> { return __builtin_log10f(__x); }
>
> inline constexpr long double
> log10(long double __x)
> { return __builtin_log10l(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log10(_Tp __x)
> { return __builtin_log10(__x); }
>
> using ::modf;
>
>
> inline float
> modf(float __x, float* __iptr)
> { return __builtin_modff(__x, __iptr); }
>
> inline long double
> modf(long double __x, long double* __iptr)
> { return __builtin_modfl(__x, __iptr); }
>
>
> using ::pow;
>
>
> inline constexpr float
> pow(float __x, float __y)
> { return __builtin_powf(__x, __y); }
>
> inline constexpr long double
> pow(long double __x, long double __y)
> { return __builtin_powl(__x, __y); }
># 434 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cmath" 3
> template<typename _Tp, typename _Up>
> inline constexpr
> typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> pow(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return pow(__type(__x), __type(__y));
> }
>
> using ::sin;
>
>
> inline constexpr float
> sin(float __x)
> { return __builtin_sinf(__x); }
>
> inline constexpr long double
> sin(long double __x)
> { return __builtin_sinl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> sin(_Tp __x)
> { return __builtin_sin(__x); }
>
> using ::sinh;
>
>
> inline constexpr float
> sinh(float __x)
> { return __builtin_sinhf(__x); }
>
> inline constexpr long double
> sinh(long double __x)
> { return __builtin_sinhl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> sinh(_Tp __x)
> { return __builtin_sinh(__x); }
>
> using ::sqrt;
>
>
> inline constexpr float
> sqrt(float __x)
> { return __builtin_sqrtf(__x); }
>
> inline constexpr long double
> sqrt(long double __x)
> { return __builtin_sqrtl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> sqrt(_Tp __x)
> { return __builtin_sqrt(__x); }
>
> using ::tan;
>
>
> inline constexpr float
> tan(float __x)
> { return __builtin_tanf(__x); }
>
> inline constexpr long double
> tan(long double __x)
> { return __builtin_tanl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> tan(_Tp __x)
> { return __builtin_tan(__x); }
>
> using ::tanh;
>
>
> inline constexpr float
> tanh(float __x)
> { return __builtin_tanhf(__x); }
>
> inline constexpr long double
> tanh(long double __x)
> { return __builtin_tanhl(__x); }
>
>
> template<typename _Tp>
> inline constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> tanh(_Tp __x)
> { return __builtin_tanh(__x); }
>
>
>}
># 558 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cmath" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> constexpr int
> fpclassify(float __x)
> { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
> FP_SUBNORMAL, FP_ZERO, __x); }
>
> constexpr int
> fpclassify(double __x)
> { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
> FP_SUBNORMAL, FP_ZERO, __x); }
>
> constexpr int
> fpclassify(long double __x)
> { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
> FP_SUBNORMAL, FP_ZERO, __x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> int>::__type
> fpclassify(_Tp __x)
> { return __x != 0 ? FP_NORMAL : FP_ZERO; }
>
> constexpr bool
> isfinite(float __x)
> { return __builtin_isfinite(__x); }
>
> constexpr bool
> isfinite(double __x)
> { return __builtin_isfinite(__x); }
>
> constexpr bool
> isfinite(long double __x)
> { return __builtin_isfinite(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isfinite(_Tp __x)
> { return true; }
>
> constexpr bool
> isinf(float __x)
> { return __builtin_isinf(__x); }
>
> constexpr bool
> isinf(double __x)
> { return __builtin_isinf(__x); }
>
> constexpr bool
> isinf(long double __x)
> { return __builtin_isinf(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isinf(_Tp __x)
> { return false; }
>
> constexpr bool
> isnan(float __x)
> { return __builtin_isnan(__x); }
>
> constexpr bool
> isnan(double __x)
> { return __builtin_isnan(__x); }
>
> constexpr bool
> isnan(long double __x)
> { return __builtin_isnan(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isnan(_Tp __x)
> { return false; }
>
> constexpr bool
> isnormal(float __x)
> { return __builtin_isnormal(__x); }
>
> constexpr bool
> isnormal(double __x)
> { return __builtin_isnormal(__x); }
>
> constexpr bool
> isnormal(long double __x)
> { return __builtin_isnormal(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> isnormal(_Tp __x)
> { return __x != 0 ? true : false; }
>
> constexpr bool
> signbit(float __x)
> { return __builtin_signbit(__x); }
>
> constexpr bool
> signbit(double __x)
> { return __builtin_signbit(__x); }
>
> constexpr bool
> signbit(long double __x)
> { return __builtin_signbit(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> bool>::__type
> signbit(_Tp __x)
> { return __x < 0 ? true : false; }
>
> constexpr bool
> isgreater(float __x, float __y)
> { return __builtin_isgreater(__x, __y); }
>
> constexpr bool
> isgreater(double __x, double __y)
> { return __builtin_isgreater(__x, __y); }
>
> constexpr bool
> isgreater(long double __x, long double __y)
> { return __builtin_isgreater(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isgreater(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isgreater(__type(__x), __type(__y));
> }
>
> constexpr bool
> isgreaterequal(float __x, float __y)
> { return __builtin_isgreaterequal(__x, __y); }
>
> constexpr bool
> isgreaterequal(double __x, double __y)
> { return __builtin_isgreaterequal(__x, __y); }
>
> constexpr bool
> isgreaterequal(long double __x, long double __y)
> { return __builtin_isgreaterequal(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isgreaterequal(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isgreaterequal(__type(__x), __type(__y));
> }
>
> constexpr bool
> isless(float __x, float __y)
> { return __builtin_isless(__x, __y); }
>
> constexpr bool
> isless(double __x, double __y)
> { return __builtin_isless(__x, __y); }
>
> constexpr bool
> isless(long double __x, long double __y)
> { return __builtin_isless(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isless(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isless(__type(__x), __type(__y));
> }
>
> constexpr bool
> islessequal(float __x, float __y)
> { return __builtin_islessequal(__x, __y); }
>
> constexpr bool
> islessequal(double __x, double __y)
> { return __builtin_islessequal(__x, __y); }
>
> constexpr bool
> islessequal(long double __x, long double __y)
> { return __builtin_islessequal(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> islessequal(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_islessequal(__type(__x), __type(__y));
> }
>
> constexpr bool
> islessgreater(float __x, float __y)
> { return __builtin_islessgreater(__x, __y); }
>
> constexpr bool
> islessgreater(double __x, double __y)
> { return __builtin_islessgreater(__x, __y); }
>
> constexpr bool
> islessgreater(long double __x, long double __y)
> { return __builtin_islessgreater(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> islessgreater(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_islessgreater(__type(__x), __type(__y));
> }
>
> constexpr bool
> isunordered(float __x, float __y)
> { return __builtin_isunordered(__x, __y); }
>
> constexpr bool
> isunordered(double __x, double __y)
> { return __builtin_isunordered(__x, __y); }
>
> constexpr bool
> isunordered(long double __x, long double __y)
> { return __builtin_isunordered(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename
> __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
> && __is_arithmetic<_Up>::__value), bool>::__type
> isunordered(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return __builtin_isunordered(__type(__x), __type(__y));
> }
># 919 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cmath" 3
>
>}
># 1035 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cmath" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> using ::double_t;
> using ::float_t;
>
>
> using ::acosh;
> using ::acoshf;
> using ::acoshl;
>
> using ::asinh;
> using ::asinhf;
> using ::asinhl;
>
> using ::atanh;
> using ::atanhf;
> using ::atanhl;
>
> using ::cbrt;
> using ::cbrtf;
> using ::cbrtl;
>
> using ::copysign;
> using ::copysignf;
> using ::copysignl;
>
> using ::erf;
> using ::erff;
> using ::erfl;
>
> using ::erfc;
> using ::erfcf;
> using ::erfcl;
>
> using ::exp2;
> using ::exp2f;
> using ::exp2l;
>
> using ::expm1;
> using ::expm1f;
> using ::expm1l;
>
> using ::fdim;
> using ::fdimf;
> using ::fdiml;
>
> using ::fma;
> using ::fmaf;
> using ::fmal;
>
> using ::fmax;
> using ::fmaxf;
> using ::fmaxl;
>
> using ::fmin;
> using ::fminf;
> using ::fminl;
>
> using ::hypot;
> using ::hypotf;
> using ::hypotl;
>
> using ::ilogb;
> using ::ilogbf;
> using ::ilogbl;
>
> using ::lgamma;
> using ::lgammaf;
> using ::lgammal;
>
> using ::llrint;
> using ::llrintf;
> using ::llrintl;
>
> using ::llround;
> using ::llroundf;
> using ::llroundl;
>
> using ::log1p;
> using ::log1pf;
> using ::log1pl;
>
> using ::log2;
> using ::log2f;
> using ::log2l;
>
> using ::logb;
> using ::logbf;
> using ::logbl;
>
> using ::lrint;
> using ::lrintf;
> using ::lrintl;
>
> using ::lround;
> using ::lroundf;
> using ::lroundl;
>
> using ::nan;
> using ::nanf;
> using ::nanl;
>
> using ::nearbyint;
> using ::nearbyintf;
> using ::nearbyintl;
>
> using ::nextafter;
> using ::nextafterf;
> using ::nextafterl;
>
> using ::nexttoward;
> using ::nexttowardf;
> using ::nexttowardl;
>
> using ::remainder;
> using ::remainderf;
> using ::remainderl;
>
> using ::remquo;
> using ::remquof;
> using ::remquol;
>
> using ::rint;
> using ::rintf;
> using ::rintl;
>
> using ::round;
> using ::roundf;
> using ::roundl;
>
> using ::scalbln;
> using ::scalblnf;
> using ::scalblnl;
>
> using ::scalbn;
> using ::scalbnf;
> using ::scalbnl;
>
> using ::tgamma;
> using ::tgammaf;
> using ::tgammal;
>
> using ::trunc;
> using ::truncf;
> using ::truncl;
>
>
> constexpr float
> acosh(float __x)
> { return __builtin_acoshf(__x); }
>
> constexpr long double
> acosh(long double __x)
> { return __builtin_acoshl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> acosh(_Tp __x)
> { return __builtin_acosh(__x); }
>
> constexpr float
> asinh(float __x)
> { return __builtin_asinhf(__x); }
>
> constexpr long double
> asinh(long double __x)
> { return __builtin_asinhl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> asinh(_Tp __x)
> { return __builtin_asinh(__x); }
>
> constexpr float
> atanh(float __x)
> { return __builtin_atanhf(__x); }
>
> constexpr long double
> atanh(long double __x)
> { return __builtin_atanhl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> atanh(_Tp __x)
> { return __builtin_atanh(__x); }
>
> constexpr float
> cbrt(float __x)
> { return __builtin_cbrtf(__x); }
>
> constexpr long double
> cbrt(long double __x)
> { return __builtin_cbrtl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> cbrt(_Tp __x)
> { return __builtin_cbrt(__x); }
>
> constexpr float
> copysign(float __x, float __y)
> { return __builtin_copysignf(__x, __y); }
>
> constexpr long double
> copysign(long double __x, long double __y)
> { return __builtin_copysignl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> copysign(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return copysign(__type(__x), __type(__y));
> }
>
> constexpr float
> erf(float __x)
> { return __builtin_erff(__x); }
>
> constexpr long double
> erf(long double __x)
> { return __builtin_erfl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> erf(_Tp __x)
> { return __builtin_erf(__x); }
>
> constexpr float
> erfc(float __x)
> { return __builtin_erfcf(__x); }
>
> constexpr long double
> erfc(long double __x)
> { return __builtin_erfcl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> erfc(_Tp __x)
> { return __builtin_erfc(__x); }
>
> constexpr float
> exp2(float __x)
> { return __builtin_exp2f(__x); }
>
> constexpr long double
> exp2(long double __x)
> { return __builtin_exp2l(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> exp2(_Tp __x)
> { return __builtin_exp2(__x); }
>
> constexpr float
> expm1(float __x)
> { return __builtin_expm1f(__x); }
>
> constexpr long double
> expm1(long double __x)
> { return __builtin_expm1l(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> expm1(_Tp __x)
> { return __builtin_expm1(__x); }
>
> constexpr float
> fdim(float __x, float __y)
> { return __builtin_fdimf(__x, __y); }
>
> constexpr long double
> fdim(long double __x, long double __y)
> { return __builtin_fdiml(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> fdim(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return fdim(__type(__x), __type(__y));
> }
>
> constexpr float
> fma(float __x, float __y, float __z)
> { return __builtin_fmaf(__x, __y, __z); }
>
> constexpr long double
> fma(long double __x, long double __y, long double __z)
> { return __builtin_fmal(__x, __y, __z); }
>
> template<typename _Tp, typename _Up, typename _Vp>
> constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
> fma(_Tp __x, _Up __y, _Vp __z)
> {
> typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
> return fma(__type(__x), __type(__y), __type(__z));
> }
>
> constexpr float
> fmax(float __x, float __y)
> { return __builtin_fmaxf(__x, __y); }
>
> constexpr long double
> fmax(long double __x, long double __y)
> { return __builtin_fmaxl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> fmax(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return fmax(__type(__x), __type(__y));
> }
>
> constexpr float
> fmin(float __x, float __y)
> { return __builtin_fminf(__x, __y); }
>
> constexpr long double
> fmin(long double __x, long double __y)
> { return __builtin_fminl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> fmin(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return fmin(__type(__x), __type(__y));
> }
>
> constexpr float
> hypot(float __x, float __y)
> { return __builtin_hypotf(__x, __y); }
>
> constexpr long double
> hypot(long double __x, long double __y)
> { return __builtin_hypotl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> hypot(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return hypot(__type(__x), __type(__y));
> }
>
> constexpr int
> ilogb(float __x)
> { return __builtin_ilogbf(__x); }
>
> constexpr int
> ilogb(long double __x)
> { return __builtin_ilogbl(__x); }
>
> template<typename _Tp>
> constexpr
> typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> int>::__type
> ilogb(_Tp __x)
> { return __builtin_ilogb(__x); }
>
> constexpr float
> lgamma(float __x)
> { return __builtin_lgammaf(__x); }
>
> constexpr long double
> lgamma(long double __x)
> { return __builtin_lgammal(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> lgamma(_Tp __x)
> { return __builtin_lgamma(__x); }
>
> constexpr long long
> llrint(float __x)
> { return __builtin_llrintf(__x); }
>
> constexpr long long
> llrint(long double __x)
> { return __builtin_llrintl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long long>::__type
> llrint(_Tp __x)
> { return __builtin_llrint(__x); }
>
> constexpr long long
> llround(float __x)
> { return __builtin_llroundf(__x); }
>
> constexpr long long
> llround(long double __x)
> { return __builtin_llroundl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long long>::__type
> llround(_Tp __x)
> { return __builtin_llround(__x); }
>
> constexpr float
> log1p(float __x)
> { return __builtin_log1pf(__x); }
>
> constexpr long double
> log1p(long double __x)
> { return __builtin_log1pl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log1p(_Tp __x)
> { return __builtin_log1p(__x); }
>
>
> constexpr float
> log2(float __x)
> { return __builtin_log2f(__x); }
>
> constexpr long double
> log2(long double __x)
> { return __builtin_log2l(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> log2(_Tp __x)
> { return __builtin_log2(__x); }
>
> constexpr float
> logb(float __x)
> { return __builtin_logbf(__x); }
>
> constexpr long double
> logb(long double __x)
> { return __builtin_logbl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> logb(_Tp __x)
> { return __builtin_logb(__x); }
>
> constexpr long
> lrint(float __x)
> { return __builtin_lrintf(__x); }
>
> constexpr long
> lrint(long double __x)
> { return __builtin_lrintl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long>::__type
> lrint(_Tp __x)
> { return __builtin_lrint(__x); }
>
> constexpr long
> lround(float __x)
> { return __builtin_lroundf(__x); }
>
> constexpr long
> lround(long double __x)
> { return __builtin_lroundl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> long>::__type
> lround(_Tp __x)
> { return __builtin_lround(__x); }
>
> constexpr float
> nearbyint(float __x)
> { return __builtin_nearbyintf(__x); }
>
> constexpr long double
> nearbyint(long double __x)
> { return __builtin_nearbyintl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> nearbyint(_Tp __x)
> { return __builtin_nearbyint(__x); }
>
> constexpr float
> nextafter(float __x, float __y)
> { return __builtin_nextafterf(__x, __y); }
>
> constexpr long double
> nextafter(long double __x, long double __y)
> { return __builtin_nextafterl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> nextafter(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return nextafter(__type(__x), __type(__y));
> }
>
> constexpr float
> nexttoward(float __x, long double __y)
> { return __builtin_nexttowardf(__x, __y); }
>
> constexpr long double
> nexttoward(long double __x, long double __y)
> { return __builtin_nexttowardl(__x, __y); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> nexttoward(_Tp __x, long double __y)
> { return __builtin_nexttoward(__x, __y); }
>
> constexpr float
> remainder(float __x, float __y)
> { return __builtin_remainderf(__x, __y); }
>
> constexpr long double
> remainder(long double __x, long double __y)
> { return __builtin_remainderl(__x, __y); }
>
> template<typename _Tp, typename _Up>
> constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> remainder(_Tp __x, _Up __y)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return remainder(__type(__x), __type(__y));
> }
>
> inline float
> remquo(float __x, float __y, int* __pquo)
> { return __builtin_remquof(__x, __y, __pquo); }
>
> inline long double
> remquo(long double __x, long double __y, int* __pquo)
> { return __builtin_remquol(__x, __y, __pquo); }
>
> template<typename _Tp, typename _Up>
> inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
> remquo(_Tp __x, _Up __y, int* __pquo)
> {
> typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
> return remquo(__type(__x), __type(__y), __pquo);
> }
>
> constexpr float
> rint(float __x)
> { return __builtin_rintf(__x); }
>
> constexpr long double
> rint(long double __x)
> { return __builtin_rintl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> rint(_Tp __x)
> { return __builtin_rint(__x); }
>
> constexpr float
> round(float __x)
> { return __builtin_roundf(__x); }
>
> constexpr long double
> round(long double __x)
> { return __builtin_roundl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> round(_Tp __x)
> { return __builtin_round(__x); }
>
> constexpr float
> scalbln(float __x, long __ex)
> { return __builtin_scalblnf(__x, __ex); }
>
> constexpr long double
> scalbln(long double __x, long __ex)
> { return __builtin_scalblnl(__x, __ex); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> scalbln(_Tp __x, long __ex)
> { return __builtin_scalbln(__x, __ex); }
>
> constexpr float
> scalbn(float __x, int __ex)
> { return __builtin_scalbnf(__x, __ex); }
>
> constexpr long double
> scalbn(long double __x, int __ex)
> { return __builtin_scalbnl(__x, __ex); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> scalbn(_Tp __x, int __ex)
> { return __builtin_scalbn(__x, __ex); }
>
> constexpr float
> tgamma(float __x)
> { return __builtin_tgammaf(__x); }
>
> constexpr long double
> tgamma(long double __x)
> { return __builtin_tgammal(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> tgamma(_Tp __x)
> { return __builtin_tgamma(__x); }
>
> constexpr float
> trunc(float __x)
> { return __builtin_truncf(__x); }
>
> constexpr long double
> trunc(long double __x)
> { return __builtin_truncl(__x); }
>
> template<typename _Tp>
> constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
> double>::__type
> trunc(_Tp __x)
> { return __builtin_trunc(__x); }
>
>
>}
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 3
>
>
># 1 "/usr/include/stdio.h" 1 3 4
># 30 "/usr/include/stdio.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 35 "/usr/include/stdio.h" 2 3 4
># 45 "/usr/include/stdio.h" 3 4
>struct _IO_FILE;
>
>
>
>typedef struct _IO_FILE FILE;
>
>
>
>
>
># 65 "/usr/include/stdio.h" 3 4
>typedef struct _IO_FILE __FILE;
># 75 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/libio.h" 1 3 4
># 32 "/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-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 16 "/usr/include/_G_config.h" 2 3 4
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 83 "/usr/include/wchar.h" 3 4
>typedef struct
>{
> int __count;
> union
> {
>
> unsigned int __wch;
>
>
>
> char __wchb[4];
> } __value;
>} __mbstate_t;
># 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;
># 53 "/usr/include/_G_config.h" 3 4
>typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
>typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
>typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
>typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
># 33 "/usr/include/libio.h" 2 3 4
># 53 "/usr/include/libio.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stdarg.h" 1 3 4
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stdarg.h" 3 4
>typedef __builtin_va_list __gnuc_va_list;
># 54 "/usr/include/libio.h" 2 3 4
># 172 "/usr/include/libio.h" 3 4
>struct _IO_jump_t; struct _IO_FILE;
># 182 "/usr/include/libio.h" 3 4
>typedef void _IO_lock_t;
>
>
>
>
>
>struct _IO_marker {
> struct _IO_marker *_next;
> struct _IO_FILE *_sbuf;
>
>
>
> int _pos;
># 205 "/usr/include/libio.h" 3 4
>};
>
>
>enum __codecvt_result
>{
> __codecvt_ok,
> __codecvt_partial,
> __codecvt_error,
> __codecvt_noconv
>};
># 273 "/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;
># 321 "/usr/include/libio.h" 3 4
> __off64_t _offset;
># 330 "/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_;
># 366 "/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);
># 462 "/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 ();
># 492 "/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 ();
># 554 "/usr/include/libio.h" 3 4
>}
># 76 "/usr/include/stdio.h" 2 3 4
>
>
>
>
>typedef __gnuc_va_list va_list;
># 109 "/usr/include/stdio.h" 3 4
>
>
>typedef _G_fpos_t fpos_t;
>
>
>
>
>
>typedef _G_fpos64_t fpos64_t;
># 165 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 166 "/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) ;
># 208 "/usr/include/stdio.h" 3 4
>extern FILE *tmpfile64 (void) ;
>
>
>
>extern char *tmpnam (char *__s) throw () ;
>
>
>
>
>
>extern char *tmpnam_r (char *__s) throw () ;
># 230 "/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);
>
># 255 "/usr/include/stdio.h" 3 4
>extern int fflush_unlocked (FILE *__stream);
># 265 "/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) ;
># 298 "/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))) ;
># 420 "/usr/include/stdio.h" 3 4
>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 ();
># 471 "/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)));
># 530 "/usr/include/stdio.h" 3 4
>
>
>
>
>
>
>
>
>
>extern int fgetc (FILE *__stream);
>extern int getc (FILE *__stream);
>
>
>
>
>
>extern int getchar (void);
>
># 558 "/usr/include/stdio.h" 3 4
>extern int getc_unlocked (FILE *__stream);
>extern int getchar_unlocked (void);
># 569 "/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);
>
># 602 "/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)
> ;
>
>
>
>
>
>
>extern char *gets (char *__s) ;
>
># 648 "/usr/include/stdio.h" 3 4
>extern char *fgets_unlocked (char *__restrict __s, int __n,
> FILE *__restrict __stream) ;
># 664 "/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) ;
>
># 725 "/usr/include/stdio.h" 3 4
>extern int fputs_unlocked (__const char *__restrict __s,
> FILE *__restrict __stream);
># 736 "/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);
>
># 772 "/usr/include/stdio.h" 3 4
>extern int fseeko (FILE *__stream, __off_t __off, int __whence);
>
>
>
>
>extern __off_t ftello (FILE *__stream) ;
># 791 "/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);
># 814 "/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
># 27 "/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[];
># 853 "/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 ();
># 933 "/usr/include/stdio.h" 3 4
># 1 "/usr/include/bits/stdio.h" 1 3 4
># 36 "/usr/include/bits/stdio.h" 3 4
>extern __inline __attribute__ ((__gnu_inline__)) int
>vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
>{
> return vfprintf (stdout, __fmt, __arg);
>}
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>getchar (void)
>{
> return _IO_getc (stdin);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>fgetc_unlocked (FILE *__fp)
>{
> return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>getc_unlocked (FILE *__fp)
>{
> return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>getchar_unlocked (void)
>{
> return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putchar (int __c)
>{
> return _IO_putc (__c, stdout);
>}
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>fputc_unlocked (int __c, FILE *__stream)
>{
> return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putc_unlocked (int __c, FILE *__stream)
>{
> return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>putchar_unlocked (int __c)
>{
> return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
>getline (char **__lineptr, size_t *__n, FILE *__stream)
>{
> return __getdelim (__lineptr, __n, '\n', __stream);
>}
>
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) feof_unlocked (FILE *__stream) throw ()
>{
> return (((__stream)->_flags & 0x10) != 0);
>}
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) ferror_unlocked (FILE *__stream) throw ()
>{
> return (((__stream)->_flags & 0x20) != 0);
>}
># 934 "/usr/include/stdio.h" 2 3 4
># 942 "/usr/include/stdio.h" 3 4
>}
># 45 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 2 3
># 95 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 3
>namespace std
>{
> using ::FILE;
> using ::fpos_t;
>
> using ::clearerr;
> using ::fclose;
> using ::feof;
> using ::ferror;
> using ::fflush;
> using ::fgetc;
> using ::fgetpos;
> using ::fgets;
> using ::fopen;
> using ::fprintf;
> using ::fputc;
> using ::fputs;
> using ::fread;
> using ::freopen;
> using ::fscanf;
> using ::fseek;
> using ::fsetpos;
> using ::ftell;
> using ::fwrite;
> using ::getc;
> using ::getchar;
> using ::gets;
> using ::perror;
> using ::printf;
> using ::putc;
> using ::putchar;
> using ::puts;
> using ::remove;
> using ::rename;
> using ::rewind;
> using ::scanf;
> using ::setbuf;
> using ::setvbuf;
> using ::sprintf;
> using ::sscanf;
> using ::tmpfile;
> using ::tmpnam;
> using ::ungetc;
> using ::vfprintf;
> using ::vprintf;
> using ::vsprintf;
>}
># 151 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 3
>namespace __gnu_cxx
>{
># 169 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 3
> using ::snprintf;
> using ::vfscanf;
> using ::vscanf;
> using ::vsnprintf;
> using ::vsscanf;
>
>}
>
>namespace std
>{
> using ::__gnu_cxx::snprintf;
> using ::__gnu_cxx::vfscanf;
> using ::__gnu_cxx::vscanf;
> using ::__gnu_cxx::vsnprintf;
> using ::__gnu_cxx::vsscanf;
>}
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 1 3
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 3
> 
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stringfwd.h" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stringfwd.h" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stringfwd.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Alloc>
> class allocator;
>
>
>
>
>
>
>
> template<class _CharT>
> struct char_traits;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_string;
>
> template<> struct char_traits<char>;
>
> typedef basic_string<char> string;
>
>
> template<> struct char_traits<wchar_t>;
>
> typedef basic_string<wchar_t> wstring;
>
>
>
>
>
> template<> struct char_traits<char16_t>;
> template<> struct char_traits<char32_t>;
>
> typedef basic_string<char16_t> u16string;
> typedef basic_string<char32_t> u32string;
>
>
>
>
>
>}
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/char_traits.h" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/char_traits.h" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/char_traits.h" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/postypes.h" 1 3
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/postypes.h" 3
> 
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/postypes.h" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 40 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stdarg.h" 1 3 4
># 41 "/usr/include/wchar.h" 2 3 4
>
># 1 "/usr/include/bits/wchar.h" 1 3 4
># 43 "/usr/include/wchar.h" 2 3 4
># 52 "/usr/include/wchar.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 354 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 3 4
>typedef unsigned int wint_t;
># 53 "/usr/include/wchar.h" 2 3 4
># 104 "/usr/include/wchar.h" 3 4
>
>
>typedef __mbstate_t mbstate_t;
>
>
>
># 129 "/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__));
># 303 "/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 *__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 ();
>
>
>
>
>
>
>
>
>extern wint_t __btowc_alias (int __c) __asm ("btowc");
>extern __inline __attribute__ ((__gnu_inline__)) wint_t
>__attribute__ ((__leaf__)) btowc (int __c) throw ()
>{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
> ? (wint_t) __c : __btowc_alias (__c)); }
>
>extern int __wctob_alias (wint_t __c) __asm ("wctob");
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) wctob (wint_t __wc) throw ()
>{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
> ? (int) __wc : __wctob_alias (__wc)); }
>
>extern __inline __attribute__ ((__gnu_inline__)) size_t
>__attribute__ ((__leaf__)) mbrlen (__const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
>
>{ return (__ps != __null
> ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }
>
>
>
>
>
>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 ();
># 527 "/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 () ;
># 677 "/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 () ;
># 733 "/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);
>
># 798 "/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);
># 824 "/usr/include/wchar.h" 3 4
>extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
>extern wint_t putwchar_unlocked (wchar_t __wc);
># 834 "/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 ();
># 888 "/usr/include/wchar.h" 3 4
>}
># 47 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 2 3
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
>namespace std
>{
> using ::mbstate_t;
>}
># 137 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
># 234 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
>
>}
>
>
>
>
>
>
>
>namespace __gnu_cxx
>{
>
>
>
>
>
> using ::wcstold;
># 259 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
> using ::wcstoll;
> using ::wcstoull;
>
>}
>
>namespace std
>{
> using ::__gnu_cxx::wcstold;
> using ::__gnu_cxx::wcstoll;
> using ::__gnu_cxx::wcstoull;
>}
># 279 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
>namespace std
>{
>
> using std::wcstof;
>
>
> using std::vfwscanf;
>
>
> using std::vswscanf;
>
>
> using std::vwscanf;
>
>
>
> using std::wcstold;
> using std::wcstoll;
> using std::wcstoull;
>
>}
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/postypes.h" 2 3
># 70 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/postypes.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 90 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/postypes.h" 3
> typedef long streamoff;
># 100 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/postypes.h" 3
> typedef ptrdiff_t streamsize;
># 113 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/postypes.h" 3
> template<typename _StateT>
> class fpos
> {
> private:
> streamoff _M_off;
> _StateT _M_state;
>
> public:
>
>
>
>
> fpos()
> : _M_off(0), _M_state() { }
># 135 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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<typename _StateT>
> inline bool
> operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
> { return streamoff(__lhs) == streamoff(__rhs); }
>
> template<typename _StateT>
> inline bool
> operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
> { return streamoff(__lhs) != streamoff(__rhs); }
>
>
>
>
>
> typedef fpos<mbstate_t> streampos;
>
> typedef fpos<mbstate_t> wstreampos;
>
>
>
> typedef fpos<mbstate_t> u16streampos;
>
> typedef fpos<mbstate_t> u32streampos;
>
>
>
>}
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/char_traits.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 47 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 2 3
># 44 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/char_traits.h" 2 3
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
># 59 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/char_traits.h" 3
> template<typename _CharT>
> struct _Char_types
> {
> typedef unsigned long int_type;
> typedef std::streampos pos_type;
> typedef std::streamoff off_type;
> typedef std::mbstate_t state_type;
> };
># 84 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/char_traits.h" 3
> template<typename _CharT>
> 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 constexpr bool
> eq(const char_type& __c1, const char_type& __c2)
> { return __c1 == __c2; }
>
> static constexpr 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 constexpr char_type
> to_char_type(const int_type& __c)
> { return static_cast<char_type>(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c)
> { return static_cast<int_type>(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2)
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof()
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c)
> { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
> };
>
> template<typename _CharT>
> 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<typename _CharT>
> 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<typename _CharT>
> 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 _CharT>
> 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 _CharT>
> 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 _CharT>
> 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")))
>{
>
># 228 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/char_traits.h" 3
> template<class _CharT>
> struct char_traits : public __gnu_cxx::char_traits<_CharT>
> { };
>
>
>
> template<>
> struct char_traits<char>
> {
> 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) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __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<const char_type*>(__builtin_memchr(__s, __a, __n)); }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return static_cast<char_type>(__c); }
>
>
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return (__c == eof()) ? 0 : __c; }
> };
>
>
>
>
> template<>
> struct char_traits<wchar_t>
> {
> typedef wchar_t char_type;
> typedef wint_t int_type;
> typedef streamoff off_type;
> typedef wstreampos pos_type;
> typedef mbstate_t state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { 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 constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return char_type(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return int_type(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>((0xffffffffu)); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
>
>
>}
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdint" 1 3
># 32 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdint" 3
> 
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdint" 3
># 50 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdint" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stdint.h" 1 3 4
>
>
># 1 "/usr/include/stdint.h" 1 3 4
># 28 "/usr/include/stdint.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 29 "/usr/include/stdint.h" 2 3 4
># 49 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint8_t;
>typedef unsigned short int uint16_t;
>
>typedef unsigned int uint32_t;
>
>
>
>typedef unsigned long int uint64_t;
># 66 "/usr/include/stdint.h" 3 4
>typedef signed char int_least8_t;
>typedef short int int_least16_t;
>typedef int int_least32_t;
>
>typedef long int int_least64_t;
>
>
>
>
>
>
>typedef unsigned char uint_least8_t;
>typedef unsigned short int uint_least16_t;
>typedef unsigned int uint_least32_t;
>
>typedef unsigned long int uint_least64_t;
># 91 "/usr/include/stdint.h" 3 4
>typedef signed char int_fast8_t;
>
>typedef long int int_fast16_t;
>typedef long int int_fast32_t;
>typedef long int int_fast64_t;
># 104 "/usr/include/stdint.h" 3 4
>typedef unsigned char uint_fast8_t;
>
>typedef unsigned long int uint_fast16_t;
>typedef unsigned long int uint_fast32_t;
>typedef unsigned long int uint_fast64_t;
># 120 "/usr/include/stdint.h" 3 4
>typedef long int intptr_t;
>
>
>typedef unsigned long int uintptr_t;
># 135 "/usr/include/stdint.h" 3 4
>typedef long int intmax_t;
>typedef unsigned long int uintmax_t;
># 4 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stdint.h" 2 3 4
># 51 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdint" 2 3
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdint" 3
>namespace std
>{
> using ::int8_t;
> using ::int16_t;
> using ::int32_t;
> using ::int64_t;
>
> using ::int_fast8_t;
> using ::int_fast16_t;
> using ::int_fast32_t;
> using ::int_fast64_t;
>
> using ::int_least8_t;
> using ::int_least16_t;
> using ::int_least32_t;
> using ::int_least64_t;
>
> using ::intmax_t;
> using ::intptr_t;
>
> using ::uint8_t;
> using ::uint16_t;
> using ::uint32_t;
> using ::uint64_t;
>
> using ::uint_fast8_t;
> using ::uint_fast16_t;
> using ::uint_fast32_t;
> using ::uint_fast64_t;
>
> using ::uint_least8_t;
> using ::uint_least16_t;
> using ::uint_least32_t;
> using ::uint_least64_t;
>
> using ::uintmax_t;
> using ::uintptr_t;
>}
># 379 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/char_traits.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<>
> struct char_traits<char16_t>
> {
> typedef char16_t char_type;
> typedef uint_least16_t int_type;
> typedef streamoff off_type;
> typedef u16streampos pos_type;
> typedef mbstate_t state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> {
> for (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;
> }
>
> static size_t
> length(const char_type* __s)
> {
> size_t __i = 0;
> while (!eq(__s[__i], char_type()))
> ++__i;
> return __i;
> }
>
> static const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (eq(__s[__i], __a))
> return __s + __i;
> return 0;
> }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> {
> return (static_cast<char_type*>
> (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> {
> return (static_cast<char_type*>
> (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> assign(__s[__i], __a);
> return __s;
> }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return char_type(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return int_type(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
> template<>
> struct char_traits<char32_t>
> {
> typedef char32_t char_type;
> typedef uint_least32_t int_type;
> typedef streamoff off_type;
> typedef u32streampos pos_type;
> typedef mbstate_t state_type;
>
> static void
> assign(char_type& __c1, const char_type& __c2) noexcept
> { __c1 = __c2; }
>
> static constexpr bool
> eq(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr bool
> lt(const char_type& __c1, const char_type& __c2) noexcept
> { return __c1 < __c2; }
>
> static int
> compare(const char_type* __s1, const char_type* __s2, size_t __n)
> {
> for (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;
> }
>
> static size_t
> length(const char_type* __s)
> {
> size_t __i = 0;
> while (!eq(__s[__i], char_type()))
> ++__i;
> return __i;
> }
>
> static const char_type*
> find(const char_type* __s, size_t __n, const char_type& __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> if (eq(__s[__i], __a))
> return __s + __i;
> return 0;
> }
>
> static char_type*
> move(char_type* __s1, const char_type* __s2, size_t __n)
> {
> return (static_cast<char_type*>
> (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> copy(char_type* __s1, const char_type* __s2, size_t __n)
> {
> return (static_cast<char_type*>
> (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
> }
>
> static char_type*
> assign(char_type* __s, size_t __n, char_type __a)
> {
> for (size_t __i = 0; __i < __n; ++__i)
> assign(__s[__i], __a);
> return __s;
> }
>
> static constexpr char_type
> to_char_type(const int_type& __c) noexcept
> { return char_type(__c); }
>
> static constexpr int_type
> to_int_type(const char_type& __c) noexcept
> { return int_type(__c); }
>
> static constexpr bool
> eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
> { return __c1 == __c2; }
>
> static constexpr int_type
> eof() noexcept
> { return static_cast<int_type>(-1); }
>
> static constexpr int_type
> not_eof(const int_type& __c) noexcept
> { return eq_int_type(__c, eof()) ? 0 : __c; }
> };
>
>
>}
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/allocator.h" 1 3
># 48 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/allocator.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++allocator.h" 1 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++allocator.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/new_allocator.h" 1 3
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/new_allocator.h" 3
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
> using std::size_t;
> using std::ptrdiff_t;
># 53 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/new_allocator.h" 3
> template<typename _Tp>
> class new_allocator
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef const _Tp* const_pointer;
> typedef _Tp& reference;
> typedef const _Tp& const_reference;
> typedef _Tp value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef new_allocator<_Tp1> other; };
>
> new_allocator() noexcept { }
>
> new_allocator(const new_allocator&) noexcept { }
>
> template<typename _Tp1>
> new_allocator(const new_allocator<_Tp1>&) noexcept { }
>
> ~new_allocator() noexcept { }
>
> pointer
> address(reference __x) const noexcept
> { return std::__addressof(__x); }
>
> const_pointer
> address(const_reference __x) const noexcept
> { 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 noexcept
> { return size_t(-1) / sizeof(_Tp); }
>
>
> template<typename _Up, typename... _Args>
> void
> construct(_Up* __p, _Args&&... __args)
> { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
>
> template<typename _Up>
> void
> destroy(_Up* __p) { __p->~_Up(); }
># 125 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/new_allocator.h" 3
> };
>
> template<typename _Tp>
> inline bool
> operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
> { return true; }
>
> template<typename _Tp>
> inline bool
> operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
> { return false; }
>
>
>}
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++allocator.h" 2 3
># 49 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/allocator.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/allocator.h" 3
> template<typename _Tp>
> class allocator;
>
>
> template<>
> class allocator<void>
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef void* pointer;
> typedef const void* const_pointer;
> typedef void value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef allocator<_Tp1> other; };
> };
>
>
>
>
>
>
>
> template<typename _Tp>
> class allocator: public __gnu_cxx::new_allocator<_Tp>
> {
> public:
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Tp* pointer;
> typedef const _Tp* const_pointer;
> typedef _Tp& reference;
> typedef const _Tp& const_reference;
> typedef _Tp value_type;
>
> template<typename _Tp1>
> struct rebind
> { typedef allocator<_Tp1> other; };
>
> allocator() throw() { }
>
> allocator(const allocator& __a) throw()
> : __gnu_cxx::new_allocator<_Tp>(__a) { }
>
> template<typename _Tp1>
> allocator(const allocator<_Tp1>&) throw() { }
>
> ~allocator() throw() { }
>
>
> };
>
> template<typename _T1, typename _T2>
> inline bool
> operator==(const allocator<_T1>&, const allocator<_T2>&)
> { return true; }
>
> template<typename _Tp>
> inline bool
> operator==(const allocator<_Tp>&, const allocator<_Tp>&)
> { return true; }
>
> template<typename _T1, typename _T2>
> inline bool
> operator!=(const allocator<_T1>&, const allocator<_T2>&)
> { return false; }
>
> template<typename _Tp>
> inline bool
> operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
> { return false; }
># 144 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/allocator.h" 3
> extern template class allocator<char>;
> extern template class allocator<wchar_t>;
>
>
>
>
>
>
> template<typename _Alloc, bool = __is_empty(_Alloc)>
> struct __alloc_swap
> { static void _S_do_it(_Alloc&, _Alloc&) { } };
>
> template<typename _Alloc>
> struct __alloc_swap<_Alloc, false>
> {
> static void
> _S_do_it(_Alloc& __one, _Alloc& __two)
> {
>
> if (__one != __two)
> swap(__one, __two);
> }
> };
>
>
> template<typename _Alloc, bool = __is_empty(_Alloc)>
> struct __alloc_neq
> {
> static bool
> _S_do_it(const _Alloc&, const _Alloc&)
> { return false; }
> };
>
> template<typename _Alloc>
> struct __alloc_neq<_Alloc, false>
> {
> static bool
> _S_do_it(const _Alloc& __one, const _Alloc& __two)
> { return __one != __two; }
> };
>
>
> template<typename _Tp, bool
> = __or_<is_copy_constructible<typename _Tp::value_type>,
> is_nothrow_move_constructible<typename _Tp::value_type>>::value>
> struct __shrink_to_fit_aux
> { static bool _S_do_it(_Tp&) { return false; } };
>
> template<typename _Tp>
> struct __shrink_to_fit_aux<_Tp, true>
> {
> static bool
> _S_do_it(_Tp& __c)
> {
> try
> {
> _Tp(__make_move_if_noexcept_iterator(__c.begin()),
> __make_move_if_noexcept_iterator(__c.end()),
> __c.get_allocator()).swap(__c);
> return true;
> }
> catch(...)
> { return false; }
> }
> };
>
>
> template<typename, typename>
> struct uses_allocator;
>
>
>
>}
># 44 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 2 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/localefwd.h" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/localefwd.h" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/localefwd.h" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++locale.h" 1 3
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++locale.h" 3
> 
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/c++locale.h" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/clocale" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/clocale" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/clocale" 3
>
>
># 1 "/usr/include/locale.h" 1 3 4
># 29 "/usr/include/locale.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 30 "/usr/include/locale.h" 2 3 4
># 1 "/usr/include/bits/locale.h" 1 3 4
># 27 "/usr/include/bits/locale.h" 3 4
>enum
>{
> __LC_CTYPE = 0,
> __LC_NUMERIC = 1,
> __LC_TIME = 2,
> __LC_COLLATE = 3,
> __LC_MONETARY = 4,
> __LC_MESSAGES = 5,
> __LC_ALL = 6,
> __LC_PAPER = 7,
> __LC_NAME = 8,
> __LC_ADDRESS = 9,
> __LC_TELEPHONE = 10,
> __LC_MEASUREMENT = 11,
> __LC_IDENTIFICATION = 12
>};
># 31 "/usr/include/locale.h" 2 3 4
>
>extern "C" {
># 51 "/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;
># 121 "/usr/include/locale.h" 3 4
>};
>
>
>
>extern char *setlocale (int __category, __const char *__locale) throw ();
>
>
>extern struct lconv *localeconv (void) throw ();
>
>
># 152 "/usr/include/locale.h" 3 4
>extern __locale_t newlocale (int __category_mask, __const char *__locale,
> __locale_t __base) throw ();
># 187 "/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 ();
>
>
>
>
>
>
>
>}
># 45 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/clocale" 2 3
># 53 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/clocale" 3
>namespace std
>{
> using ::lconv;
> using ::setlocale;
> using ::localeconv;
>}
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/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);
># 89 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/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;
> }
>
>
>}
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/localefwd.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iosfwd" 1 3
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iosfwd" 3
> 
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iosfwd" 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 76 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iosfwd" 3
> class ios_base;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ios;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_streambuf;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_istream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ostream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_iostream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_stringbuf;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_istringstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_ostringstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT>,
> typename _Alloc = allocator<_CharT> >
> class basic_stringstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_filebuf;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ifstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_ofstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class basic_fstream;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class istreambuf_iterator;
>
> template<typename _CharT, typename _Traits = char_traits<_CharT> >
> class ostreambuf_iterator;
>
>
>
> typedef basic_ios<char> ios;
>
>
> typedef basic_streambuf<char> streambuf;
>
>
> typedef basic_istream<char> istream;
>
>
> typedef basic_ostream<char> ostream;
>
>
> typedef basic_iostream<char> iostream;
>
>
> typedef basic_stringbuf<char> stringbuf;
>
>
> typedef basic_istringstream<char> istringstream;
>
>
> typedef basic_ostringstream<char> ostringstream;
>
>
> typedef basic_stringstream<char> stringstream;
>
>
> typedef basic_filebuf<char> filebuf;
>
>
> typedef basic_ifstream<char> ifstream;
>
>
> typedef basic_ofstream<char> ofstream;
>
>
> typedef basic_fstream<char> fstream;
>
>
>
> typedef basic_ios<wchar_t> wios;
>
>
> typedef basic_streambuf<wchar_t> wstreambuf;
>
>
> typedef basic_istream<wchar_t> wistream;
>
>
> typedef basic_ostream<wchar_t> wostream;
>
>
> typedef basic_iostream<wchar_t> wiostream;
>
>
> typedef basic_stringbuf<wchar_t> wstringbuf;
>
>
> typedef basic_istringstream<wchar_t> wistringstream;
>
>
> typedef basic_ostringstream<wchar_t> wostringstream;
>
>
> typedef basic_stringstream<wchar_t> wstringstream;
>
>
> typedef basic_filebuf<wchar_t> wfilebuf;
>
>
> typedef basic_ifstream<wchar_t> wifstream;
>
>
> typedef basic_ofstream<wchar_t> wofstream;
>
>
> typedef basic_fstream<wchar_t> wfstream;
>
>
>
>
>}
># 44 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/localefwd.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cctype" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cctype" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cctype" 3
>
>
># 1 "/usr/include/ctype.h" 1 3 4
># 30 "/usr/include/ctype.h" 3 4
>extern "C" {
># 48 "/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))
>};
># 81 "/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));
># 106 "/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 ();
># 273 "/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 ();
># 349 "/usr/include/ctype.h" 3 4
>}
># 45 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cctype" 2 3
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
>}
>
>
>
>
>
>
>
>namespace std
>{
> using ::isblank;
>}
># 45 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/localefwd.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 57 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/localefwd.h" 3
> class locale;
>
> template<typename _Facet>
> bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> const _Facet&
> use_facet(const locale&);
>
>
> template<typename _CharT>
> bool
> isspace(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isprint(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> iscntrl(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isupper(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> islower(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isalpha(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isdigit(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> ispunct(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isxdigit(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isalnum(_CharT, const locale&);
>
> template<typename _CharT>
> bool
> isgraph(_CharT, const locale&);
>
> template<typename _CharT>
> _CharT
> toupper(_CharT, const locale&);
>
> template<typename _CharT>
> _CharT
> tolower(_CharT, const locale&);
>
>
> class ctype_base;
> template<typename _CharT>
> class ctype;
> template<> class ctype<char>;
>
> template<> class ctype<wchar_t>;
>
> template<typename _CharT>
> class ctype_byname;
>
>
> class codecvt_base;
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt;
> template<> class codecvt<char, char, mbstate_t>;
>
> template<> class codecvt<wchar_t, char, mbstate_t>;
>
> template<typename _InternT, typename _ExternT, typename _StateT>
> class codecvt_byname;
>
>
>
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class num_get;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class num_put;
>
> template<typename _CharT> class numpunct;
> template<typename _CharT> class numpunct_byname;
>
>
> template<typename _CharT>
> class collate;
> template<typename _CharT> class
> collate_byname;
>
>
> class time_base;
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class time_get;
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class time_get_byname;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class time_put;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class time_put_byname;
>
>
> class money_base;
>
> template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
> class money_get;
> template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
> class money_put;
>
> template<typename _CharT, bool _Intl = false>
> class moneypunct;
> template<typename _CharT, bool _Intl = false>
> class moneypunct_byname;
>
>
> class messages_base;
> template<typename _CharT>
> class messages;
> template<typename _CharT>
> class messages_byname;
>
>
>}
># 46 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ostream_insert.h" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ostream_insert.h" 3
> 
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ostream_insert.h" 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/cxxabi_forced.h" 1 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/cxxabi_forced.h" 3
> 
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ostream_insert.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> inline void
> __ostream_write(basic_ostream<_CharT, _Traits>& __out,
> const _CharT* __s, streamsize __n)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const streamsize __put = __out.rdbuf()->sputn(__s, __n);
> if (__put != __n)
> __out.setstate(__ios_base::badbit);
> }
>
> template<typename _CharT, typename _Traits>
> inline void
> __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const _CharT __c = __out.fill();
> for (; __n > 0; --__n)
> {
> const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
> if (_Traits::eq_int_type(__put, _Traits::eof()))
> {
> __out.setstate(__ios_base::badbit);
> break;
> }
> }
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
> const _CharT* __s, streamsize __n)
> {
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> typename __ostream_type::sentry __cerb(__out);
> if (__cerb)
> {
> try
> {
> const streamsize __w = __out.width();
> if (__w > __n)
> {
> const bool __left = ((__out.flags()
> & __ios_base::adjustfield)
> == __ios_base::left);
> if (!__left)
> __ostream_fill(__out, __w - __n);
> if (__out.good())
> __ostream_write(__out, __s, __n);
> if (__left && __out.good())
> __ostream_fill(__out, __w - __n);
> }
> else
> __ostream_write(__out, __s, __n);
> __out.width(0);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __out._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> { __out._M_setstate(__ios_base::badbit); }
> }
> return __out;
> }
>
>
>
>
> extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
>
>
> extern template wostream& __ostream_insert(wostream&, const wchar_t*,
> streamsize);
>
>
>
>
>}
># 47 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 2 3
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 1 3
># 61 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 102 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 3
> template<typename _Arg, typename _Result>
> struct unary_function
> {
>
> typedef _Arg argument_type;
>
>
> typedef _Result result_type;
> };
>
>
>
>
> template<typename _Arg1, typename _Arg2, typename _Result>
> struct binary_function
> {
>
> typedef _Arg1 first_argument_type;
>
>
> typedef _Arg2 second_argument_type;
>
>
> typedef _Result result_type;
> };
># 141 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 3
> template<typename _Tp>
> struct plus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x + __y; }
> };
>
>
> template<typename _Tp>
> struct minus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x - __y; }
> };
>
>
> template<typename _Tp>
> struct multiplies : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x * __y; }
> };
>
>
> template<typename _Tp>
> struct divides : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x / __y; }
> };
>
>
> template<typename _Tp>
> struct modulus : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x % __y; }
> };
>
>
> template<typename _Tp>
> struct negate : public unary_function<_Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x) const
> { return -__x; }
> };
># 205 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 3
> template<typename _Tp>
> struct equal_to : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x == __y; }
> };
>
>
> template<typename _Tp>
> struct not_equal_to : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x != __y; }
> };
>
>
> template<typename _Tp>
> struct greater : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x > __y; }
> };
>
>
> template<typename _Tp>
> struct less : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x < __y; }
> };
>
>
> template<typename _Tp>
> struct greater_equal : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x >= __y; }
> };
>
>
> template<typename _Tp>
> struct less_equal : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x <= __y; }
> };
># 269 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 3
> template<typename _Tp>
> struct logical_and : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x && __y; }
> };
>
>
> template<typename _Tp>
> struct logical_or : public binary_function<_Tp, _Tp, bool>
> {
> bool
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x || __y; }
> };
>
>
> template<typename _Tp>
> struct logical_not : public unary_function<_Tp, bool>
> {
> bool
> operator()(const _Tp& __x) const
> { return !__x; }
> };
>
>
>
>
> template<typename _Tp>
> struct bit_and : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x & __y; }
> };
>
> template<typename _Tp>
> struct bit_or : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x | __y; }
> };
>
> template<typename _Tp>
> struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
> {
> _Tp
> operator()(const _Tp& __x, const _Tp& __y) const
> { return __x ^ __y; }
> };
># 352 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 3
> template<typename _Predicate>
> class unary_negate
> : public unary_function<typename _Predicate::argument_type, bool>
> {
> protected:
> _Predicate _M_pred;
>
> public:
> explicit
> unary_negate(const _Predicate& __x) : _M_pred(__x) { }
>
> bool
> operator()(const typename _Predicate::argument_type& __x) const
> { return !_M_pred(__x); }
> };
>
>
> template<typename _Predicate>
> inline unary_negate<_Predicate>
> not1(const _Predicate& __pred)
> { return unary_negate<_Predicate>(__pred); }
>
>
> template<typename _Predicate>
> class binary_negate
> : public binary_function<typename _Predicate::first_argument_type,
> typename _Predicate::second_argument_type, bool>
> {
> protected:
> _Predicate _M_pred;
>
> public:
> explicit
> binary_negate(const _Predicate& __x) : _M_pred(__x) { }
>
> bool
> operator()(const typename _Predicate::first_argument_type& __x,
> const typename _Predicate::second_argument_type& __y) const
> { return !_M_pred(__x, __y); }
> };
>
>
> template<typename _Predicate>
> inline binary_negate<_Predicate>
> not2(const _Predicate& __pred)
> { return binary_negate<_Predicate>(__pred); }
># 423 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 3
> template<typename _Arg, typename _Result>
> class pointer_to_unary_function : public unary_function<_Arg, _Result>
> {
> protected:
> _Result (*_M_ptr)(_Arg);
>
> public:
> pointer_to_unary_function() { }
>
> explicit
> pointer_to_unary_function(_Result (*__x)(_Arg))
> : _M_ptr(__x) { }
>
> _Result
> operator()(_Arg __x) const
> { return _M_ptr(__x); }
> };
>
>
> template<typename _Arg, typename _Result>
> inline pointer_to_unary_function<_Arg, _Result>
> ptr_fun(_Result (*__x)(_Arg))
> { return pointer_to_unary_function<_Arg, _Result>(__x); }
>
>
> template<typename _Arg1, typename _Arg2, typename _Result>
> class pointer_to_binary_function
> : public binary_function<_Arg1, _Arg2, _Result>
> {
> protected:
> _Result (*_M_ptr)(_Arg1, _Arg2);
>
> public:
> pointer_to_binary_function() { }
>
> explicit
> pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
> : _M_ptr(__x) { }
>
> _Result
> operator()(_Arg1 __x, _Arg2 __y) const
> { return _M_ptr(__x, __y); }
> };
>
>
> template<typename _Arg1, typename _Arg2, typename _Result>
> inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
> ptr_fun(_Result (*__x)(_Arg1, _Arg2))
> { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
>
>
> template<typename _Tp>
> struct _Identity
>
>
>
>
>
> {
> _Tp&
> operator()(_Tp& __x) const
> { return __x; }
>
> const _Tp&
> operator()(const _Tp& __x) const
> { return __x; }
> };
>
> template<typename _Pair>
> struct _Select1st
>
>
>
> {
> typename _Pair::first_type&
> operator()(_Pair& __x) const
> { return __x.first; }
>
> const typename _Pair::first_type&
> operator()(const _Pair& __x) const
> { return __x.first; }
>
>
> template<typename _Pair2>
> typename _Pair2::first_type&
> operator()(_Pair2& __x) const
> { return __x.first; }
>
> template<typename _Pair2>
> const typename _Pair2::first_type&
> operator()(const _Pair2& __x) const
> { return __x.first; }
>
> };
>
> template<typename _Pair>
> struct _Select2nd
>
>
>
> {
> typename _Pair::second_type&
> operator()(_Pair& __x) const
> { return __x.second; }
>
> const typename _Pair::second_type&
> operator()(const _Pair& __x) const
> { return __x.second; }
> };
># 551 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 3
> template<typename _Ret, typename _Tp>
> class mem_fun_t : public unary_function<_Tp*, _Ret>
> {
> public:
> explicit
> mem_fun_t(_Ret (_Tp::*__pf)())
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp* __p) const
> { return (__p->*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)();
> };
>
>
>
> template<typename _Ret, typename _Tp>
> class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
> {
> public:
> explicit
> const_mem_fun_t(_Ret (_Tp::*__pf)() const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp* __p) const
> { return (__p->*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)() const;
> };
>
>
>
> template<typename _Ret, typename _Tp>
> class mem_fun_ref_t : public unary_function<_Tp, _Ret>
> {
> public:
> explicit
> mem_fun_ref_t(_Ret (_Tp::*__pf)())
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp& __r) const
> { return (__r.*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)();
> };
>
>
>
> template<typename _Ret, typename _Tp>
> class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
> {
> public:
> explicit
> const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp& __r) const
> { return (__r.*_M_f)(); }
>
> private:
> _Ret (_Tp::*_M_f)() const;
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
> {
> public:
> explicit
> mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp* __p, _Arg __x) const
> { return (__p->*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg);
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
> {
> public:
> explicit
> const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp* __p, _Arg __x) const
> { return (__p->*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg) const;
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
> {
> public:
> explicit
> mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
> : _M_f(__pf) { }
>
> _Ret
> operator()(_Tp& __r, _Arg __x) const
> { return (__r.*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg);
> };
>
>
>
> template<typename _Ret, typename _Tp, typename _Arg>
> class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
> {
> public:
> explicit
> const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
> : _M_f(__pf) { }
>
> _Ret
> operator()(const _Tp& __r, _Arg __x) const
> { return (__r.*_M_f)(__x); }
>
> private:
> _Ret (_Tp::*_M_f)(_Arg) const;
> };
>
>
>
> template<typename _Ret, typename _Tp>
> inline mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)())
> { return mem_fun_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp>
> inline const_mem_fun_t<_Ret, _Tp>
> mem_fun(_Ret (_Tp::*__f)() const)
> { return const_mem_fun_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp>
> inline mem_fun_ref_t<_Ret, _Tp>
> mem_fun_ref(_Ret (_Tp::*__f)())
> { return mem_fun_ref_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp>
> inline const_mem_fun_ref_t<_Ret, _Tp>
> mem_fun_ref(_Ret (_Tp::*__f)() const)
> { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline mem_fun1_t<_Ret, _Tp, _Arg>
> mem_fun(_Ret (_Tp::*__f)(_Arg))
> { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline const_mem_fun1_t<_Ret, _Tp, _Arg>
> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
> { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
> { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
> template<typename _Ret, typename _Tp, typename _Arg>
> inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
> mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
> { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
>
>
>
>
>}
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/backward/binders.h" 1 3
># 60 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/backward/binders.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 104 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/backward/binders.h" 3
> template<typename _Operation>
> class binder1st
> : public unary_function<typename _Operation::second_argument_type,
> typename _Operation::result_type>
> {
> protected:
> _Operation op;
> typename _Operation::first_argument_type value;
>
> public:
> binder1st(const _Operation& __x,
> const typename _Operation::first_argument_type& __y)
> : op(__x), value(__y) { }
>
> typename _Operation::result_type
> operator()(const typename _Operation::second_argument_type& __x) const
> { return op(value, __x); }
>
>
>
> typename _Operation::result_type
> operator()(typename _Operation::second_argument_type& __x) const
> { return op(value, __x); }
> } __attribute__ ((__deprecated__));
>
>
> template<typename _Operation, typename _Tp>
> inline binder1st<_Operation>
> bind1st(const _Operation& __fn, const _Tp& __x)
> {
> typedef typename _Operation::first_argument_type _Arg1_type;
> return binder1st<_Operation>(__fn, _Arg1_type(__x));
> }
>
>
> template<typename _Operation>
> class binder2nd
> : public unary_function<typename _Operation::first_argument_type,
> typename _Operation::result_type>
> {
> protected:
> _Operation op;
> typename _Operation::second_argument_type value;
>
> public:
> binder2nd(const _Operation& __x,
> const typename _Operation::second_argument_type& __y)
> : op(__x), value(__y) { }
>
> typename _Operation::result_type
> operator()(const typename _Operation::first_argument_type& __x) const
> { return op(__x, value); }
>
>
>
> typename _Operation::result_type
> operator()(typename _Operation::first_argument_type& __x) const
> { return op(__x, value); }
> } __attribute__ ((__deprecated__));
>
>
> template<typename _Operation, typename _Tp>
> inline binder2nd<_Operation>
> bind2nd(const _Operation& __fn, const _Tp& __x)
> {
> typedef typename _Operation::second_argument_type _Arg2_type;
> return binder2nd<_Operation>(__fn, _Arg2_type(__x));
> }
>
>
>
>}
># 742 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_function.h" 2 3
># 51 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 2 3
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/range_access.h" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/range_access.h" 3
> 
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/range_access.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> template<class _Container>
> inline auto
> begin(_Container& __cont) -> decltype(__cont.begin())
> { return __cont.begin(); }
>
>
>
>
>
>
> template<class _Container>
> inline auto
> begin(const _Container& __cont) -> decltype(__cont.begin())
> { return __cont.begin(); }
>
>
>
>
>
>
> template<class _Container>
> inline auto
> end(_Container& __cont) -> decltype(__cont.end())
> { return __cont.end(); }
>
>
>
>
>
>
> template<class _Container>
> inline auto
> end(const _Container& __cont) -> decltype(__cont.end())
> { return __cont.end(); }
>
>
>
>
>
> template<class _Tp, size_t _Nm>
> inline _Tp*
> begin(_Tp (&__arr)[_Nm])
> { return __arr; }
>
>
>
>
>
>
> template<class _Tp, size_t _Nm>
> inline _Tp*
> end(_Tp (&__arr)[_Nm])
> { return __arr + _Nm; }
>
>
>}
># 54 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/atomicity.h" 1 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/atomicity.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/gthr.h" 1 3
># 31 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/gthr.h" 3
>#pragma GCC visibility push(default)
># 150 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/gthr.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/gthr-default.h" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/gthr-default.h" 3
># 1 "/usr/include/pthread.h" 1 3 4
># 25 "/usr/include/pthread.h" 3 4
># 1 "/usr/include/sched.h" 1 3 4
># 30 "/usr/include/sched.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 31 "/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
># 74 "/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;
> };
># 120 "/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;
># 203 "/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 ();
>
>
>}
># 26 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/time.h" 1 3 4
># 30 "/usr/include/time.h" 3 4
>extern "C" {
>
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 39 "/usr/include/time.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/time.h" 1 3 4
># 86 "/usr/include/bits/time.h" 3 4
># 1 "/usr/include/bits/timex.h" 1 3 4
># 24 "/usr/include/bits/timex.h" 3 4
>struct timex
>{
> unsigned int modes;
> long int offset;
> long int freq;
> long int maxerror;
> long int esterror;
> int status;
> long int constant;
> long int precision;
> long int tolerance;
> struct timeval time;
> long int tick;
>
> long int ppsfreq;
> long int jitter;
> int shift;
> long int stabil;
> long int jitcnt;
> long int calcnt;
> long int errcnt;
> long int 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;
>};
># 87 "/usr/include/bits/time.h" 2 3 4
>
>extern "C" {
>
>
>extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
>
>}
># 43 "/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;
># 180 "/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 ();
># 313 "/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__));
># 328 "/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 ();
># 390 "/usr/include/time.h" 3 4
>extern int getdate_err;
># 399 "/usr/include/time.h" 3 4
>extern struct tm *getdate (__const char *__string);
># 413 "/usr/include/time.h" 3 4
>extern int getdate_r (__const char *__restrict __string,
> struct tm *__restrict __resbufp);
>
>
>}
># 27 "/usr/include/pthread.h" 2 3 4
>
>
># 1 "/usr/include/bits/setjmp.h" 1 3 4
># 27 "/usr/include/bits/setjmp.h" 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 28 "/usr/include/bits/setjmp.h" 2 3 4
>
>
>
>
>typedef long int __jmp_buf[8];
># 30 "/usr/include/pthread.h" 2 3 4
># 1 "/usr/include/bits/wordsize.h" 1 3 4
># 31 "/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
>};
># 115 "/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
>};
># 147 "/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
>
>};
># 182 "/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
>
>};
># 220 "/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 ();
>
>
>
>
>
>
>
>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_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)));
># 478 "/usr/include/pthread.h" 3 4
>extern int pthread_once (pthread_once_t *__once_control,
> void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
># 490 "/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__));
># 524 "/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); }
>};
># 726 "/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)));
># 790 "/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)));
># 872 "/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)));
># 984 "/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)));
># 1028 "/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)));
># 1095 "/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)));
># 1129 "/usr/include/pthread.h" 3 4
>extern int pthread_atfork (void (*__prepare) (void),
> void (*__parent) (void),
> void (*__child) (void)) throw ();
>
>
>
>
>extern __inline __attribute__ ((__gnu_inline__)) int
>__attribute__ ((__leaf__)) pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
>{
> return __thread1 == __thread2;
>}
>
>
>}
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/gthr-default.h" 2 3
># 53 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/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;
># 140 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/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")));
># 258 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/gthr-default.h" 3
>static inline int
>__gthread_active_p (void)
>{
>
>
>
> static void *const __gthread_active_ptr
> = __extension__ (void *) &__gthrw_pthread_cancel;
>
>
>
>
> return __gthread_active_ptr != 0;
>}
># 677 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/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);
>}
># 756 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/gthr-default.h" 3
>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;
>}
># 828 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/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);
>}
># 864 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/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_timedwait_recursive (__gthread_cond_t *__cond,
> __gthread_recursive_mutex_t *__mutex,
> const __gthread_time_t *__abs_timeout)
>{
> return __gthread_cond_timedwait (__cond, __mutex, __abs_timeout);
>}
>
>static inline int
>__gthread_cond_destroy (__gthread_cond_t* __cond)
>{
> return __gthrw_pthread_cond_destroy (__cond);
>}
># 151 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/gthr.h" 2 3
>
>
>#pragma GCC visibility pop
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/atomicity.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/atomic_word.h" 1 3
># 32 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/atomic_word.h" 3
>typedef int _Atomic_word;
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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);
>
>
>
> }
>
>
>}
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 2 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 108 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> class basic_string
> {
> typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
>
>
> public:
> typedef _Traits traits_type;
> typedef typename _Traits::char_type value_type;
> typedef _Alloc allocator_type;
> typedef typename _CharT_alloc_type::size_type size_type;
> typedef typename _CharT_alloc_type::difference_type difference_type;
> typedef typename _CharT_alloc_type::reference reference;
> typedef typename _CharT_alloc_type::const_reference const_reference;
> typedef typename _CharT_alloc_type::pointer pointer;
> typedef typename _CharT_alloc_type::const_pointer const_pointer;
> typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
> typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
> const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
>
> private:
># 145 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> struct _Rep_base
> {
> size_type _M_length;
> size_type _M_capacity;
> _Atomic_word _M_refcount;
> };
>
> struct _Rep : _Rep_base
> {
>
> typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
># 170 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> static const size_type _S_max_size;
> static const _CharT _S_terminal;
>
>
>
> static size_type _S_empty_rep_storage[];
>
> static _Rep&
> _S_empty_rep()
> {
>
>
>
> void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
> return *reinterpret_cast<_Rep*>(__p);
> }
>
> bool
> _M_is_leaked() const
> { return this->_M_refcount < 0; }
>
> bool
> _M_is_shared() const
> { return this->_M_refcount > 0; }
>
> void
> _M_set_leaked()
> { this->_M_refcount = -1; }
>
> void
> _M_set_sharable()
> { this->_M_refcount = 0; }
>
> void
> _M_set_length_and_sharable(size_type __n)
> {
>
> if (__builtin_expect(this != &_S_empty_rep(), false))
>
> {
> this->_M_set_sharable();
> this->_M_length = __n;
> traits_type::assign(this->_M_refdata()[__n], _S_terminal);
>
>
> }
> }
>
> _CharT*
> _M_refdata() throw()
> { return reinterpret_cast<_CharT*>(this + 1); }
>
> _CharT*
> _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
> {
> return (!_M_is_leaked() && __alloc1 == __alloc2)
> ? _M_refcopy() : _M_clone(__alloc1);
> }
>
>
> static _Rep*
> _S_create(size_type, size_type, const _Alloc&);
>
> void
> _M_dispose(const _Alloc& __a)
> {
>
> if (__builtin_expect(this != &_S_empty_rep(), false))
>
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
> -1) <= 0)
> {
> ;
> _M_destroy(__a);
> }
> }
> }
>
> void
> _M_destroy(const _Alloc&) throw();
>
> _CharT*
> _M_refcopy() throw()
> {
>
> if (__builtin_expect(this != &_S_empty_rep(), false))
>
> __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
> return _M_refdata();
> }
>
> _CharT*
> _M_clone(const _Alloc&, size_type __res = 0);
> };
>
>
> struct _Alloc_hider : _Alloc
> {
> _Alloc_hider(_CharT* __dat, const _Alloc& __a)
> : _Alloc(__a), _M_p(__dat) { }
>
> _CharT* _M_p;
> };
>
> public:
>
>
>
>
> static const size_type npos = static_cast<size_type>(-1);
>
> private:
>
> mutable _Alloc_hider _M_dataplus;
>
> _CharT*
> _M_data() const
> { return _M_dataplus._M_p; }
>
> _CharT*
> _M_data(_CharT* __p)
> { return (_M_dataplus._M_p = __p); }
>
> _Rep*
> _M_rep() const
> { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
>
>
>
> iterator
> _M_ibegin() const
> { return iterator(_M_data()); }
>
> iterator
> _M_iend() const
> { return iterator(_M_data() + this->size()); }
>
> void
> _M_leak()
> {
> if (!_M_rep()->_M_is_leaked())
> _M_leak_hard();
> }
>
> size_type
> _M_check(size_type __pos, const char* __s) const
> {
> if (__pos > this->size())
> __throw_out_of_range((__s));
> return __pos;
> }
>
> void
> _M_check_length(size_type __n1, size_type __n2, const char* __s) const
> {
> if (this->max_size() - (this->size() - __n1) < __n2)
> __throw_length_error((__s));
> }
>
>
> size_type
> _M_limit(size_type __pos, size_type __off) const
> {
> const bool __testoff = __off < this->size() - __pos;
> return __testoff ? __off : this->size() - __pos;
> }
>
>
> bool
> _M_disjunct(const _CharT* __s) const
> {
> return (less<const _CharT*>()(__s, _M_data())
> || less<const _CharT*>()(_M_data() + this->size(), __s));
> }
>
>
>
> static void
> _M_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
> _M_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
> _M_assign(_CharT* __d, size_type __n, _CharT __c)
> {
> if (__n == 1)
> traits_type::assign(*__d, __c);
> else
> traits_type::assign(__d, __n, __c);
> }
>
>
>
> template<class _Iterator>
> static void
> _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
> {
> for (; __k1 != __k2; ++__k1, ++__p)
> traits_type::assign(*__p, *__k1);
> }
>
> static void
> _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
> { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
> static void
> _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
> { _S_copy_chars(__p, __k1.base(), __k2.base()); }
>
> static void
> _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
> { _M_copy(__p, __k1, __k2 - __k1); }
>
> static void
> _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
> { _M_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<int>::__max)
> return __gnu_cxx::__numeric_traits<int>::__max;
> else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
> return __gnu_cxx::__numeric_traits<int>::__min;
> else
> return int(__d);
> }
>
> void
> _M_mutate(size_type __pos, size_type __len1, size_type __len2);
>
> void
> _M_leak_hard();
>
> static _Rep&
> _S_empty_rep()
> { return _Rep::_S_empty_rep(); }
>
> public:
>
>
>
>
>
>
>
> basic_string()
>
> : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
>
>
>
>
>
>
>
> explicit
> basic_string(const _Alloc& __a);
>
>
>
>
>
>
> basic_string(const basic_string& __str);
>
>
>
>
>
>
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n = npos);
>
>
>
>
>
>
>
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n, const _Alloc& __a);
># 480 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string(const _CharT* __s, size_type __n,
> const _Alloc& __a = _Alloc());
>
>
>
>
>
> basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
>
>
>
>
>
>
> basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
># 504 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string(basic_string&& __str) noexcept
> : _M_dataplus(__str._M_dataplus)
> {
>
> __str._M_data(_S_empty_rep()._M_refdata());
>
>
>
> }
>
>
>
>
>
>
> basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc());
># 528 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string(_InputIterator __beg, _InputIterator __end,
> const _Alloc& __a = _Alloc());
>
>
>
>
> ~basic_string() noexcept
> { _M_rep()->_M_dispose(this->get_allocator()); }
>
>
>
>
>
> basic_string&
> operator=(const basic_string& __str)
> { return this->assign(__str); }
>
>
>
>
>
> basic_string&
> operator=(const _CharT* __s)
> { return this->assign(__s); }
># 561 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> operator=(_CharT __c)
> {
> this->assign(1, __c);
> return *this;
> }
># 576 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> operator=(basic_string&& __str)
> {
>
> this->swap(__str);
> return *this;
> }
>
>
>
>
>
> basic_string&
> operator=(initializer_list<_CharT> __l)
> {
> this->assign(__l.begin(), __l.size());
> return *this;
> }
>
>
>
>
>
>
>
> iterator
> begin() noexcept
> {
> _M_leak();
> return iterator(_M_data());
> }
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return const_iterator(_M_data()); }
>
>
>
>
>
> iterator
> end() noexcept
> {
> _M_leak();
> return iterator(_M_data() + this->size());
> }
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return const_iterator(_M_data() + this->size()); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(this->end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(this->begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(this->_M_data()); }
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return const_iterator(this->_M_data() + this->size()); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(this->end()); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(this->begin()); }
>
>
> public:
>
>
>
> size_type
> size() const noexcept
> { return _M_rep()->_M_length; }
>
>
>
> size_type
> length() const noexcept
> { return _M_rep()->_M_length; }
>
>
> size_type
> max_size() const noexcept
> { return _Rep::_S_max_size; }
># 736 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> void
> resize(size_type __n, _CharT __c);
># 749 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> void
> resize(size_type __n)
> { this->resize(__n, _CharT()); }
>
>
>
> void
> shrink_to_fit()
> {
> if (capacity() > size())
> {
> try
> { reserve(0); }
> catch(...)
> { }
> }
> }
>
>
>
>
>
>
> size_type
> capacity() const noexcept
> { return _M_rep()->_M_capacity; }
># 793 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> void
> reserve(size_type __res_arg = 0);
>
>
>
>
> void
> clear() noexcept
> { _M_mutate(0, this->size(), 0); }
>
>
>
>
>
> bool
> empty() const noexcept
> { return this->size() == 0; }
># 822 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> const_reference
> operator[] (size_type __pos) const
> {
> ;
> return _M_data()[__pos];
> }
># 839 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> reference
> operator[](size_type __pos)
> {
>
> ;
>
> ;
> _M_leak();
> return _M_data()[__pos];
> }
># 860 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> const_reference
> at(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("basic_string::at"));
> return _M_data()[__n];
> }
># 879 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> reference
> at(size_type __n)
> {
> if (__n >= size())
> __throw_out_of_range(("basic_string::at"));
> _M_leak();
> return _M_data()[__n];
> }
>
>
>
>
>
>
> reference
> front()
> { return operator[](0); }
>
>
>
>
>
> const_reference
> front() const
> { return operator[](0); }
>
>
>
>
>
> reference
> back()
> { return operator[](this->size() - 1); }
>
>
>
>
>
> const_reference
> back() const
> { return operator[](this->size() - 1); }
># 928 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
>
>
>
>
>
>
>
> basic_string&
> operator+=(initializer_list<_CharT> __l)
> { return this->append(__l.begin(), __l.size()); }
>
>
>
>
>
>
>
> basic_string&
> append(const basic_string& __str);
># 985 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> append(const basic_string& __str, size_type __pos, size_type __n);
>
>
>
>
>
>
>
> basic_string&
> append(const _CharT* __s, size_type __n);
>
>
>
>
>
>
> basic_string&
> append(const _CharT* __s)
> {
> ;
> return this->append(__s, traits_type::length(__s));
> }
># 1017 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> append(size_type __n, _CharT __c);
>
>
>
>
>
>
>
> basic_string&
> append(initializer_list<_CharT> __l)
> { return this->append(__l.begin(), __l.size()); }
># 1039 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> append(_InputIterator __first, _InputIterator __last)
> { return this->replace(_M_iend(), _M_iend(), __first, __last); }
>
>
>
>
>
> void
> push_back(_CharT __c)
> {
> const size_type __len = 1 + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> traits_type::assign(_M_data()[this->size()], __c);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
>
>
>
>
>
>
> basic_string&
> assign(const basic_string& __str);
># 1075 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> assign(basic_string&& __str)
> {
> this->swap(__str);
> return *this;
> }
># 1096 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> assign(const basic_string& __str, size_type __pos, size_type __n)
> { return this->assign(__str._M_data()
> + __str._M_check(__pos, "basic_string::assign"),
> __str._M_limit(__pos, __n)); }
># 1112 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s, size_type __n);
># 1124 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> assign(const _CharT* __s)
> {
> ;
> return this->assign(__s, traits_type::length(__s));
> }
># 1140 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> assign(size_type __n, _CharT __c)
> { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
># 1152 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> assign(_InputIterator __first, _InputIterator __last)
> { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
>
>
>
>
>
>
>
> basic_string&
> assign(initializer_list<_CharT> __l)
> { return this->assign(__l.begin(), __l.size()); }
># 1181 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> void
> insert(iterator __p, size_type __n, _CharT __c)
> { this->replace(__p, __p, __n, __c); }
># 1197 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<class _InputIterator>
> void
> insert(iterator __p, _InputIterator __beg, _InputIterator __end)
> { this->replace(__p, __p, __beg, __end); }
># 1209 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> void
> insert(iterator __p, initializer_list<_CharT> __l)
> {
> ;
> this->insert(__p - _M_ibegin(), __l.begin(), __l.size());
> }
># 1229 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos1, const basic_string& __str)
> { return this->insert(__pos1, __str, size_type(0), __str.size()); }
># 1251 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos1, const basic_string& __str,
> size_type __pos2, size_type __n)
> { return this->insert(__pos1, __str._M_data()
> + __str._M_check(__pos2, "basic_string::insert"),
> __str._M_limit(__pos2, __n)); }
># 1274 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s, size_type __n);
># 1292 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> insert(size_type __pos, const _CharT* __s)
> {
> ;
> return this->insert(__pos, __s, traits_type::length(__s));
> }
># 1315 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 1333 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> iterator
> insert(iterator __p, _CharT __c)
> {
> ;
> const size_type __pos = __p - _M_ibegin();
> _M_replace_aux(__pos, size_type(0), size_type(1), __c);
> _M_rep()->_M_set_leaked();
> return iterator(_M_data() + __pos);
> }
># 1358 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> erase(size_type __pos = 0, size_type __n = npos)
> {
> _M_mutate(_M_check(__pos, "basic_string::erase"),
> _M_limit(__pos, __n), size_type(0));
> return *this;
> }
># 1374 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> iterator
> erase(iterator __position)
> {
>
> ;
> const size_type __pos = __position - _M_ibegin();
> _M_mutate(__pos, size_type(1), size_type(0));
> _M_rep()->_M_set_leaked();
> return iterator(_M_data() + __pos);
> }
># 1394 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> iterator
> erase(iterator __first, iterator __last);
>
>
>
>
>
>
>
> void
> pop_back()
> { erase(size()-1, 1); }
># 1425 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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()); }
># 1447 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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)); }
># 1472 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> replace(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2);
># 1492 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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));
> }
># 1516 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 1534 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, const basic_string& __str)
> { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
># 1553 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
> {
>
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
> }
># 1574 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, const _CharT* __s)
> {
> ;
> return this->replace(__i1, __i2, __s, traits_type::length(__s));
> }
># 1595 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string&
> replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
> {
>
> ;
> return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
> }
># 1618 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<class _InputIterator>
> basic_string&
> replace(iterator __i1, iterator __i2,
> _InputIterator __k1, _InputIterator __k2)
> {
> 
> ;
> ;
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
> }
>
>
>
> basic_string&
> replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1, __k2 - __k1);
> }
>
> basic_string&
> replace(iterator __i1, iterator __i2,
> const _CharT* __k1, const _CharT* __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1, __k2 - __k1);
> }
>
> basic_string&
> replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1.base(), __k2 - __k1);
> }
>
> basic_string&
> replace(iterator __i1, iterator __i2,
> const_iterator __k1, const_iterator __k2)
> {
>
> ;
> ;
> return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
> __k1.base(), __k2 - __k1);
> }
># 1689 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> basic_string& replace(iterator __i1, iterator __i2,
> initializer_list<_CharT> __l)
> { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
>
>
> private:
> template<class _Integer>
> basic_string&
> _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
> _Integer __val, __true_type)
> { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
>
> template<class _InputIterator>
> basic_string&
> _M_replace_dispatch(iterator __i1, 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_safe(size_type __pos1, size_type __n1, const _CharT* __s,
> size_type __n2);
>
>
>
> template<class _InIterator>
> static _CharT*
> _S_construct_aux(_InIterator __beg, _InIterator __end,
> const _Alloc& __a, __false_type)
> {
> typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
> return _S_construct(__beg, __end, __a, _Tag());
> }
>
>
>
> template<class _Integer>
> static _CharT*
> _S_construct_aux(_Integer __beg, _Integer __end,
> const _Alloc& __a, __true_type)
> { return _S_construct_aux_2(static_cast<size_type>(__beg),
> __end, __a); }
>
> static _CharT*
> _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
> { return _S_construct(__req, __c, __a); }
>
> template<class _InIterator>
> static _CharT*
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
> {
> typedef typename std::__is_integer<_InIterator>::__type _Integral;
> return _S_construct_aux(__beg, __end, __a, _Integral());
> }
>
>
> template<class _InIterator>
> static _CharT*
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
> input_iterator_tag);
>
>
>
> template<class _FwdIterator>
> static _CharT*
> _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
> forward_iterator_tag);
>
> static _CharT*
> _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
>
> public:
># 1776 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
># 1786 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> void
> swap(basic_string& __s);
># 1796 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> const _CharT*
> c_str() const noexcept
> { return _M_data(); }
>
>
>
>
>
>
>
> const _CharT*
> data() const noexcept
> { return _M_data(); }
>
>
>
>
> allocator_type
> get_allocator() const noexcept
> { return _M_dataplus; }
># 1829 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find(const _CharT* __s, size_type __pos, size_type __n) const;
># 1842 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find(const basic_string& __str, size_type __pos = 0) const
> noexcept
> { return this->find(__str.data(), __pos, __str.size()); }
># 1857 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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));
> }
># 1874 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find(_CharT __c, size_type __pos = 0) const noexcept;
># 1887 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> rfind(const basic_string& __str, size_type __pos = npos) const
> noexcept
> { return this->rfind(__str.data(), __pos, __str.size()); }
># 1904 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> rfind(const _CharT* __s, size_type __pos, size_type __n) const;
># 1917 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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));
> }
># 1934 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> rfind(_CharT __c, size_type __pos = npos) const noexcept;
># 1948 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_first_of(const basic_string& __str, size_type __pos = 0) const
> noexcept
> { return this->find_first_of(__str.data(), __pos, __str.size()); }
># 1965 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 1978 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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));
> }
># 1997 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_first_of(_CharT __c, size_type __pos = 0) const noexcept
> { return this->find(__c, __pos); }
># 2012 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_last_of(const basic_string& __str, size_type __pos = npos) const
> noexcept
> { return this->find_last_of(__str.data(), __pos, __str.size()); }
># 2029 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
># 2042 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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));
> }
># 2061 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_last_of(_CharT __c, size_type __pos = npos) const noexcept
> { return this->rfind(__c, __pos); }
># 2075 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_first_not_of(const basic_string& __str, size_type __pos = 0) const
> noexcept
> { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
># 2092 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_first_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const;
># 2106 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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));
> }
># 2123 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_first_not_of(_CharT __c, size_type __pos = 0) const
> noexcept;
># 2138 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_last_not_of(const basic_string& __str, size_type __pos = npos) const
> noexcept
> { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
># 2155 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_last_not_of(const _CharT* __s, size_type __pos,
> size_type __n) const;
># 2169 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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));
> }
># 2186 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> size_type
> find_last_not_of(_CharT __c, size_type __pos = npos) const
> noexcept;
># 2202 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 2221 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 2253 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n, const basic_string& __str) const;
># 2279 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> int
> compare(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2) const;
># 2297 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> int
> compare(const _CharT* __s) const;
># 2321 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s) const;
># 2348 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> int
> compare(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2) const;
> };
># 2360 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
> __str.append(__rhs);
> return __str;
> }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT,_Traits,_Alloc>
> operator+(const _CharT* __lhs,
> const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT,_Traits,_Alloc>
> operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> {
> basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
> __str.append(__rhs);
> return __str;
> }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
> {
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> __string_type __str(__lhs);
> __str.append(__size_type(1), __rhs);
> return __str;
> }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return std::move(__lhs.append(__rhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> { return std::move(__rhs.insert(0, __lhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> {
> const auto __size = __lhs.size() + __rhs.size();
> const bool __cond = (__size > __lhs.capacity()
> && __size <= __rhs.capacity());
> return __cond ? std::move(__rhs.insert(0, __lhs))
> : std::move(__lhs.append(__rhs));
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(const _CharT* __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> { return std::move(__rhs.insert(0, __lhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(_CharT __lhs,
> basic_string<_CharT, _Traits, _Alloc>&& __rhs)
> { return std::move(__rhs.insert(0, 1, __lhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> const _CharT* __rhs)
> { return std::move(__lhs.append(__rhs)); }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_string<_CharT, _Traits, _Alloc>
> operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
> _CharT __rhs)
> { return std::move(__lhs.append(1, __rhs)); }
># 2481 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) == 0; }
>
> template<typename _CharT>
> inline
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
> operator==(const basic_string<_CharT>& __lhs,
> const basic_string<_CharT>& __rhs)
> { return (__lhs.size() == __rhs.size()
> && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
> __lhs.size())); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) == 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) == 0; }
># 2527 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return !(__lhs == __rhs); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return !(__lhs == __rhs); }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return !(__lhs == __rhs); }
># 2564 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) < 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) > 0; }
># 2601 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) > 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) < 0; }
># 2638 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) <= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator<=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) >= 0; }
># 2675 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
> const _CharT* __rhs)
> { return __lhs.compare(__rhs) >= 0; }
>
>
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline bool
> operator>=(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { return __rhs.compare(__lhs) <= 0; }
># 2712 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline void
> swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
> basic_string<_CharT, _Traits, _Alloc>& __rhs)
> { __lhs.swap(__rhs); }
># 2730 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str);
>
> template<>
> basic_istream<char>&
> operator>>(basic_istream<char>& __is, basic_string<char>& __str);
># 2748 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __os,
> const basic_string<_CharT, _Traits, _Alloc>& __str)
> {
>
>
> return __ostream_insert(__os, __str.data(), __str.size());
> }
># 2772 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
># 2790 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 3
> template<typename _CharT, typename _Traits, typename _Alloc>
> inline basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __is,
> basic_string<_CharT, _Traits, _Alloc>& __str)
> { return getline(__is, __str, __is.widen('\n')); }
>
> template<>
> basic_istream<char>&
> getline(basic_istream<char>& __in, basic_string<char>& __str,
> char __delim);
>
>
> template<>
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
> wchar_t __delim);
>
>
>
>}
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/string_conversions.h" 1 3
># 32 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/string_conversions.h" 3
> 
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/string_conversions.h" 3
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdlib" 3
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/string_conversions.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 3
>
>
>
>
># 1 "/usr/include/wchar.h" 1 3 4
># 47 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwchar" 2 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/string_conversions.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cstdio" 3
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/string_conversions.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cerrno" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cerrno" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cerrno" 3
>
># 1 "/usr/include/errno.h" 1 3 4
># 32 "/usr/include/errno.h" 3 4
>extern "C" {
>
>
>
># 1 "/usr/include/bits/errno.h" 1 3 4
># 25 "/usr/include/bits/errno.h" 3 4
># 1 "/usr/include/linux/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm/errno.h" 1 3 4
># 1 "/usr/include/asm-generic/errno.h" 1 3 4
>
>
>
># 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
># 5 "/usr/include/asm-generic/errno.h" 2 3 4
># 1 "/usr/include/asm/errno.h" 2 3 4
># 5 "/usr/include/linux/errno.h" 2 3 4
># 26 "/usr/include/bits/errno.h" 2 3 4
># 47 "/usr/include/bits/errno.h" 3 4
>extern int *__errno_location (void) throw () __attribute__ ((__const__));
># 37 "/usr/include/errno.h" 2 3 4
># 55 "/usr/include/errno.h" 3 4
>extern char *program_invocation_name, *program_invocation_short_name;
>
>
>
>}
># 69 "/usr/include/errno.h" 3 4
>typedef int error_t;
># 44 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cerrno" 2 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ext/string_conversions.h" 2 3
>
>namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _TRet, typename _Ret = _TRet, typename _CharT,
> typename... _Base>
> _Ret
> __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
> const char* __name, const _CharT* __str, std::size_t* __idx,
> _Base... __base)
> {
> _Ret __ret;
>
> _CharT* __endptr;
> (*__errno_location ()) = 0;
> const _TRet __tmp = __convf(__str, &__endptr, __base...);
>
> if (__endptr == __str)
> std::__throw_invalid_argument(__name);
> else if ((*__errno_location ()) == 34
> || (std::__are_same<_Ret, int>::__value
> && (__tmp < __numeric_traits<int>::__min
> || __tmp > __numeric_traits<int>::__max)))
> std::__throw_out_of_range(__name);
> else
> __ret = __tmp;
>
> if (__idx)
> *__idx = __endptr - __str;
>
> return __ret;
> }
>
>
> template<typename _String, typename _CharT = typename _String::value_type>
> _String
> __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
> __builtin_va_list), std::size_t __n,
> const _CharT* __fmt, ...)
> {
>
>
> _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __n));
>
> __builtin_va_list __args;
> __builtin_va_start(__args, __fmt);
>
> const int __len = __convf(__s, __n, __fmt, __args);
>
> __builtin_va_end(__args);
>
> return _String(__s, __s + __len);
> }
>
>
>}
># 2815 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> inline int
> stoi(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
> __idx, __base); }
>
> inline long
> stol(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long
> stoul(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
> __idx, __base); }
>
> inline long long
> stoll(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long long
> stoull(const string& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
> __idx, __base); }
>
>
> inline float
> stof(const string& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
>
> inline double
> stod(const string& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }
>
> inline long double
> stold(const string& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
>
>
>
>
> inline string
> to_string(int __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(int),
> "%d", __val); }
>
> inline string
> to_string(unsigned __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(unsigned),
> "%u", __val); }
>
> inline string
> to_string(long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, 4 * sizeof(long),
> "%ld", __val); }
>
> inline string
> to_string(unsigned long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(unsigned long),
> "%lu", __val); }
>
> inline string
> to_string(long long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(long long),
> "%lld", __val); }
>
> inline string
> to_string(unsigned long long __val)
> { return __gnu_cxx::__to_xstring<string>(&std::vsnprintf,
> 4 * sizeof(unsigned long long),
> "%llu", __val); }
>
> inline string
> to_string(float __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
> "%f", __val);
> }
>
> inline string
> to_string(double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
> "%f", __val);
> }
>
> inline string
> to_string(long double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
> "%Lf", __val);
> }
>
>
> inline int
> stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
> __idx, __base); }
>
> inline long
> stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long
> stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
> __idx, __base); }
>
> inline long long
> stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
> __idx, __base); }
>
> inline unsigned long long
> stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
> { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
> __idx, __base); }
>
>
> inline float
> stof(const wstring& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }
>
> inline double
> stod(const wstring& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }
>
> inline long double
> stold(const wstring& __str, size_t* __idx = 0)
> { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }
>
>
> inline wstring
> to_wstring(int __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(int),
> L"%d", __val); }
>
> inline wstring
> to_wstring(unsigned __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(unsigned),
> L"%u", __val); }
>
> inline wstring
> to_wstring(long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, 4 * sizeof(long),
> L"%ld", __val); }
>
> inline wstring
> to_wstring(unsigned long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(unsigned long),
> L"%lu", __val); }
>
> inline wstring
> to_wstring(long long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(long long),
> L"%lld", __val); }
>
> inline wstring
> to_wstring(unsigned long long __val)
> { return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf,
> 4 * sizeof(unsigned long long),
> L"%llu", __val); }
>
> inline wstring
> to_wstring(float __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
> L"%f", __val);
> }
>
> inline wstring
> to_wstring(double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
> L"%f", __val);
> }
>
> inline wstring
> to_wstring(long double __val)
> {
> const int __n =
> __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
> return __gnu_cxx::__to_xstring<wstring>(&std::vswprintf, __n,
> L"%Lf", __val);
> }
>
>
>
>}
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/functional_hash.h" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/functional_hash.h" 3
> 
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/functional_hash.h" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/hash_bytes.h" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/hash_bytes.h" 3
> 
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/hash_bytes.h" 3
>
>
>
>namespace std
>{
>
>
>
>
>
>
>
> size_t
> _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
>
>
>
>
>
> size_t
> _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
>
>
>}
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/functional_hash.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 49 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/functional_hash.h" 3
> template<typename _Result, typename _Arg>
> struct __hash_base
> {
> typedef _Result result_type;
> typedef _Arg argument_type;
> };
>
>
> template<typename _Tp>
> struct hash : public __hash_base<size_t, _Tp>
> {
> static_assert(sizeof(_Tp) < 0,
> "std::hash is not specialized for this type");
> size_t operator()(const _Tp&) const noexcept;
> };
>
>
> template<typename _Tp>
> struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
> {
> size_t
> operator()(_Tp* __p) const noexcept
> { return reinterpret_cast<size_t>(__p); }
> };
># 85 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/functional_hash.h" 3
> template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
> template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
>
>
>
> struct _Hash_impl
> {
> static size_t
> hash(const void* __ptr, size_t __clength,
> size_t __seed = static_cast<size_t>(0xc70f6907UL))
> { return _Hash_bytes(__ptr, __clength, __seed); }
>
> template<typename _Tp>
> static size_t
> hash(const _Tp& __val)
> { return hash(&__val, sizeof(__val)); }
>
> template<typename _Tp>
> static size_t
> __hash_combine(const _Tp& __val, size_t __hash)
> { return hash(&__val, sizeof(__val), __hash); }
> };
>
> struct _Fnv_hash_impl
> {
> static size_t
> hash(const void* __ptr, size_t __clength,
> size_t __seed = static_cast<size_t>(2166136261UL))
> { return _Fnv_hash_bytes(__ptr, __clength, __seed); }
>
> template<typename _Tp>
> static size_t
> hash(const _Tp& __val)
> { return hash(&__val, sizeof(__val)); }
>
> template<typename _Tp>
> static size_t
> __hash_combine(const _Tp& __val, size_t __hash)
> { return hash(&__val, sizeof(__val), __hash); }
> };
>
>
> template<>
> struct hash<float> : public __hash_base<size_t, float>
> {
> size_t
> operator()(float __val) const noexcept
> {
>
> return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
> }
> };
>
>
> template<>
> struct hash<double> : public __hash_base<size_t, double>
> {
> size_t
> operator()(double __val) const noexcept
> {
>
> return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
> }
> };
>
>
> template<>
> struct hash<long double>
> : public __hash_base<size_t, long double>
> {
> __attribute__ ((__pure__)) size_t
> operator()(long double __val) const noexcept;
> };
>
>
>
>
>}
># 3033 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
> template<>
> struct hash<string>
> : public __hash_base<size_t, string>
> {
> size_t
> operator()(const string& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(), __s.length()); }
> };
>
>
>
> template<>
> struct hash<wstring>
> : public __hash_base<size_t, wstring>
> {
> size_t
> operator()(const wstring& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(wchar_t)); }
> };
>
>
>
>
>
> template<>
> struct hash<u16string>
> : public __hash_base<size_t, u16string>
> {
> size_t
> operator()(const u16string& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char16_t)); }
> };
>
>
> template<>
> struct hash<u32string>
> : public __hash_base<size_t, u32string>
> {
> size_t
> operator()(const u32string& __s) const noexcept
> { return std::_Hash_impl::hash(__s.data(),
> __s.length() * sizeof(char32_t)); }
> };
>
>
>
>}
># 55 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.tcc" 1 3
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.tcc" 3
> 
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const _CharT
> basic_string<_CharT, _Traits, _Alloc>::
> _Rep::_S_terminal = _CharT();
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> const typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::npos;
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
> (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
> sizeof(size_type)];
>
>
>
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InIterator>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
> input_iterator_tag)
> {
>
> if (__beg == __end && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
> _CharT __buf[128];
> size_type __len = 0;
> while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
> {
> __buf[__len++] = *__beg;
> ++__beg;
> }
> _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
> _M_copy(__r->_M_refdata(), __buf, __len);
> try
> {
> while (__beg != __end)
> {
> if (__len == __r->_M_capacity)
> {
>
> _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
> _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
> __r->_M_destroy(__a);
> __r = __another;
> }
> __r->_M_refdata()[__len++] = *__beg;
> ++__beg;
> }
> }
> catch(...)
> {
> __r->_M_destroy(__a);
> throw;
> }
> __r->_M_set_length_and_sharable(__len);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template <typename _InIterator>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::
> _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
> forward_iterator_tag)
> {
>
> if (__beg == __end && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
> if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
> __throw_logic_error(("basic_string::_S_construct null not valid"));
>
> const size_type __dnew = static_cast<size_type>(std::distance(__beg,
> __end));
>
> _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
> try
> { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
> catch(...)
> {
> __r->_M_destroy(__a);
> throw;
> }
> __r->_M_set_length_and_sharable(__dnew);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::
> _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
> {
>
> if (__n == 0 && __a == _Alloc())
> return _S_empty_rep()._M_refdata();
>
>
> _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
> if (__n)
> _M_assign(__r->_M_refdata(), __n, __c);
>
> __r->_M_set_length_and_sharable(__n);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const basic_string& __str)
> : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
> __str.get_allocator()),
> __str.get_allocator())
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const _Alloc& __a)
> : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const basic_string& __str, size_type __pos, size_type __n)
> : _M_dataplus(_S_construct(__str._M_data()
> + __str._M_check(__pos,
> "basic_string::basic_string"),
> __str._M_data() + __str._M_limit(__pos, __n)
> + __pos, _Alloc()), _Alloc())
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const basic_string& __str, size_type __pos,
> size_type __n, const _Alloc& __a)
> : _M_dataplus(_S_construct(__str._M_data()
> + __str._M_check(__pos,
> "basic_string::basic_string"),
> __str._M_data() + __str._M_limit(__pos, __n)
> + __pos, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
> : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(const _CharT* __s, const _Alloc& __a)
> : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
> __s + npos, __a), __a)
> { }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(size_type __n, _CharT __c, const _Alloc& __a)
> : _M_dataplus(_S_construct(__n, __c, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InputIterator>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
> : _M_dataplus(_S_construct(__beg, __end, __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>::
> basic_string(initializer_list<_CharT> __l, const _Alloc& __a)
> : _M_dataplus(_S_construct(__l.begin(), __l.end(), __a), __a)
> { }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> assign(const basic_string& __str)
> {
> if (_M_rep() != __str._M_rep())
> {
>
> const allocator_type __a = this->get_allocator();
> _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
> _M_rep()->_M_dispose(__a);
> _M_data(__tmp);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> assign(const _CharT* __s, size_type __n)
> {
> ;
> _M_check_length(this->size(), __n, "basic_string::assign");
> if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(size_type(0), this->size(), __s, __n);
> else
> {
>
> const size_type __pos = __s - _M_data();
> if (__pos >= __n)
> _M_copy(_M_data(), __s, __n);
> else if (__pos)
> _M_move(_M_data(), __s, __n);
> _M_rep()->_M_set_length_and_sharable(__n);
> return *this;
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(size_type __n, _CharT __c)
> {
> if (__n)
> {
> _M_check_length(size_type(0), __n, "basic_string::append");
> const size_type __len = __n + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> _M_assign(_M_data() + this->size(), __n, __c);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const _CharT* __s, size_type __n)
> {
> ;
> if (__n)
> {
> _M_check_length(size_type(0), __n, "basic_string::append");
> const size_type __len = __n + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> {
> if (_M_disjunct(__s))
> this->reserve(__len);
> else
> {
> const size_type __off = __s - _M_data();
> this->reserve(__len);
> __s = _M_data() + __off;
> }
> }
> _M_copy(_M_data() + this->size(), __s, __n);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const basic_string& __str)
> {
> const size_type __size = __str.size();
> if (__size)
> {
> const size_type __len = __size + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> _M_copy(_M_data() + this->size(), __str._M_data(), __size);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> append(const basic_string& __str, size_type __pos, size_type __n)
> {
> __str._M_check(__pos, "basic_string::append");
> __n = __str._M_limit(__pos, __n);
> if (__n)
> {
> const size_type __len = __n + this->size();
> if (__len > this->capacity() || _M_rep()->_M_is_shared())
> this->reserve(__len);
> _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
> _M_rep()->_M_set_length_and_sharable(__len);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> insert(size_type __pos, const _CharT* __s, size_type __n)
> {
> ;
> _M_check(__pos, "basic_string::insert");
> _M_check_length(size_type(0), __n, "basic_string::insert");
> if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(__pos, size_type(0), __s, __n);
> else
> {
>
> const size_type __off = __s - _M_data();
> _M_mutate(__pos, 0, __n);
> __s = _M_data() + __off;
> _CharT* __p = _M_data() + __pos;
> if (__s + __n <= __p)
> _M_copy(__p, __s, __n);
> else if (__s >= __p)
> _M_copy(__p, __s + __n, __n);
> else
> {
> const size_type __nleft = __p - __s;
> _M_copy(__p, __s, __nleft);
> _M_copy(__p + __nleft, __p + __n, __n - __nleft);
> }
> return *this;
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::iterator
> basic_string<_CharT, _Traits, _Alloc>::
> erase(iterator __first, iterator __last)
> {
> 
> ;
>
>
>
>
> const size_type __size = __last - __first;
> if (__size)
> {
> const size_type __pos = __first - _M_ibegin();
> _M_mutate(__pos, __size, size_type(0));
> _M_rep()->_M_set_leaked();
> return iterator(_M_data() + __pos);
> }
> else
> return __first;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> replace(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2)
> {
> ;
> _M_check(__pos, "basic_string::replace");
> __n1 = _M_limit(__pos, __n1);
> _M_check_length(__n1, __n2, "basic_string::replace");
> bool __left;
> if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
> return _M_replace_safe(__pos, __n1, __s, __n2);
> else if ((__left = __s + __n2 <= _M_data() + __pos)
> || _M_data() + __pos + __n1 <= __s)
> {
>
> size_type __off = __s - _M_data();
> __left ? __off : (__off += __n2 - __n1);
> _M_mutate(__pos, __n1, __n2);
> _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
> return *this;
> }
> else
> {
>
> const basic_string __tmp(__s, __n2);
> return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::_Rep::
> _M_destroy(const _Alloc& __a) throw ()
> {
> const size_type __size = sizeof(_Rep_base) +
> (this->_M_capacity + 1) * sizeof(_CharT);
> _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_leak_hard()
> {
>
> if (_M_rep() == &_S_empty_rep())
> return;
>
> if (_M_rep()->_M_is_shared())
> _M_mutate(0, 0, 0);
> _M_rep()->_M_set_leaked();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> _M_mutate(size_type __pos, size_type __len1, size_type __len2)
> {
> const size_type __old_size = this->size();
> const size_type __new_size = __old_size + __len2 - __len1;
> const size_type __how_much = __old_size - __pos - __len1;
>
> if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
> {
>
> const allocator_type __a = get_allocator();
> _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
>
> if (__pos)
> _M_copy(__r->_M_refdata(), _M_data(), __pos);
> if (__how_much)
> _M_copy(__r->_M_refdata() + __pos + __len2,
> _M_data() + __pos + __len1, __how_much);
>
> _M_rep()->_M_dispose(__a);
> _M_data(__r->_M_refdata());
> }
> else if (__how_much && __len1 != __len2)
> {
>
> _M_move(_M_data() + __pos + __len2,
> _M_data() + __pos + __len1, __how_much);
> }
> _M_rep()->_M_set_length_and_sharable(__new_size);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> reserve(size_type __res)
> {
> if (__res != this->capacity() || _M_rep()->_M_is_shared())
> {
>
> if (__res < this->size())
> __res = this->size();
> const allocator_type __a = get_allocator();
> _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
> _M_rep()->_M_dispose(__a);
> _M_data(__tmp);
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> swap(basic_string& __s)
> {
> if (_M_rep()->_M_is_leaked())
> _M_rep()->_M_set_sharable();
> if (__s._M_rep()->_M_is_leaked())
> __s._M_rep()->_M_set_sharable();
> if (this->get_allocator() == __s.get_allocator())
> {
> _CharT* __tmp = _M_data();
> _M_data(__s._M_data());
> __s._M_data(__tmp);
> }
>
> else
> {
> const basic_string __tmp1(_M_ibegin(), _M_iend(),
> __s.get_allocator());
> const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
> this->get_allocator());
> *this = __tmp2;
> __s = __tmp1;
> }
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
> basic_string<_CharT, _Traits, _Alloc>::_Rep::
> _S_create(size_type __capacity, size_type __old_capacity,
> const _Alloc& __alloc)
> {
>
>
> if (__capacity > _S_max_size)
> __throw_length_error(("basic_string::_S_create"));
># 579 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_string.tcc" 3
> const size_type __pagesize = 4096;
> const size_type __malloc_header_size = 4 * sizeof(void*);
>
>
>
>
>
>
>
> if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
> __capacity = 2 * __old_capacity;
>
>
>
>
> size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
>
> const size_type __adj_size = __size + __malloc_header_size;
> if (__adj_size > __pagesize && __capacity > __old_capacity)
> {
> const size_type __extra = __pagesize - __adj_size % __pagesize;
> __capacity += __extra / sizeof(_CharT);
>
> if (__capacity > _S_max_size)
> __capacity = _S_max_size;
> __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
> }
>
>
>
> void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
> _Rep *__p = new (__place) _Rep;
> __p->_M_capacity = __capacity;
>
>
>
>
>
>
>
> __p->_M_set_sharable();
> return __p;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> _CharT*
> basic_string<_CharT, _Traits, _Alloc>::_Rep::
> _M_clone(const _Alloc& __alloc, size_type __res)
> {
>
> const size_type __requested_cap = this->_M_length + __res;
> _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
> __alloc);
> if (this->_M_length)
> _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
>
> __r->_M_set_length_and_sharable(this->_M_length);
> return __r->_M_refdata();
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> void
> basic_string<_CharT, _Traits, _Alloc>::
> resize(size_type __n, _CharT __c)
> {
> const size_type __size = this->size();
> _M_check_length(__size, __n, "basic_string::resize");
> if (__size < __n)
> this->append(__n - __size, __c);
> else if (__n < __size)
> this->erase(__n);
>
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> template<typename _InputIterator>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
> _InputIterator __k2, __false_type)
> {
> const basic_string __s(__k1, __k2);
> const size_type __n1 = __i2 - __i1;
> _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
> return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
> __s.size());
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
> _CharT __c)
> {
> _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
> _M_mutate(__pos1, __n1, __n2);
> if (__n2)
> _M_assign(_M_data() + __pos1, __n2, __c);
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>&
> basic_string<_CharT, _Traits, _Alloc>::
> _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
> size_type __n2)
> {
> _M_mutate(__pos1, __n1, __n2);
> if (__n2)
> _M_copy(_M_data() + __pos1, __s, __n2);
> return *this;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(const _CharT* __lhs,
> const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> ;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> const __size_type __len = _Traits::length(__lhs);
> __string_type __str;
> __str.reserve(__len + __rhs.size());
> __str.append(__lhs, __len);
> __str.append(__rhs);
> return __str;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_string<_CharT, _Traits, _Alloc>
> operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
> {
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __string_type::size_type __size_type;
> __string_type __str;
> const __size_type __len = __rhs.size();
> __str.reserve(__len + 1);
> __str.append(__size_type(1), __lhs);
> __str.append(__rhs);
> return __str;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> copy(_CharT* __s, size_type __n, size_type __pos) const
> {
> _M_check(__pos, "basic_string::copy");
> __n = _M_limit(__pos, __n);
> ;
> if (__n)
> _M_copy(__s, _M_data() + __pos, __n);
>
> return __n;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> 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 _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find(_CharT __c, size_type __pos) const noexcept
> {
> size_type __ret = npos;
> const size_type __size = this->size();
> if (__pos < __size)
> {
> const _CharT* __data = _M_data();
> const size_type __n = __size - __pos;
> const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
> if (__p)
> __ret = __p - __data;
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> rfind(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> const size_type __size = this->size();
> if (__n <= __size)
> {
> __pos = std::min(size_type(__size - __n), __pos);
> const _CharT* __data = _M_data();
> do
> {
> if (traits_type::compare(__data + __pos, __s, __n) == 0)
> return __pos;
> }
> while (__pos-- > 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> rfind(_CharT __c, size_type __pos) const noexcept
> {
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> for (++__size; __size-- > 0; )
> if (traits_type::eq(_M_data()[__size], __c))
> return __size;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> for (; __n && __pos < this->size(); ++__pos)
> {
> const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
> if (__p)
> return __pos;
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> size_type __size = this->size();
> if (__size && __n)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (traits_type::find(__s, __n, _M_data()[__size]))
> return __size;
> }
> while (__size-- != 0);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> for (; __pos < this->size(); ++__pos)
> if (!traits_type::find(__s, __n, _M_data()[__pos]))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_first_not_of(_CharT __c, size_type __pos) const noexcept
> {
> for (; __pos < this->size(); ++__pos)
> if (!traits_type::eq(_M_data()[__pos], __c))
> return __pos;
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
> {
> ;
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::find(__s, __n, _M_data()[__size]))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> typename basic_string<_CharT, _Traits, _Alloc>::size_type
> basic_string<_CharT, _Traits, _Alloc>::
> find_last_not_of(_CharT __c, size_type __pos) const noexcept
> {
> size_type __size = this->size();
> if (__size)
> {
> if (--__size > __pos)
> __size = __pos;
> do
> {
> if (!traits_type::eq(_M_data()[__size], __c))
> return __size;
> }
> while (__size--);
> }
> return npos;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n, const basic_string& __str) const
> {
> _M_check(__pos, "basic_string::compare");
> __n = _M_limit(__pos, __n);
> const size_type __osize = __str.size();
> const size_type __len = std::min(__n, __osize);
> int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
> if (!__r)
> __r = _S_compare(__n, __osize);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(size_type __pos1, size_type __n1, const basic_string& __str,
> size_type __pos2, size_type __n2) const
> {
> _M_check(__pos1, "basic_string::compare");
> __str._M_check(__pos2, "basic_string::compare");
> __n1 = _M_limit(__pos1, __n1);
> __n2 = __str._M_limit(__pos2, __n2);
> const size_type __len = std::min(__n1, __n2);
> int __r = traits_type::compare(_M_data() + __pos1,
> __str.data() + __pos2, __len);
> if (!__r)
> __r = _S_compare(__n1, __n2);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string<_CharT, _Traits, _Alloc>::
> compare(const _CharT* __s) const
> {
> ;
> const size_type __size = this->size();
> const size_type __osize = traits_type::length(__s);
> const size_type __len = std::min(__size, __osize);
> int __r = traits_type::compare(_M_data(), __s, __len);
> if (!__r)
> __r = _S_compare(__size, __osize);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string <_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n1, const _CharT* __s) const
> {
> ;
> _M_check(__pos, "basic_string::compare");
> __n1 = _M_limit(__pos, __n1);
> const size_type __osize = traits_type::length(__s);
> const size_type __len = std::min(__n1, __osize);
> int __r = traits_type::compare(_M_data() + __pos, __s, __len);
> if (!__r)
> __r = _S_compare(__n1, __osize);
> return __r;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> int
> basic_string <_CharT, _Traits, _Alloc>::
> compare(size_type __pos, size_type __n1, const _CharT* __s,
> size_type __n2) const
> {
> ;
> _M_check(__pos, "basic_string::compare");
> __n1 = _M_limit(__pos, __n1);
> const size_type __len = std::min(__n1, __n2);
> int __r = traits_type::compare(_M_data() + __pos, __s, __len);
> if (!__r)
> __r = _S_compare(__n1, __n2);
> return __r;
> }
>
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT, _Traits, _Alloc>& __str)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __istream_type::ios_base __ios_base;
> typedef typename __istream_type::int_type __int_type;
> typedef typename __string_type::size_type __size_type;
> typedef ctype<_CharT> __ctype_type;
> typedef typename __ctype_type::ctype_base __ctype_base;
>
> __size_type __extracted = 0;
> typename __ios_base::iostate __err = __ios_base::goodbit;
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> try
> {
>
> __str.erase();
> _CharT __buf[128];
> __size_type __len = 0;
> const streamsize __w = __in.width();
> const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
> : __str.max_size();
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
> const __int_type __eof = _Traits::eof();
> __int_type __c = __in.rdbuf()->sgetc();
>
> while (__extracted < __n
> && !_Traits::eq_int_type(__c, __eof)
> && !__ct.is(__ctype_base::space,
> _Traits::to_char_type(__c)))
> {
> if (__len == sizeof(__buf) / sizeof(_CharT))
> {
> __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
> __len = 0;
> }
> __buf[__len++] = _Traits::to_char_type(__c);
> ++__extracted;
> __c = __in.rdbuf()->snextc();
> }
> __str.append(__buf, __len);
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= __ios_base::eofbit;
> __in.width(0);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> {
>
>
>
> __in._M_setstate(__ios_base::badbit);
> }
> }
>
> if (!__extracted)
> __err |= __ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> basic_istream<_CharT, _Traits>&
> getline(basic_istream<_CharT, _Traits>& __in,
> basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
> typedef typename __istream_type::ios_base __ios_base;
> typedef typename __istream_type::int_type __int_type;
> typedef typename __string_type::size_type __size_type;
>
> __size_type __extracted = 0;
> const __size_type __n = __str.max_size();
> typename __ios_base::iostate __err = __ios_base::goodbit;
> typename __istream_type::sentry __cerb(__in, true);
> if (__cerb)
> {
> try
> {
> __str.erase();
> const __int_type __idelim = _Traits::to_int_type(__delim);
> const __int_type __eof = _Traits::eof();
> __int_type __c = __in.rdbuf()->sgetc();
>
> while (__extracted < __n
> && !_Traits::eq_int_type(__c, __eof)
> && !_Traits::eq_int_type(__c, __idelim))
> {
> __str += _Traits::to_char_type(__c);
> ++__extracted;
> __c = __in.rdbuf()->snextc();
> }
>
> if (_Traits::eq_int_type(__c, __eof))
> __err |= __ios_base::eofbit;
> else if (_Traits::eq_int_type(__c, __idelim))
> {
> ++__extracted;
> __in.rdbuf()->sbumpc();
> }
> else
> __err |= __ios_base::failbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(__ios_base::badbit);
> throw;
> }
> catch(...)
> {
>
>
>
> __in._M_setstate(__ios_base::badbit);
> }
> }
> if (!__extracted)
> __err |= __ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
>
>
>
> extern template class basic_string<char>;
> extern template
> basic_istream<char>&
> operator>>(basic_istream<char>&, string&);
> extern template
> basic_ostream<char>&
> operator<<(basic_ostream<char>&, const string&);
> extern template
> basic_istream<char>&
> getline(basic_istream<char>&, string&, char);
> extern template
> basic_istream<char>&
> getline(basic_istream<char>&, string&);
>
>
> extern template class basic_string<wchar_t>;
> extern template
> basic_istream<wchar_t>&
> operator>>(basic_istream<wchar_t>&, wstring&);
> extern template
> basic_ostream<wchar_t>&
> operator<<(basic_ostream<wchar_t>&, const wstring&);
> extern template
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>&, wstring&, wchar_t);
> extern template
> basic_istream<wchar_t>&
> getline(basic_istream<wchar_t>&, wstring&);
>
>
>
>
>}
># 56 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/string" 2 3
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 2 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/limits" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/limits" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/limits" 3
># 148 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/limits" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
> enum float_round_style
> {
> round_indeterminate = -1,
> round_toward_zero = 0,
> round_to_nearest = 1,
> round_toward_infinity = 2,
> round_toward_neg_infinity = 3
> };
>
>
>
>
>
>
>
> enum float_denorm_style
> {
>
> denorm_indeterminate = -1,
>
> denorm_absent = 0,
>
> denorm_present = 1
> };
># 192 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/limits" 3
> struct __numeric_limits_base
> {
>
>
> static constexpr bool is_specialized = false;
>
>
>
>
> static constexpr int digits = 0;
>
>
> static constexpr int digits10 = 0;
>
>
>
>
> static constexpr int max_digits10 = 0;
>
>
>
> static constexpr bool is_signed = false;
>
>
>
> static constexpr bool is_integer = false;
>
>
>
>
>
> static constexpr bool is_exact = false;
>
>
>
> static constexpr int radix = 0;
>
>
>
> static constexpr int min_exponent = 0;
>
>
>
> static constexpr int min_exponent10 = 0;
>
>
>
>
> static constexpr int max_exponent = 0;
>
>
>
> static constexpr int max_exponent10 = 0;
>
>
> static constexpr bool has_infinity = false;
>
>
>
> static constexpr bool has_quiet_NaN = false;
>
>
>
> static constexpr bool has_signaling_NaN = false;
>
>
> static constexpr float_denorm_style has_denorm = denorm_absent;
>
>
>
> static constexpr bool has_denorm_loss = false;
>
>
>
> static constexpr bool is_iec559 = false;
>
>
>
>
> static constexpr bool is_bounded = false;
>
>
>
>
>
> static constexpr bool is_modulo = false;
>
>
> static constexpr bool traps = false;
>
>
> static constexpr bool tinyness_before = false;
>
>
>
>
> static constexpr float_round_style round_style =
> round_toward_zero;
> };
># 303 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/limits" 3
> template<typename _Tp>
> struct numeric_limits : public __numeric_limits_base
> {
>
>
> static constexpr _Tp
> min() noexcept { return static_cast<_Tp>(0); }
>
>
> static constexpr _Tp
> max() noexcept { return static_cast<_Tp>(0); }
>
>
>
>
> static constexpr _Tp
> lowest() noexcept { return static_cast<_Tp>(0); }
>
>
>
>
> static constexpr _Tp
> epsilon() noexcept { return static_cast<_Tp>(0); }
>
>
> static constexpr _Tp
> round_error() noexcept { return static_cast<_Tp>(0); }
>
>
> static constexpr _Tp
> infinity() noexcept { return static_cast<_Tp>(0); }
>
>
>
> static constexpr _Tp
> quiet_NaN() noexcept { return static_cast<_Tp>(0); }
>
>
>
> static constexpr _Tp
> signaling_NaN() noexcept { return static_cast<_Tp>(0); }
>
>
>
>
> static constexpr _Tp
> denorm_min() noexcept { return static_cast<_Tp>(0); }
> };
>
>
> template<typename _Tp>
> struct numeric_limits<const _Tp>
> : public numeric_limits<_Tp> { };
>
> template<typename _Tp>
> struct numeric_limits<volatile _Tp>
> : public numeric_limits<_Tp> { };
>
> template<typename _Tp>
> struct numeric_limits<const volatile _Tp>
> : public numeric_limits<_Tp> { };
>
>
>
>
>
>
> template<>
> struct numeric_limits<bool>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr bool
> min() noexcept { return false; }
>
> static constexpr bool
> max() noexcept { return true; }
>
>
> static constexpr bool
> lowest() noexcept { return min(); }
>
> static constexpr int digits = 1;
> static constexpr int digits10 = 0;
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr bool
> epsilon() noexcept { return false; }
>
> static constexpr bool
> round_error() noexcept { return false; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr bool
> infinity() noexcept { return false; }
>
> static constexpr bool
> quiet_NaN() noexcept { return false; }
>
> static constexpr bool
> signaling_NaN() noexcept { return false; }
>
> static constexpr bool
> denorm_min() noexcept { return false; }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
>
>
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<char>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr char
> min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }
>
> static constexpr char
> max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
>
>
> static constexpr char
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
> static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = ((char)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr char
> epsilon() noexcept { return 0; }
>
> static constexpr char
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr
> char infinity() noexcept { return char(); }
>
> static constexpr char
> quiet_NaN() noexcept { return char(); }
>
> static constexpr char
> signaling_NaN() noexcept { return char(); }
>
> static constexpr char
> denorm_min() noexcept { return static_cast<char>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<signed char>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr signed char
> min() noexcept { return -127 - 1; }
>
> static constexpr signed char
> max() noexcept { return 127; }
>
>
> static constexpr signed char
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr signed char
> epsilon() noexcept { return 0; }
>
> static constexpr signed char
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr signed char
> infinity() noexcept { return static_cast<signed char>(0); }
>
> static constexpr signed char
> quiet_NaN() noexcept { return static_cast<signed char>(0); }
>
> static constexpr signed char
> signaling_NaN() noexcept
> { return static_cast<signed char>(0); }
>
> static constexpr signed char
> denorm_min() noexcept
> { return static_cast<signed char>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned char>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned char
> min() noexcept { return 0; }
>
> static constexpr unsigned char
> max() noexcept { return 127 * 2U + 1; }
>
>
> static constexpr unsigned char
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned char
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned char
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned char
> infinity() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr unsigned char
> quiet_NaN() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr unsigned char
> signaling_NaN() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr unsigned char
> denorm_min() noexcept
> { return static_cast<unsigned char>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<wchar_t>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr wchar_t
> min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }
>
> static constexpr wchar_t
> max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
>
>
> static constexpr wchar_t
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = ((wchar_t)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr wchar_t
> epsilon() noexcept { return 0; }
>
> static constexpr wchar_t
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr wchar_t
> infinity() noexcept { return wchar_t(); }
>
> static constexpr wchar_t
> quiet_NaN() noexcept { return wchar_t(); }
>
> static constexpr wchar_t
> signaling_NaN() noexcept { return wchar_t(); }
>
> static constexpr wchar_t
> denorm_min() noexcept { return wchar_t(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
>
> template<>
> struct numeric_limits<char16_t>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr char16_t
> min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }
>
> static constexpr char16_t
> max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }
>
> static constexpr char16_t
> lowest() noexcept { return min(); }
>
> static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
> static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
> static constexpr int max_digits10 = 0;
> static constexpr bool is_signed = ((char16_t)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr char16_t
> epsilon() noexcept { return 0; }
>
> static constexpr char16_t
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr char16_t
> infinity() noexcept { return char16_t(); }
>
> static constexpr char16_t
> quiet_NaN() noexcept { return char16_t(); }
>
> static constexpr char16_t
> signaling_NaN() noexcept { return char16_t(); }
>
> static constexpr char16_t
> denorm_min() noexcept { return char16_t(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<char32_t>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr char32_t
> min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }
>
> static constexpr char32_t
> max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }
>
> static constexpr char32_t
> lowest() noexcept { return min(); }
>
> static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
> static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
> static constexpr int max_digits10 = 0;
> static constexpr bool is_signed = ((char32_t)(-1) < 0);
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr char32_t
> epsilon() noexcept { return 0; }
>
> static constexpr char32_t
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr char32_t
> infinity() noexcept { return char32_t(); }
>
> static constexpr char32_t
> quiet_NaN() noexcept { return char32_t(); }
>
> static constexpr char32_t
> signaling_NaN() noexcept { return char32_t(); }
>
> static constexpr char32_t
> denorm_min() noexcept { return char32_t(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style = round_toward_zero;
> };
>
>
>
> template<>
> struct numeric_limits<short>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr short
> min() noexcept { return -32767 - 1; }
>
> static constexpr short
> max() noexcept { return 32767; }
>
>
> static constexpr short
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
> static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr short
> epsilon() noexcept { return 0; }
>
> static constexpr short
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr short
> infinity() noexcept { return short(); }
>
> static constexpr short
> quiet_NaN() noexcept { return short(); }
>
> static constexpr short
> signaling_NaN() noexcept { return short(); }
>
> static constexpr short
> denorm_min() noexcept { return short(); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned short>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned short
> min() noexcept { return 0; }
>
> static constexpr unsigned short
> max() noexcept { return 32767 * 2U + 1; }
>
>
> static constexpr unsigned short
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned short
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned short
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned short
> infinity() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr unsigned short
> quiet_NaN() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr unsigned short
> signaling_NaN() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr unsigned short
> denorm_min() noexcept
> { return static_cast<unsigned short>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<int>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr int
> min() noexcept { return -2147483647 - 1; }
>
> static constexpr int
> max() noexcept { return 2147483647; }
>
>
> static constexpr int
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
> static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr int
> epsilon() noexcept { return 0; }
>
> static constexpr int
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr int
> infinity() noexcept { return static_cast<int>(0); }
>
> static constexpr int
> quiet_NaN() noexcept { return static_cast<int>(0); }
>
> static constexpr int
> signaling_NaN() noexcept { return static_cast<int>(0); }
>
> static constexpr int
> denorm_min() noexcept { return static_cast<int>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned int>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned int
> min() noexcept { return 0; }
>
> static constexpr unsigned int
> max() noexcept { return 2147483647 * 2U + 1; }
>
>
> static constexpr unsigned int
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned int
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned int
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned int
> infinity() noexcept { return static_cast<unsigned int>(0); }
>
> static constexpr unsigned int
> quiet_NaN() noexcept
> { return static_cast<unsigned int>(0); }
>
> static constexpr unsigned int
> signaling_NaN() noexcept
> { return static_cast<unsigned int>(0); }
>
> static constexpr unsigned int
> denorm_min() noexcept
> { return static_cast<unsigned int>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr long
> min() noexcept { return -9223372036854775807L - 1; }
>
> static constexpr long
> max() noexcept { return 9223372036854775807L; }
>
>
> static constexpr long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
> static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr long
> epsilon() noexcept { return 0; }
>
> static constexpr long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr long
> infinity() noexcept { return static_cast<long>(0); }
>
> static constexpr long
> quiet_NaN() noexcept { return static_cast<long>(0); }
>
> static constexpr long
> signaling_NaN() noexcept { return static_cast<long>(0); }
>
> static constexpr long
> denorm_min() noexcept { return static_cast<long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned long
> min() noexcept { return 0; }
>
> static constexpr unsigned long
> max() noexcept { return 9223372036854775807L * 2UL + 1; }
>
>
> static constexpr unsigned long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned long
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned long
> infinity() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr unsigned long
> quiet_NaN() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr unsigned long
> signaling_NaN() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr unsigned long
> denorm_min() noexcept
> { return static_cast<unsigned long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<long long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr long long
> min() noexcept { return -9223372036854775807LL - 1; }
>
> static constexpr long long
> max() noexcept { return 9223372036854775807LL; }
>
>
> static constexpr long long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(long long) * 8 - ((long long)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr long long
> epsilon() noexcept { return 0; }
>
> static constexpr long long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr long long
> infinity() noexcept { return static_cast<long long>(0); }
>
> static constexpr long long
> quiet_NaN() noexcept { return static_cast<long long>(0); }
>
> static constexpr long long
> signaling_NaN() noexcept
> { return static_cast<long long>(0); }
>
> static constexpr long long
> denorm_min() noexcept { return static_cast<long long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
>
>
> template<>
> struct numeric_limits<unsigned long long>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr unsigned long long
> min() noexcept { return 0; }
>
> static constexpr unsigned long long
> max() noexcept { return 9223372036854775807LL * 2ULL + 1; }
>
>
> static constexpr unsigned long long
> lowest() noexcept { return min(); }
>
>
> static constexpr int digits
> = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
> static constexpr int digits10
> = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);
>
> static constexpr int max_digits10 = 0;
>
> static constexpr bool is_signed = false;
> static constexpr bool is_integer = true;
> static constexpr bool is_exact = true;
> static constexpr int radix = 2;
>
> static constexpr unsigned long long
> epsilon() noexcept { return 0; }
>
> static constexpr unsigned long long
> round_error() noexcept { return 0; }
>
> static constexpr int min_exponent = 0;
> static constexpr int min_exponent10 = 0;
> static constexpr int max_exponent = 0;
> static constexpr int max_exponent10 = 0;
>
> static constexpr bool has_infinity = false;
> static constexpr bool has_quiet_NaN = false;
> static constexpr bool has_signaling_NaN = false;
> static constexpr float_denorm_style has_denorm
> = denorm_absent;
> static constexpr bool has_denorm_loss = false;
>
> static constexpr unsigned long long
> infinity() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr unsigned long long
> quiet_NaN() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr unsigned long long
> signaling_NaN() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr unsigned long long
> denorm_min() noexcept
> { return static_cast<unsigned long long>(0); }
>
> static constexpr bool is_iec559 = false;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = true;
>
> static constexpr bool traps = true;
> static constexpr bool tinyness_before = false;
> static constexpr float_round_style round_style
> = round_toward_zero;
> };
># 1552 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/limits" 3
> template<>
> struct numeric_limits<float>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr float
> min() noexcept { return 1.17549435082228750797e-38F; }
>
> static constexpr float
> max() noexcept { return 3.40282346638528859812e+38F; }
>
>
> static constexpr float
> lowest() noexcept { return -3.40282346638528859812e+38F; }
>
>
> static constexpr int digits = 24;
> static constexpr int digits10 = 6;
>
> static constexpr int max_digits10
> = (2 + (24) * 643L / 2136);
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = false;
> static constexpr bool is_exact = false;
> static constexpr int radix = 2;
>
> static constexpr float
> epsilon() noexcept { return 1.19209289550781250000e-7F; }
>
> static constexpr float
> round_error() noexcept { return 0.5F; }
>
> static constexpr int min_exponent = (-125);
> static constexpr int min_exponent10 = (-37);
> static constexpr int max_exponent = 128;
> static constexpr int max_exponent10 = 38;
>
> static constexpr bool has_infinity = 1;
> static constexpr bool has_quiet_NaN = 1;
> static constexpr bool has_signaling_NaN = has_quiet_NaN;
> static constexpr float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
> static constexpr bool has_denorm_loss
> = false;
>
> static constexpr float
> infinity() noexcept { return __builtin_huge_valf(); }
>
> static constexpr float
> quiet_NaN() noexcept { return __builtin_nanf(""); }
>
> static constexpr float
> signaling_NaN() noexcept { return __builtin_nansf(""); }
>
> static constexpr float
> denorm_min() noexcept { return 1.40129846432481707092e-45F; }
>
> static constexpr bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = false;
> static constexpr bool tinyness_before
> = false;
> static constexpr float_round_style round_style
> = round_to_nearest;
> };
>
>
>
>
>
>
> template<>
> struct numeric_limits<double>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr double
> min() noexcept { return double(2.22507385850720138309e-308L); }
>
> static constexpr double
> max() noexcept { return double(1.79769313486231570815e+308L); }
>
>
> static constexpr double
> lowest() noexcept { return -double(1.79769313486231570815e+308L); }
>
>
> static constexpr int digits = 53;
> static constexpr int digits10 = 15;
>
> static constexpr int max_digits10
> = (2 + (53) * 643L / 2136);
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = false;
> static constexpr bool is_exact = false;
> static constexpr int radix = 2;
>
> static constexpr double
> epsilon() noexcept { return double(2.22044604925031308085e-16L); }
>
> static constexpr double
> round_error() noexcept { return 0.5; }
>
> static constexpr int min_exponent = (-1021);
> static constexpr int min_exponent10 = (-307);
> static constexpr int max_exponent = 1024;
> static constexpr int max_exponent10 = 308;
>
> static constexpr bool has_infinity = 1;
> static constexpr bool has_quiet_NaN = 1;
> static constexpr bool has_signaling_NaN = has_quiet_NaN;
> static constexpr float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
> static constexpr bool has_denorm_loss
> = false;
>
> static constexpr double
> infinity() noexcept { return __builtin_huge_val(); }
>
> static constexpr double
> quiet_NaN() noexcept { return __builtin_nan(""); }
>
> static constexpr double
> signaling_NaN() noexcept { return __builtin_nans(""); }
>
> static constexpr double
> denorm_min() noexcept { return double(4.94065645841246544177e-324L); }
>
> static constexpr bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = false;
> static constexpr bool tinyness_before
> = false;
> static constexpr float_round_style round_style
> = round_to_nearest;
> };
>
>
>
>
>
>
> template<>
> struct numeric_limits<long double>
> {
> static constexpr bool is_specialized = true;
>
> static constexpr long double
> min() noexcept { return 3.36210314311209350626e-4932L; }
>
> static constexpr long double
> max() noexcept { return 1.18973149535723176502e+4932L; }
>
>
> static constexpr long double
> lowest() noexcept { return -1.18973149535723176502e+4932L; }
>
>
> static constexpr int digits = 64;
> static constexpr int digits10 = 18;
>
> static constexpr int max_digits10
> = (2 + (64) * 643L / 2136);
>
> static constexpr bool is_signed = true;
> static constexpr bool is_integer = false;
> static constexpr bool is_exact = false;
> static constexpr int radix = 2;
>
> static constexpr long double
> epsilon() noexcept { return 1.08420217248550443401e-19L; }
>
> static constexpr long double
> round_error() noexcept { return 0.5L; }
>
> static constexpr int min_exponent = (-16381);
> static constexpr int min_exponent10 = (-4931);
> static constexpr int max_exponent = 16384;
> static constexpr int max_exponent10 = 4932;
>
> static constexpr bool has_infinity = 1;
> static constexpr bool has_quiet_NaN = 1;
> static constexpr bool has_signaling_NaN = has_quiet_NaN;
> static constexpr float_denorm_style has_denorm
> = bool(1) ? denorm_present : denorm_absent;
> static constexpr bool has_denorm_loss
> = false;
>
> static constexpr long double
> infinity() noexcept { return __builtin_huge_vall(); }
>
> static constexpr long double
> quiet_NaN() noexcept { return __builtin_nanl(""); }
>
> static constexpr long double
> signaling_NaN() noexcept { return __builtin_nansl(""); }
>
> static constexpr long double
> denorm_min() noexcept { return 3.64519953188247460253e-4951L; }
>
> static constexpr bool is_iec559
> = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
> static constexpr bool is_bounded = true;
> static constexpr bool is_modulo = false;
>
> static constexpr bool traps = false;
> static constexpr bool tinyness_before =
> false;
> static constexpr float_round_style round_style =
> round_to_nearest;
> };
>
>
>
>
>
>
>}
># 44 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 2 3
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 1 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/vector" 1 3
># 59 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/vector" 3
> 
># 60 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/vector" 3
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_uninitialized.h" 1 3
># 61 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_uninitialized.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<bool _TrivialValueTypes>
> struct __uninitialized_copy
> {
> template<typename _InputIterator, typename _ForwardIterator>
> static _ForwardIterator
> __uninit_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for (; __first != __last; ++__first, ++__cur)
> std::_Construct(std::__addressof(*__cur), *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_copy<true>
> {
> template<typename _InputIterator, typename _ForwardIterator>
> static _ForwardIterator
> __uninit_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> { return std::copy(__first, __last, __result); }
> };
># 107 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_uninitialized.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> inline _ForwardIterator
> uninitialized_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result)
> {
> typedef typename iterator_traits<_InputIterator>::value_type
> _ValueType1;
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType2;
>
> return std::__uninitialized_copy<(__is_trivial(_ValueType1)
> && __is_trivial(_ValueType2))>::
> __uninit_copy(__first, __last, __result);
> }
>
>
> template<bool _TrivialValueType>
> struct __uninitialized_fill
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __cur != __last; ++__cur)
> std::_Construct(std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_fill<true>
> {
> template<typename _ForwardIterator, typename _Tp>
> static void
> __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> { std::fill(__first, __last, __x); }
> };
># 164 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_uninitialized.h" 3
> template<typename _ForwardIterator, typename _Tp>
> inline void
> uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_fill<__is_trivial(_ValueType)>::
> __uninit_fill(__first, __last, __x);
> }
>
>
> template<bool _TrivialValueType>
> struct __uninitialized_fill_n
> {
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> static void
> __uninit_fill_n(_ForwardIterator __first, _Size __n,
> const _Tp& __x)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __n > 0; --__n, ++__cur)
> std::_Construct(std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_fill_n<true>
> {
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> static void
> __uninit_fill_n(_ForwardIterator __first, _Size __n,
> const _Tp& __x)
> { std::fill_n(__first, __n, __x); }
> };
># 218 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_uninitialized.h" 3
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline void
> uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_fill_n<__is_trivial(_ValueType)>::
> __uninit_fill_n(__first, __n, __x);
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> _ForwardIterator
> __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, _Allocator& __alloc)
> {
> _ForwardIterator __cur = __result;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __first != __last; ++__first, ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur), *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
> inline _ForwardIterator
> __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, allocator<_Tp>&)
> { return std::uninitialized_copy(__first, __last, __result); }
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, _Allocator& __alloc)
> {
> return std::__uninitialized_copy_a(std::make_move_iterator(__first),
> std::make_move_iterator(__last),
> __result, __alloc);
> }
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_move_if_noexcept_a(_InputIterator __first,
> _InputIterator __last,
> _ForwardIterator __result,
> _Allocator& __alloc)
> {
> return std::__uninitialized_copy_a
> (std::__make_move_if_noexcept_iterator(__first),
> std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Allocator>
> void
> __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __cur != __last; ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Tp, typename _Tp2>
> inline void
> __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __x, allocator<_Tp2>&)
> { std::uninitialized_fill(__first, __last, __x); }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp,
> typename _Allocator>
> void
> __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
> const _Tp& __x, _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __n > 0; --__n, ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur), __x);
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp,
> typename _Tp2>
> inline void
> __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
> const _Tp& __x, allocator<_Tp2>&)
> { std::uninitialized_fill_n(__first, __n, __x); }
># 348 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_uninitialized.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _ForwardIterator, typename _Allocator>
> inline _ForwardIterator
> __uninitialized_copy_move(_InputIterator1 __first1,
> _InputIterator1 __last1,
> _InputIterator2 __first2,
> _InputIterator2 __last2,
> _ForwardIterator __result,
> _Allocator& __alloc)
> {
> _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
> __result,
> __alloc);
> try
> {
> return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _ForwardIterator, typename _Allocator>
> inline _ForwardIterator
> __uninitialized_move_copy(_InputIterator1 __first1,
> _InputIterator1 __last1,
> _InputIterator2 __first2,
> _InputIterator2 __last2,
> _ForwardIterator __result,
> _Allocator& __alloc)
> {
> _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
> __result,
> __alloc);
> try
> {
> return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
> template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
> typename _Allocator>
> inline _ForwardIterator
> __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
> const _Tp& __x, _InputIterator __first,
> _InputIterator __last, _Allocator& __alloc)
> {
> std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
> try
> {
> return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__result, __mid, __alloc);
> throw;
> }
> }
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
> typename _Allocator>
> inline void
> __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
> _ForwardIterator __first2,
> _ForwardIterator __last2, const _Tp& __x,
> _Allocator& __alloc)
> {
> _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
> __first2,
> __alloc);
> try
> {
> std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
> }
> catch(...)
> {
> std::_Destroy(__first2, __mid2, __alloc);
> throw;
> }
> }
>
>
>
>
>
> template<bool _TrivialValueType>
> struct __uninitialized_default_1
> {
> template<typename _ForwardIterator>
> static void
> __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __cur != __last; ++__cur)
> std::_Construct(std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_default_1<true>
> {
> template<typename _ForwardIterator>
> static void
> __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::fill(__first, __last, _ValueType());
> }
> };
>
> template<bool _TrivialValueType>
> struct __uninitialized_default_n_1
> {
> template<typename _ForwardIterator, typename _Size>
> static void
> __uninit_default_n(_ForwardIterator __first, _Size __n)
> {
> _ForwardIterator __cur = __first;
> try
> {
> for (; __n > 0; --__n, ++__cur)
> std::_Construct(std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur);
> throw;
> }
> }
> };
>
> template<>
> struct __uninitialized_default_n_1<true>
> {
> template<typename _ForwardIterator, typename _Size>
> static void
> __uninit_default_n(_ForwardIterator __first, _Size __n)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::fill_n(__first, __n, _ValueType());
> }
> };
>
>
>
>
> template<typename _ForwardIterator>
> inline void
> __uninitialized_default(_ForwardIterator __first,
> _ForwardIterator __last)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_default_1<__is_trivial(_ValueType)>::
> __uninit_default(__first, __last);
> }
>
>
>
> template<typename _ForwardIterator, typename _Size>
> inline void
> __uninitialized_default_n(_ForwardIterator __first, _Size __n)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
>
> std::__uninitialized_default_n_1<__is_trivial(_ValueType)>::
> __uninit_default_n(__first, __n);
> }
>
>
>
>
>
> template<typename _ForwardIterator, typename _Allocator>
> void
> __uninitialized_default_a(_ForwardIterator __first,
> _ForwardIterator __last,
> _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __cur != __last; ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Tp>
> inline void
> __uninitialized_default_a(_ForwardIterator __first,
> _ForwardIterator __last,
> allocator<_Tp>&)
> { std::__uninitialized_default(__first, __last); }
>
>
>
>
>
> template<typename _ForwardIterator, typename _Size, typename _Allocator>
> void
> __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
> _Allocator& __alloc)
> {
> _ForwardIterator __cur = __first;
> try
> {
> typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
> for (; __n > 0; --__n, ++__cur)
> __traits::construct(__alloc, std::__addressof(*__cur));
> }
> catch(...)
> {
> std::_Destroy(__first, __cur, __alloc);
> throw;
> }
> }
>
> template<typename _ForwardIterator, typename _Size, typename _Tp>
> inline void
> __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
> allocator<_Tp>&)
> { std::__uninitialized_default_n(__first, __n); }
>
>
> template<typename _InputIterator, typename _Size,
> typename _ForwardIterator>
> _ForwardIterator
> __uninitialized_copy_n(_InputIterator __first, _Size __n,
> _ForwardIterator __result, input_iterator_tag)
> {
> _ForwardIterator __cur = __result;
> try
> {
> for (; __n > 0; --__n, ++__first, ++__cur)
> std::_Construct(std::__addressof(*__cur), *__first);
> return __cur;
> }
> catch(...)
> {
> std::_Destroy(__result, __cur);
> throw;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Size,
> typename _ForwardIterator>
> inline _ForwardIterator
> __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
> _ForwardIterator __result,
> random_access_iterator_tag)
> { return std::uninitialized_copy(__first, __first + __n, __result); }
># 647 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_uninitialized.h" 3
> template<typename _InputIterator, typename _Size, typename _ForwardIterator>
> inline _ForwardIterator
> uninitialized_copy_n(_InputIterator __first, _Size __n,
> _ForwardIterator __result)
> { return std::__uninitialized_copy_n(__first, __n, __result,
> std::__iterator_category(__first)); }
>
>
>
>}
># 65 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/vector" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 1 3
># 67 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Tp, typename _Alloc>
> struct _Vector_base
> {
> typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
> rebind<_Tp>::other _Tp_alloc_type;
> typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
> pointer;
>
> struct _Vector_impl
> : public _Tp_alloc_type
> {
> pointer _M_start;
> pointer _M_finish;
> pointer _M_end_of_storage;
>
> _Vector_impl()
> : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
> { }
>
> _Vector_impl(_Tp_alloc_type const& __a)
> : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
> { }
>
>
> _Vector_impl(_Tp_alloc_type&& __a)
> : _Tp_alloc_type(std::move(__a)),
> _M_start(0), _M_finish(0), _M_end_of_storage(0)
> { }
>
>
> void _M_swap_data(_Vector_impl& __x)
> {
> std::swap(_M_start, __x._M_start);
> std::swap(_M_finish, __x._M_finish);
> std::swap(_M_end_of_storage, __x._M_end_of_storage);
> }
> };
>
> public:
> typedef _Alloc allocator_type;
>
> _Tp_alloc_type&
> _M_get_Tp_allocator() noexcept
> { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
>
> const _Tp_alloc_type&
> _M_get_Tp_allocator() const noexcept
> { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Tp_allocator()); }
>
> _Vector_base()
> : _M_impl() { }
>
> _Vector_base(const allocator_type& __a)
> : _M_impl(__a) { }
>
> _Vector_base(size_t __n)
> : _M_impl()
> { _M_create_storage(__n); }
>
> _Vector_base(size_t __n, const allocator_type& __a)
> : _M_impl(__a)
> { _M_create_storage(__n); }
>
>
> _Vector_base(_Tp_alloc_type&& __a)
> : _M_impl(std::move(__a)) { }
>
> _Vector_base(_Vector_base&& __x)
> : _M_impl(std::move(__x._M_get_Tp_allocator()))
> { this->_M_impl._M_swap_data(__x._M_impl); }
>
> _Vector_base(_Vector_base&& __x, const allocator_type& __a)
> : _M_impl(__a)
> {
> if (__x.get_allocator() == __a)
> this->_M_impl._M_swap_data(__x._M_impl);
> else
> {
> size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start;
> _M_create_storage(__n);
> }
> }
>
>
> ~_Vector_base()
> { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start); }
>
> public:
> _Vector_impl _M_impl;
>
> pointer
> _M_allocate(size_t __n)
> { return __n != 0 ? _M_impl.allocate(__n) : 0; }
>
> void
> _M_deallocate(pointer __p, size_t __n)
> {
> if (__p)
> _M_impl.deallocate(__p, __n);
> }
>
> private:
> void
> _M_create_storage(size_t __n)
> {
> this->_M_impl._M_start = this->_M_allocate(__n);
> this->_M_impl._M_finish = this->_M_impl._M_start;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> }
> };
># 207 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
> class vector : protected _Vector_base<_Tp, _Alloc>
> {
>
> typedef typename _Alloc::value_type _Alloc_value_type;
> 
> 
>
> typedef _Vector_base<_Tp, _Alloc> _Base;
> typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
> typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
>
> public:
> typedef _Tp value_type;
> typedef typename _Base::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 __gnu_cxx::__normal_iterator<pointer, vector> iterator;
> typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
> const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Alloc allocator_type;
>
> protected:
> using _Base::_M_allocate;
> using _Base::_M_deallocate;
> using _Base::_M_impl;
> using _Base::_M_get_Tp_allocator;
>
> public:
>
>
>
>
>
> vector()
> : _Base() { }
>
>
>
>
>
> explicit
> vector(const allocator_type& __a)
> : _Base(__a) { }
># 265 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> explicit
> vector(size_type __n)
> : _Base(__n)
> { _M_default_initialize(__n); }
># 278 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> vector(size_type __n, const value_type& __value,
> const allocator_type& __a = allocator_type())
> : _Base(__n, __a)
> { _M_fill_initialize(__n, __value); }
># 307 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> vector(const vector& __x)
> : _Base(__x.size(),
> _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
> { this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__x.begin(), __x.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
># 324 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> vector(vector&& __x) noexcept
> : _Base(std::move(__x)) { }
>
>
> vector(const vector& __x, const allocator_type& __a)
> : _Base(__x.size(), __a)
> { this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__x.begin(), __x.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
>
>
> vector(vector&& __rv, const allocator_type& __m)
> : _Base(std::move(__rv), __m)
> {
> if (__rv.get_allocator() != __m)
> {
> this->_M_impl._M_finish =
> std::__uninitialized_move_a(__rv.begin(), __rv.end(),
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> __rv.clear();
> }
> }
># 361 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> vector(initializer_list<value_type> __l,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> _M_range_initialize(__l.begin(), __l.end(),
> random_access_iterator_tag());
> }
># 386 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename _InputIterator>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_initialize_dispatch(__first, __last, _Integral());
> }
>
>
>
>
>
>
>
> ~vector() noexcept
> { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator()); }
># 414 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> vector&
> operator=(const vector& __x);
># 426 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> vector&
> operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
> {
> constexpr bool __move_storage =
> _Alloc_traits::_S_propagate_on_move_assign()
> || _Alloc_traits::_S_always_equal();
> _M_move_assign(std::move(__x),
> integral_constant<bool, __move_storage>());
> return *this;
> }
># 448 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> vector&
> operator=(initializer_list<value_type> __l)
> {
> this->assign(__l.begin(), __l.end());
> return *this;
> }
># 466 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 482 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
># 503 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> assign(initializer_list<value_type> __l)
> { this->assign(__l.begin(), __l.end()); }
>
>
>
> using _Base::get_allocator;
>
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return const_iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> iterator
> end() noexcept
> { return iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return const_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(this->_M_impl._M_start); }
>
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return const_iterator(this->_M_impl._M_finish); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
> size_type
> size() const noexcept
> { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
>
>
> size_type
> max_size() const noexcept
> { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
># 643 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> resize(size_type __new_size)
> {
> if (__new_size > size())
> _M_default_append(__new_size - size());
> else if (__new_size < size())
> _M_erase_at_end(this->_M_impl._M_start + __new_size);
> }
># 663 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> resize(size_type __new_size, const value_type& __x)
> {
> if (__new_size > size())
> insert(end(), __new_size - size(), __x);
> else if (__new_size < size())
> _M_erase_at_end(this->_M_impl._M_start + __new_size);
> }
># 695 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> shrink_to_fit()
> { _M_shrink_to_fit(); }
>
>
>
>
>
>
> size_type
> capacity() const noexcept
> { return size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start); }
>
>
>
>
>
> bool
> empty() const noexcept
> { return begin() == end(); }
># 734 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> reserve(size_type __n);
># 749 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> reference
> operator[](size_type __n)
> { return *(this->_M_impl._M_start + __n); }
># 764 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> const_reference
> operator[](size_type __n) const
> { return *(this->_M_impl._M_start + __n); }
>
> protected:
>
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("vector::_M_range_check"));
> }
>
> public:
># 789 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> reference
> at(size_type __n)
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
># 807 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> const_reference
> at(size_type __n) const
> {
> _M_range_check(__n);
> return (*this)[__n];
> }
>
>
>
>
>
> reference
> front()
> { return *begin(); }
>
>
>
>
>
> const_reference
> front() const
> { return *begin(); }
>
>
>
>
>
> reference
> back()
> { return *(end() - 1); }
>
>
>
>
>
> const_reference
> back() const
> { return *(end() - 1); }
># 854 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> _Tp*
>
>
>
> data() noexcept
> { return std::__addressof(front()); }
>
>
> const _Tp*
>
>
>
> data() const noexcept
> { return std::__addressof(front()); }
># 880 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> push_back(const value_type& __x)
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> __x);
> ++this->_M_impl._M_finish;
> }
> else
>
> _M_emplace_back_aux(__x);
>
>
>
> }
>
>
> void
> push_back(value_type&& __x)
> { emplace_back(std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace_back(_Args&&... __args);
># 916 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> pop_back()
> {
> --this->_M_impl._M_finish;
> _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
> }
># 936 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename... _Args>
> iterator
> emplace(iterator __position, _Args&&... __args);
># 952 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> iterator
> insert(iterator __position, const value_type& __x);
># 967 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> iterator
> insert(iterator __position, value_type&& __x)
> { return emplace(__position, std::move(__x)); }
># 984 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> insert(iterator __position, initializer_list<value_type> __l)
> { this->insert(__position, __l.begin(), __l.end()); }
># 1002 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> insert(iterator __position, size_type __n, const value_type& __x)
> { _M_fill_insert(__position, __n, __x); }
># 1020 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename _InputIterator>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
># 1045 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> iterator
> erase(iterator __position);
># 1066 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> iterator
> erase(iterator __first, iterator __last);
># 1078 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> void
> swap(vector& __x)
>
> noexcept(_Alloc_traits::_S_nothrow_swap())
>
> {
> this->_M_impl._M_swap_data(__x._M_impl);
> _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
> __x._M_get_Tp_allocator());
> }
>
>
>
>
>
>
>
> void
> clear() noexcept
> { _M_erase_at_end(this->_M_impl._M_start); }
>
> protected:
>
>
>
>
> template<typename _ForwardIterator>
> pointer
> _M_allocate_and_copy(size_type __n,
> _ForwardIterator __first, _ForwardIterator __last)
> {
> pointer __result = this->_M_allocate(__n);
> try
> {
> std::__uninitialized_copy_a(__first, __last, __result,
> _M_get_Tp_allocator());
> return __result;
> }
> catch(...)
> {
> _M_deallocate(__result, __n);
> throw;
> }
> }
># 1130 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
> {
> this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
> this->_M_impl._M_end_of_storage =
> this->_M_impl._M_start + static_cast<size_type>(__n);
> _M_fill_initialize(static_cast<size_type>(__n), __value);
> }
>
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_initialize(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_initialize(_InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> push_back(*__first);
> }
>
>
> template<typename _ForwardIterator>
> void
> _M_range_initialize(_ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> this->_M_impl._M_start = this->_M_allocate(__n);
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__first, __last,
> this->_M_impl._M_start,
> _M_get_Tp_allocator());
> }
>
>
>
> void
> _M_fill_initialize(size_type __n, const value_type& __value)
> {
> std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
> }
>
>
>
> void
> _M_default_initialize(size_type __n)
> {
> std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
> }
># 1204 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign(__n, __val); }
>
>
> template<typename _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_assign_aux(__first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag);
>
>
>
> void
> _M_fill_assign(size_type __n, const value_type& __val);
># 1244 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
> __true_type)
> { _M_fill_insert(__pos, __n, __val); }
>
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos, _InputIterator __first,
> _InputIterator __last, __false_type)
> {
> typedef typename std::iterator_traits<_InputIterator>::
> iterator_category _IterCategory;
> _M_range_insert(__pos, __first, __last, _IterCategory());
> }
>
>
> template<typename _InputIterator>
> void
> _M_range_insert(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag);
>
>
> template<typename _ForwardIterator>
> void
> _M_range_insert(iterator __pos, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag);
>
>
>
> void
> _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
>
>
>
> void
> _M_default_append(size_type __n);
>
> bool
> _M_shrink_to_fit();
>
>
>
>
>
>
>
> template<typename... _Args>
> void
> _M_insert_aux(iterator __position, _Args&&... __args);
>
> template<typename... _Args>
> void
> _M_emplace_back_aux(_Args&&... __args);
>
>
>
> size_type
> _M_check_len(size_type __n, const char* __s) const
> {
> if (max_size() - size() < __n)
> __throw_length_error((__s));
>
> const size_type __len = size() + std::max(size(), __n);
> return (__len < size() || __len > max_size()) ? max_size() : __len;
> }
>
>
>
>
>
> void
> _M_erase_at_end(pointer __pos)
> {
> std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
> this->_M_impl._M_finish = __pos;
> }
>
>
> private:
>
>
>
> void
> _M_move_assign(vector&& __x, std::true_type) noexcept
> {
> const vector __tmp(std::move(*this));
> this->_M_impl._M_swap_data(__x._M_impl);
> if (_Alloc_traits::_S_propagate_on_move_assign())
> std::__alloc_on_move(_M_get_Tp_allocator(),
> __x._M_get_Tp_allocator());
> }
>
>
>
> void
> _M_move_assign(vector&& __x, std::false_type)
> {
> if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
> _M_move_assign(std::move(__x), std::true_type());
> else
> {
>
>
> this->assign(std::__make_move_if_noexcept_iterator(__x.begin()),
> std::__make_move_if_noexcept_iterator(__x.end()));
> __x.clear();
> }
> }
>
> };
># 1368 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return (__x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin())); }
># 1385 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_vector.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return std::lexicographical_compare(__x.begin(), __x.end(),
> __y.begin(), __y.end()); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline void
> swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
> { __x.swap(__y); }
>
>
>}
># 66 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/vector" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_bvector.h" 1 3
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_bvector.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> typedef unsigned long _Bit_type;
> enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
>
> struct _Bit_reference
> {
> _Bit_type * _M_p;
> _Bit_type _M_mask;
>
> _Bit_reference(_Bit_type * __x, _Bit_type __y)
> : _M_p(__x), _M_mask(__y) { }
>
> _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }
>
> operator bool() const noexcept
> { return !!(*_M_p & _M_mask); }
>
> _Bit_reference&
> operator=(bool __x) noexcept
> {
> if (__x)
> *_M_p |= _M_mask;
> else
> *_M_p &= ~_M_mask;
> return *this;
> }
>
> _Bit_reference&
> operator=(const _Bit_reference& __x) noexcept
> { return *this = bool(__x); }
>
> bool
> operator==(const _Bit_reference& __x) const
> { return bool(*this) == bool(__x); }
>
> bool
> operator<(const _Bit_reference& __x) const
> { return !bool(*this) && bool(__x); }
>
> void
> flip() noexcept
> { *_M_p ^= _M_mask; }
> };
>
> struct _Bit_iterator_base
> : public std::iterator<std::random_access_iterator_tag, bool>
> {
> _Bit_type * _M_p;
> unsigned int _M_offset;
>
> _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
> : _M_p(__x), _M_offset(__y) { }
>
> void
> _M_bump_up()
> {
> if (_M_offset++ == int(_S_word_bit) - 1)
> {
> _M_offset = 0;
> ++_M_p;
> }
> }
>
> void
> _M_bump_down()
> {
> if (_M_offset-- == 0)
> {
> _M_offset = int(_S_word_bit) - 1;
> --_M_p;
> }
> }
>
> void
> _M_incr(ptrdiff_t __i)
> {
> difference_type __n = __i + _M_offset;
> _M_p += __n / int(_S_word_bit);
> __n = __n % int(_S_word_bit);
> if (__n < 0)
> {
> __n += int(_S_word_bit);
> --_M_p;
> }
> _M_offset = static_cast<unsigned int>(__n);
> }
>
> bool
> operator==(const _Bit_iterator_base& __i) const
> { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
>
> bool
> operator<(const _Bit_iterator_base& __i) const
> {
> return _M_p < __i._M_p
> || (_M_p == __i._M_p && _M_offset < __i._M_offset);
> }
>
> bool
> operator!=(const _Bit_iterator_base& __i) const
> { return !(*this == __i); }
>
> bool
> operator>(const _Bit_iterator_base& __i) const
> { return __i < *this; }
>
> bool
> operator<=(const _Bit_iterator_base& __i) const
> { return !(__i < *this); }
>
> bool
> operator>=(const _Bit_iterator_base& __i) const
> { return !(*this < __i); }
> };
>
> inline ptrdiff_t
> operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
> {
> return (int(_S_word_bit) * (__x._M_p - __y._M_p)
> + __x._M_offset - __y._M_offset);
> }
>
> struct _Bit_iterator : public _Bit_iterator_base
> {
> typedef _Bit_reference reference;
> typedef _Bit_reference* pointer;
> typedef _Bit_iterator iterator;
>
> _Bit_iterator() : _Bit_iterator_base(0, 0) { }
>
> _Bit_iterator(_Bit_type * __x, unsigned int __y)
> : _Bit_iterator_base(__x, __y) { }
>
> reference
> operator*() const
> { return reference(_M_p, 1UL << _M_offset); }
>
> iterator&
> operator++()
> {
> _M_bump_up();
> return *this;
> }
>
> iterator
> operator++(int)
> {
> iterator __tmp = *this;
> _M_bump_up();
> return __tmp;
> }
>
> iterator&
> operator--()
> {
> _M_bump_down();
> return *this;
> }
>
> iterator
> operator--(int)
> {
> iterator __tmp = *this;
> _M_bump_down();
> return __tmp;
> }
>
> iterator&
> operator+=(difference_type __i)
> {
> _M_incr(__i);
> return *this;
> }
>
> iterator&
> operator-=(difference_type __i)
> {
> *this += -__i;
> return *this;
> }
>
> iterator
> operator+(difference_type __i) const
> {
> iterator __tmp = *this;
> return __tmp += __i;
> }
>
> iterator
> operator-(difference_type __i) const
> {
> iterator __tmp = *this;
> return __tmp -= __i;
> }
>
> reference
> operator[](difference_type __i) const
> { return *(*this + __i); }
> };
>
> inline _Bit_iterator
> operator+(ptrdiff_t __n, const _Bit_iterator& __x)
> { return __x + __n; }
>
> struct _Bit_const_iterator : public _Bit_iterator_base
> {
> typedef bool reference;
> typedef bool const_reference;
> typedef const bool* pointer;
> typedef _Bit_const_iterator const_iterator;
>
> _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
>
> _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
> : _Bit_iterator_base(__x, __y) { }
>
> _Bit_const_iterator(const _Bit_iterator& __x)
> : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
>
> const_reference
> operator*() const
> { return _Bit_reference(_M_p, 1UL << _M_offset); }
>
> const_iterator&
> operator++()
> {
> _M_bump_up();
> return *this;
> }
>
> const_iterator
> operator++(int)
> {
> const_iterator __tmp = *this;
> _M_bump_up();
> return __tmp;
> }
>
> const_iterator&
> operator--()
> {
> _M_bump_down();
> return *this;
> }
>
> const_iterator
> operator--(int)
> {
> const_iterator __tmp = *this;
> _M_bump_down();
> return __tmp;
> }
>
> const_iterator&
> operator+=(difference_type __i)
> {
> _M_incr(__i);
> return *this;
> }
>
> const_iterator&
> operator-=(difference_type __i)
> {
> *this += -__i;
> return *this;
> }
>
> const_iterator
> operator+(difference_type __i) const
> {
> const_iterator __tmp = *this;
> return __tmp += __i;
> }
>
> const_iterator
> operator-(difference_type __i) const
> {
> const_iterator __tmp = *this;
> return __tmp -= __i;
> }
>
> const_reference
> operator[](difference_type __i) const
> { return *(*this + __i); }
> };
>
> inline _Bit_const_iterator
> operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
> { return __x + __n; }
>
> inline void
> __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
> {
> for (; __first != __last; ++__first)
> *__first = __x;
> }
>
> inline void
> fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
> {
> if (__first._M_p != __last._M_p)
> {
> std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
> __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
> __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
> }
> else
> __fill_bvector(__first, __last, __x);
> }
>
> template<typename _Alloc>
> struct _Bvector_base
> {
> typedef typename _Alloc::template rebind<_Bit_type>::other
> _Bit_alloc_type;
>
> struct _Bvector_impl
> : public _Bit_alloc_type
> {
> _Bit_iterator _M_start;
> _Bit_iterator _M_finish;
> _Bit_type* _M_end_of_storage;
>
> _Bvector_impl()
> : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
> { }
>
> _Bvector_impl(const _Bit_alloc_type& __a)
> : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
> { }
>
>
> _Bvector_impl(_Bit_alloc_type&& __a)
> : _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
> _M_end_of_storage(0)
> { }
>
> };
>
> public:
> typedef _Alloc allocator_type;
>
> _Bit_alloc_type&
> _M_get_Bit_allocator() noexcept
> { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
>
> const _Bit_alloc_type&
> _M_get_Bit_allocator() const noexcept
> { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
>
> allocator_type
> get_allocator() const noexcept
> { return allocator_type(_M_get_Bit_allocator()); }
>
> _Bvector_base()
> : _M_impl() { }
>
> _Bvector_base(const allocator_type& __a)
> : _M_impl(__a) { }
>
>
> _Bvector_base(_Bvector_base&& __x) noexcept
> : _M_impl(std::move(__x._M_get_Bit_allocator()))
> {
> this->_M_impl._M_start = __x._M_impl._M_start;
> this->_M_impl._M_finish = __x._M_impl._M_finish;
> this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
> __x._M_impl._M_start = _Bit_iterator();
> __x._M_impl._M_finish = _Bit_iterator();
> __x._M_impl._M_end_of_storage = 0;
> }
>
>
> ~_Bvector_base()
> { this->_M_deallocate(); }
>
> protected:
> _Bvector_impl _M_impl;
>
> _Bit_type*
> _M_allocate(size_t __n)
> { return _M_impl.allocate(_S_nword(__n)); }
>
> void
> _M_deallocate()
> {
> if (_M_impl._M_start._M_p)
> _M_impl.deallocate(_M_impl._M_start._M_p,
> _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
> }
>
> static size_t
> _S_nword(size_t __n)
> { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
> };
>
>
>}
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 490 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_bvector.h" 3
>template<typename _Alloc>
> class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
> {
> typedef _Bvector_base<_Alloc> _Base;
>
>
> template<typename> friend class hash;
>
>
> public:
> typedef bool value_type;
> typedef size_t size_type;
> typedef ptrdiff_t difference_type;
> typedef _Bit_reference reference;
> typedef bool const_reference;
> typedef _Bit_reference* pointer;
> typedef const bool* const_pointer;
> typedef _Bit_iterator iterator;
> typedef _Bit_const_iterator const_iterator;
> typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<iterator> reverse_iterator;
> typedef _Alloc allocator_type;
>
> allocator_type get_allocator() const
> { return _Base::get_allocator(); }
>
> protected:
> using _Base::_M_allocate;
> using _Base::_M_deallocate;
> using _Base::_S_nword;
> using _Base::_M_get_Bit_allocator;
>
> public:
> vector()
> : _Base() { }
>
> explicit
> vector(const allocator_type& __a)
> : _Base(__a) { }
>
> explicit
> vector(size_type __n, const bool& __value = bool(),
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> _M_initialize(__n);
> std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
> __value ? ~0 : 0);
> }
>
> vector(const vector& __x)
> : _Base(__x._M_get_Bit_allocator())
> {
> _M_initialize(__x.size());
> _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
> }
>
>
> vector(vector&& __x) noexcept
> : _Base(std::move(__x)) { }
>
> vector(initializer_list<bool> __l,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> _M_initialize_range(__l.begin(), __l.end(),
> random_access_iterator_tag());
> }
>
>
> template<typename _InputIterator>
> vector(_InputIterator __first, _InputIterator __last,
> const allocator_type& __a = allocator_type())
> : _Base(__a)
> {
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_initialize_dispatch(__first, __last, _Integral());
> }
>
> ~vector() noexcept { }
>
> vector&
> operator=(const vector& __x)
> {
> if (&__x == this)
> return *this;
> if (__x.size() > capacity())
> {
> this->_M_deallocate();
> _M_initialize(__x.size());
> }
> this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
> begin());
> return *this;
> }
>
>
> vector&
> operator=(vector&& __x)
> {
>
>
> this->clear();
> this->swap(__x);
> return *this;
> }
>
> vector&
> operator=(initializer_list<bool> __l)
> {
> this->assign (__l.begin(), __l.end());
> return *this;
> }
>
>
>
>
>
>
> void
> assign(size_type __n, const bool& __x)
> { _M_fill_assign(__n, __x); }
>
> template<typename _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
>
>
> void
> assign(initializer_list<bool> __l)
> { this->assign(__l.begin(), __l.end()); }
>
>
> iterator
> begin() noexcept
> { return this->_M_impl._M_start; }
>
> const_iterator
> begin() const noexcept
> { return this->_M_impl._M_start; }
>
> iterator
> end() noexcept
> { return this->_M_impl._M_finish; }
>
> const_iterator
> end() const noexcept
> { return this->_M_impl._M_finish; }
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
> const_iterator
> cbegin() const noexcept
> { return this->_M_impl._M_start; }
>
> const_iterator
> cend() const noexcept
> { return this->_M_impl._M_finish; }
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
> size_type
> size() const noexcept
> { return size_type(end() - begin()); }
>
> size_type
> max_size() const noexcept
> {
> const size_type __isize =
> __gnu_cxx::__numeric_traits<difference_type>::__max
> - int(_S_word_bit) + 1;
> const size_type __asize = _M_get_Bit_allocator().max_size();
> return (__asize <= __isize / int(_S_word_bit)
> ? __asize * int(_S_word_bit) : __isize);
> }
>
> size_type
> capacity() const noexcept
> { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
> - begin()); }
>
> bool
> empty() const noexcept
> { return begin() == end(); }
>
> reference
> operator[](size_type __n)
> {
> return *iterator(this->_M_impl._M_start._M_p
> + __n / int(_S_word_bit), __n % int(_S_word_bit));
> }
>
> const_reference
> operator[](size_type __n) const
> {
> return *const_iterator(this->_M_impl._M_start._M_p
> + __n / int(_S_word_bit), __n % int(_S_word_bit));
> }
>
> protected:
> void
> _M_range_check(size_type __n) const
> {
> if (__n >= this->size())
> __throw_out_of_range(("vector<bool>::_M_range_check"));
> }
>
> public:
> reference
> at(size_type __n)
> { _M_range_check(__n); return (*this)[__n]; }
>
> const_reference
> at(size_type __n) const
> { _M_range_check(__n); return (*this)[__n]; }
>
> void
> reserve(size_type __n)
> {
> if (__n > max_size())
> __throw_length_error(("vector::reserve"));
> if (capacity() < __n)
> _M_reallocate(__n);
> }
>
> reference
> front()
> { return *begin(); }
>
> const_reference
> front() const
> { return *begin(); }
>
> reference
> back()
> { return *(end() - 1); }
>
> const_reference
> back() const
> { return *(end() - 1); }
>
>
>
>
>
>
> void
> data() noexcept { }
>
> void
> push_back(bool __x)
> {
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
> *this->_M_impl._M_finish++ = __x;
> else
> _M_insert_aux(end(), __x);
> }
>
> void
> swap(vector& __x)
> {
> std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
> std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
> std::swap(this->_M_impl._M_end_of_storage,
> __x._M_impl._M_end_of_storage);
>
>
>
> std::__alloc_swap<typename _Base::_Bit_alloc_type>::
> _S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
> }
>
>
> static void
> swap(reference __x, reference __y) noexcept
> {
> bool __tmp = __x;
> __x = __y;
> __y = __tmp;
> }
>
> iterator
> insert(iterator __position, const bool& __x = bool())
> {
> const difference_type __n = __position - begin();
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
> && __position == end())
> *this->_M_impl._M_finish++ = __x;
> else
> _M_insert_aux(__position, __x);
> return begin() + __n;
> }
>
> template<typename _InputIterator>
> void
> insert(iterator __position,
> _InputIterator __first, _InputIterator __last)
> {
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_insert_dispatch(__position, __first, __last, _Integral());
> }
>
> void
> insert(iterator __position, size_type __n, const bool& __x)
> { _M_fill_insert(__position, __n, __x); }
>
>
> void insert(iterator __p, initializer_list<bool> __l)
> { this->insert(__p, __l.begin(), __l.end()); }
>
>
> void
> pop_back()
> { --this->_M_impl._M_finish; }
>
> iterator
> erase(iterator __position)
> {
> if (__position + 1 != end())
> std::copy(__position + 1, end(), __position);
> --this->_M_impl._M_finish;
> return __position;
> }
>
> iterator
> erase(iterator __first, iterator __last)
> {
> if (__first != __last)
> _M_erase_at_end(std::copy(__last, end(), __first));
> return __first;
> }
>
> void
> resize(size_type __new_size, bool __x = bool())
> {
> if (__new_size < size())
> _M_erase_at_end(begin() + difference_type(__new_size));
> else
> insert(end(), __new_size - size(), __x);
> }
>
>
> void
> shrink_to_fit()
> { _M_shrink_to_fit(); }
>
>
> void
> flip() noexcept
> {
> for (_Bit_type * __p = this->_M_impl._M_start._M_p;
> __p != this->_M_impl._M_end_of_storage; ++__p)
> *__p = ~*__p;
> }
>
> void
> clear() noexcept
> { _M_erase_at_end(begin()); }
>
>
> protected:
>
> iterator
> _M_copy_aligned(const_iterator __first, const_iterator __last,
> iterator __result)
> {
> _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
> return std::copy(const_iterator(__last._M_p, 0), __last,
> iterator(__q, 0));
> }
>
> void
> _M_initialize(size_type __n)
> {
> _Bit_type* __q = this->_M_allocate(__n);
> this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
> this->_M_impl._M_start = iterator(__q, 0);
> this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
> }
>
> void
> _M_reallocate(size_type __n);
>
>
> bool
> _M_shrink_to_fit();
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> {
> _M_initialize(static_cast<size_type>(__n));
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> }
>
> template<typename _InputIterator>
> void
> _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_initialize_range(__first, __last,
> std::__iterator_category(__first)); }
>
> template<typename _InputIterator>
> void
> _M_initialize_range(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> push_back(*__first);
> }
>
> template<typename _ForwardIterator>
> void
> _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __n = std::distance(__first, __last);
> _M_initialize(__n);
> std::copy(__first, __last, this->_M_impl._M_start);
> }
>
>
>
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign(__n, __val); }
>
> template<class _InputIterator>
> void
> _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
>
> void
> _M_fill_assign(size_t __n, bool __x)
> {
> if (__n > size())
> {
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> insert(end(), __n - size(), __x);
> }
> else
> {
> _M_erase_at_end(begin() + __n);
> std::fill(this->_M_impl._M_start._M_p,
> this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
> }
> }
>
> template<typename _InputIterator>
> void
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> iterator __cur = begin();
> for (; __first != __last && __cur != end(); ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> _M_erase_at_end(__cur);
> else
> insert(end(), __first, __last);
> }
>
> template<typename _ForwardIterator>
> void
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
> if (__len < size())
> _M_erase_at_end(std::copy(__first, __last, begin()));
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, begin());
> insert(end(), __mid, __last);
> }
> }
>
>
>
>
>
> template<typename _Integer>
> void
> _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
> __true_type)
> { _M_fill_insert(__pos, __n, __x); }
>
> template<typename _InputIterator>
> void
> _M_insert_dispatch(iterator __pos,
> _InputIterator __first, _InputIterator __last,
> __false_type)
> { _M_insert_range(__pos, __first, __last,
> std::__iterator_category(__first)); }
>
> void
> _M_fill_insert(iterator __position, size_type __n, bool __x);
>
> template<typename _InputIterator>
> void
> _M_insert_range(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> {
> __pos = insert(__pos, *__first);
> ++__pos;
> }
> }
>
> template<typename _ForwardIterator>
> void
> _M_insert_range(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag);
>
> void
> _M_insert_aux(iterator __position, bool __x);
>
> size_type
> _M_check_len(size_type __n, const char* __s) const
> {
> if (max_size() - size() < __n)
> __throw_length_error((__s));
>
> const size_type __len = size() + std::max(size(), __n);
> return (__len < size() || __len > max_size()) ? max_size() : __len;
> }
>
> void
> _M_erase_at_end(iterator __pos)
> { this->_M_impl._M_finish = __pos; }
> };
>
>
>}
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template<typename _Alloc>
> struct hash<std::vector<bool, _Alloc>>
> : public __hash_base<size_t, std::vector<bool, _Alloc>>
> {
> size_t
> operator()(const std::vector<bool, _Alloc>&) const noexcept;
> };
>
>
>}
># 67 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/vector" 2 3
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/vector.tcc" 1 3
># 60 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/vector.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> reserve(size_type __n)
> {
> if (__n > this->max_size())
> __throw_length_error(("vector::reserve"));
> if (this->capacity() < __n)
> {
> const size_type __old_size = size();
> pointer __tmp = _M_allocate_and_copy(__n,
> std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
> std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_finish = __tmp + __old_size;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> void
> vector<_Tp, _Alloc>::
> emplace_back(_Args&&... __args)
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::forward<_Args>(__args)...);
> ++this->_M_impl._M_finish;
> }
> else
> _M_emplace_back_aux(std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> insert(iterator __position, const value_type& __x)
> {
> const size_type __n = __position - begin();
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
> && __position == end())
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x);
> ++this->_M_impl._M_finish;
> }
> else
> {
>
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> _Tp __x_copy = __x;
> _M_insert_aux(__position, std::move(__x_copy));
> }
> else
>
> _M_insert_aux(__position, __x);
> }
> return iterator(this->_M_impl._M_start + __n);
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> erase(iterator __position)
> {
> if (__position + 1 != end())
> std::move(__position + 1, end(), __position);
> --this->_M_impl._M_finish;
> _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
> return __position;
> }
>
> template<typename _Tp, typename _Alloc>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> erase(iterator __first, iterator __last)
> {
> if (__first != __last)
> {
> if (__last != end())
> std::move(__last, end(), __first);
> _M_erase_at_end(__first.base() + (end() - __last));
> }
> return __first;
> }
>
> template<typename _Tp, typename _Alloc>
> vector<_Tp, _Alloc>&
> vector<_Tp, _Alloc>::
> operator=(const vector<_Tp, _Alloc>& __x)
> {
> if (&__x != this)
> {
>
> if (_Alloc_traits::_S_propagate_on_copy_assign())
> {
> if (!_Alloc_traits::_S_always_equal()
> && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
> {
>
> this->clear();
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> }
> std::__alloc_on_copy(_M_get_Tp_allocator(),
> __x._M_get_Tp_allocator());
> }
>
> const size_type __xlen = __x.size();
> if (__xlen > capacity())
> {
> pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
> __x.end());
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
> }
> else if (size() >= __xlen)
> {
> std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
> end(), _M_get_Tp_allocator());
> }
> else
> {
> std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
> this->_M_impl._M_start);
> std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
> __x._M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> }
> this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
> }
> return *this;
> }
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_fill_assign(size_t __n, const value_type& __val)
> {
> if (__n > capacity())
> {
> vector __tmp(__n, __val, _M_get_Tp_allocator());
> __tmp.swap(*this);
> }
> else if (__n > size())
> {
> std::fill(begin(), end(), __val);
> std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
> __n - size(), __val,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - size();
> }
> else
> _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _InputIterator>
> void
> vector<_Tp, _Alloc>::
> _M_assign_aux(_InputIterator __first, _InputIterator __last,
> std::input_iterator_tag)
> {
> pointer __cur(this->_M_impl._M_start);
> for (; __first != __last && __cur != this->_M_impl._M_finish;
> ++__cur, ++__first)
> *__cur = *__first;
> if (__first == __last)
> _M_erase_at_end(__cur);
> else
> insert(end(), __first, __last);
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<_Tp, _Alloc>::
> _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
> std::forward_iterator_tag)
> {
> const size_type __len = std::distance(__first, __last);
>
> if (__len > capacity())
> {
> pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __tmp;
> this->_M_impl._M_finish = this->_M_impl._M_start + __len;
> this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
> }
> else if (size() >= __len)
> _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, size());
> std::copy(__first, __mid, this->_M_impl._M_start);
> this->_M_impl._M_finish =
> std::__uninitialized_copy_a(__mid, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> typename vector<_Tp, _Alloc>::iterator
> vector<_Tp, _Alloc>::
> emplace(iterator __position, _Args&&... __args)
> {
> const size_type __n = __position - begin();
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
> && __position == end())
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::forward<_Args>(__args)...);
> ++this->_M_impl._M_finish;
> }
> else
> _M_insert_aux(__position, std::forward<_Args>(__args)...);
> return iterator(this->_M_impl._M_start + __n);
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> void
> vector<_Tp, _Alloc>::
> _M_insert_aux(iterator __position, _Args&&... __args)
>
>
>
>
>
>
> {
> if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
> {
> _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
> std::move(*(this->_M_impl._M_finish - 1))
> );
> ++this->_M_impl._M_finish;
>
>
>
> std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)
>
> ;
>
>
>
> *__position = _Tp(std::forward<_Args>(__args)...);
>
> }
> else
> {
> const size_type __len =
> _M_check_len(size_type(1), "vector::_M_insert_aux");
> const size_type __elems_before = __position - begin();
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
>
>
>
>
> _Alloc_traits::construct(this->_M_impl,
> __new_start + __elems_before,
>
> std::forward<_Args>(__args)...);
>
>
>
> __new_finish = 0;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, __position.base(),
> __new_start, _M_get_Tp_allocator());
>
> ++__new_finish;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__position.base(), this->_M_impl._M_finish,
> __new_finish, _M_get_Tp_allocator());
> }
> catch(...)
> {
> if (!__new_finish)
> _Alloc_traits::destroy(this->_M_impl,
> __new_start + __elems_before);
> else
> std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> void
> vector<_Tp, _Alloc>::
> _M_emplace_back_aux(_Args&&... __args)
> {
> const size_type __len =
> _M_check_len(size_type(1), "vector::_M_emplace_back_aux");
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
> _Alloc_traits::construct(this->_M_impl, __new_start + size(),
> std::forward<_Args>(__args)...);
> __new_finish = 0;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, this->_M_impl._M_finish,
> __new_start, _M_get_Tp_allocator());
>
> ++__new_finish;
> }
> catch(...)
> {
> if (!__new_finish)
> _Alloc_traits::destroy(this->_M_impl, __new_start + size());
> else
> std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
>
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
> {
> if (__n != 0)
> {
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
> value_type __x_copy = __x;
> const size_type __elems_after = end() - __position;
> pointer __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> std::move_backward(__position.base(), __old_finish - __n, __old_finish)
> ;
> std::fill(__position.base(), __position.base() + __n,
> __x_copy);
> }
> else
> {
> std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
> __n - __elems_after,
> __x_copy,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - __elems_after;
> std::__uninitialized_move_a(__position.base(), __old_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __elems_after;
> std::fill(__position.base(), __old_finish, __x_copy);
> }
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector::_M_fill_insert");
> const size_type __elems_before = __position - begin();
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
>
> std::__uninitialized_fill_n_a(__new_start + __elems_before,
> __n, __x,
> _M_get_Tp_allocator());
> __new_finish = 0;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, __position.base(),
> __new_start, _M_get_Tp_allocator());
>
> __new_finish += __n;
>
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__position.base(), this->_M_impl._M_finish,
> __new_finish, _M_get_Tp_allocator());
> }
> catch(...)
> {
> if (!__new_finish)
> std::_Destroy(__new_start + __elems_before,
> __new_start + __elems_before + __n,
> _M_get_Tp_allocator());
> else
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> void
> vector<_Tp, _Alloc>::
> _M_default_append(size_type __n)
> {
> if (__n != 0)
> {
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
> std::__uninitialized_default_n_a(this->_M_impl._M_finish,
> __n, _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector::_M_default_append");
> const size_type __old_size = this->size();
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, this->_M_impl._M_finish,
> __new_start, _M_get_Tp_allocator());
> std::__uninitialized_default_n_a(__new_finish, __n,
> _M_get_Tp_allocator());
> __new_finish += __n;
> }
> catch(...)
> {
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
> }
>
> template<typename _Tp, typename _Alloc>
> bool
> vector<_Tp, _Alloc>::
> _M_shrink_to_fit()
> {
> if (capacity() == size())
> return false;
> return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename _InputIterator>
> void
> vector<_Tp, _Alloc>::
> _M_range_insert(iterator __pos, _InputIterator __first,
> _InputIterator __last, std::input_iterator_tag)
> {
> for (; __first != __last; ++__first)
> {
> __pos = insert(__pos, *__first);
> ++__pos;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<_Tp, _Alloc>::
> _M_range_insert(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> if (__first != __last)
> {
> const size_type __n = std::distance(__first, __last);
> if (size_type(this->_M_impl._M_end_of_storage
> - this->_M_impl._M_finish) >= __n)
> {
> const size_type __elems_after = end() - __position;
> pointer __old_finish(this->_M_impl._M_finish);
> if (__elems_after > __n)
> {
> std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
> this->_M_impl._M_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n;
> std::move_backward(__position.base(), __old_finish - __n, __old_finish)
> ;
> std::copy(__first, __last, __position);
> }
> else
> {
> _ForwardIterator __mid = __first;
> std::advance(__mid, __elems_after);
> std::__uninitialized_copy_a(__mid, __last,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __n - __elems_after;
> std::__uninitialized_move_a(__position.base(),
> __old_finish,
> this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> this->_M_impl._M_finish += __elems_after;
> std::copy(__first, __mid, __position);
> }
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector::_M_range_insert");
> pointer __new_start(this->_M_allocate(__len));
> pointer __new_finish(__new_start);
> try
> {
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (this->_M_impl._M_start, __position.base(),
> __new_start, _M_get_Tp_allocator());
> __new_finish
> = std::__uninitialized_copy_a(__first, __last,
> __new_finish,
> _M_get_Tp_allocator());
> __new_finish
> = std::__uninitialized_move_if_noexcept_a
> (__position.base(), this->_M_impl._M_finish,
> __new_finish, _M_get_Tp_allocator());
> }
> catch(...)
> {
> std::_Destroy(__new_start, __new_finish,
> _M_get_Tp_allocator());
> _M_deallocate(__new_start, __len);
> throw;
> }
> std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
> _M_get_Tp_allocator());
> _M_deallocate(this->_M_impl._M_start,
> this->_M_impl._M_end_of_storage
> - this->_M_impl._M_start);
> this->_M_impl._M_start = __new_start;
> this->_M_impl._M_finish = __new_finish;
> this->_M_impl._M_end_of_storage = __new_start + __len;
> }
> }
> }
>
>
>
> template<typename _Alloc>
> void
> vector<bool, _Alloc>::
> _M_reallocate(size_type __n)
> {
> _Bit_type* __q = this->_M_allocate(__n);
> this->_M_impl._M_finish = _M_copy_aligned(begin(), end(),
> iterator(__q, 0));
> this->_M_deallocate();
> this->_M_impl._M_start = iterator(__q, 0);
> this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
> }
>
> template<typename _Alloc>
> void
> vector<bool, _Alloc>::
> _M_fill_insert(iterator __position, size_type __n, bool __x)
> {
> if (__n == 0)
> return;
> if (capacity() - size() >= __n)
> {
> std::copy_backward(__position, end(),
> this->_M_impl._M_finish + difference_type(__n));
> std::fill(__position, __position + difference_type(__n), __x);
> this->_M_impl._M_finish += difference_type(__n);
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector<bool>::_M_fill_insert");
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = _M_copy_aligned(begin(), __position,
> iterator(__q, 0));
> std::fill(__i, __i + difference_type(__n), __x);
> this->_M_impl._M_finish = std::copy(__position, end(),
> __i + difference_type(__n));
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
>
> template<typename _Alloc>
> template<typename _ForwardIterator>
> void
> vector<bool, _Alloc>::
> _M_insert_range(iterator __position, _ForwardIterator __first,
> _ForwardIterator __last, std::forward_iterator_tag)
> {
> if (__first != __last)
> {
> size_type __n = std::distance(__first, __last);
> if (capacity() - size() >= __n)
> {
> std::copy_backward(__position, end(),
> this->_M_impl._M_finish
> + difference_type(__n));
> std::copy(__first, __last, __position);
> this->_M_impl._M_finish += difference_type(__n);
> }
> else
> {
> const size_type __len =
> _M_check_len(__n, "vector<bool>::_M_insert_range");
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = _M_copy_aligned(begin(), __position,
> iterator(__q, 0));
> __i = std::copy(__first, __last, __i);
> this->_M_impl._M_finish = std::copy(__position, end(), __i);
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
> }
>
> template<typename _Alloc>
> void
> vector<bool, _Alloc>::
> _M_insert_aux(iterator __position, bool __x)
> {
> if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
> {
> std::copy_backward(__position, this->_M_impl._M_finish,
> this->_M_impl._M_finish + 1);
> *__position = __x;
> ++this->_M_impl._M_finish;
> }
> else
> {
> const size_type __len =
> _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
> _Bit_type * __q = this->_M_allocate(__len);
> iterator __i = _M_copy_aligned(begin(), __position,
> iterator(__q, 0));
> *__i++ = __x;
> this->_M_impl._M_finish = std::copy(__position, end(), __i);
> this->_M_deallocate();
> this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
> this->_M_impl._M_start = iterator(__q, 0);
> }
> }
>
>
> template<typename _Alloc>
> bool
> vector<bool, _Alloc>::
> _M_shrink_to_fit()
> {
> if (capacity() - size() < int(_S_word_bit))
> return false;
> try
> {
> _M_reallocate(size());
> return true;
> }
> catch(...)
> { return false; }
> }
>
>
>
>}
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Alloc>
> size_t
> hash<std::vector<bool, _Alloc>>::
> operator()(const std::vector<bool, _Alloc>& __b) const noexcept
> {
> size_t __hash = 0;
> using std::_S_word_bit;
> using std::_Bit_type;
>
> const size_t __words = __b.size() / _S_word_bit;
> if (__words)
> {
> const size_t __clength = __words * sizeof(_Bit_type);
> __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength);
> }
>
> const size_t __extrabits = __b.size() % _S_word_bit;
> if (__extrabits)
> {
> _Bit_type __hiword = *__b._M_impl._M_finish._M_p;
> __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits);
>
> const size_t __clength
> = (__extrabits + 8 - 1) / 8;
> if (__words)
> __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash);
> else
> __hash = std::_Hash_impl::hash(&__hiword, __clength);
> }
>
> return __hash;
> }
>
>
>}
># 71 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/vector" 2 3
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, size_t __bits,
> typename _UniformRandomNumberGenerator>
> _RealType
> generate_canonical(_UniformRandomNumberGenerator& __g);
>
>
>
>
>
>
> namespace __detail
> {
> 
>
> template<typename _UIntType, size_t __w,
> bool = __w < static_cast<size_t>
> (std::numeric_limits<_UIntType>::digits)>
> struct _Shift
> { static const _UIntType __value = 0; };
>
> template<typename _UIntType, size_t __w>
> struct _Shift<_UIntType, __w, true>
> { static const _UIntType __value = _UIntType(1) << __w; };
>
> template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool>
> struct _Mod;
>
>
>
> template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
> inline _Tp
> __mod(_Tp __x)
> { return _Mod<_Tp, __m, __a, __c, __m == 0>::__calc(__x); }
>
>
>
>
>
> template<typename _Engine, typename _DInputType>
> struct _Adaptor
> {
>
> public:
> _Adaptor(_Engine& __g)
> : _M_g(__g) { }
>
> _DInputType
> min() const
> { return _DInputType(0); }
>
> _DInputType
> max() const
> { return _DInputType(1); }
>
>
>
>
>
>
> _DInputType
> operator()()
> {
> return std::generate_canonical<_DInputType,
> std::numeric_limits<_DInputType>::digits,
> _Engine>(_M_g);
> }
>
> private:
> _Engine& _M_g;
> };
>
> 
> }
>
>
># 169 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> class linear_congruential_engine
> {
> static_assert(std::is_unsigned<_UIntType>::value, "template argument "
> "substituting _UIntType not an unsigned integral type");
> static_assert(__m == 0u || (__a < __m && __c < __m),
> "template argument substituting __m out of bounds");
>
>
>
> static_assert(__m % __a < __m / __a,
> "sorry, not implemented yet: try a smaller 'a' constant");
>
> public:
>
> typedef _UIntType result_type;
>
>
> static constexpr result_type multiplier = __a;
>
> static constexpr result_type increment = __c;
>
> static constexpr result_type modulus = __m;
> static constexpr result_type default_seed = 1u;
># 201 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> explicit
> linear_congruential_engine(result_type __s = default_seed)
> { seed(__s); }
>
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value>
> ::type>
> explicit
> linear_congruential_engine(_Sseq& __q)
> { seed(__q); }
>
>
>
>
>
>
>
> void
> seed(result_type __s = default_seed);
># 234 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> seed(_Sseq& __q);
>
>
>
>
>
>
>
> static constexpr result_type
> min()
> { return __c == 0u ? 1u : 0u; }
>
>
>
>
> static constexpr result_type
> max()
> { return __m - 1u; }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()()
> {
> _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
> return _M_x;
> }
># 286 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> friend bool
> operator==(const linear_congruential_engine& __lhs,
> const linear_congruential_engine& __rhs)
> { return __lhs._M_x == __rhs._M_x; }
># 299 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
> _UIntType1 __m1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::linear_congruential_engine<_UIntType1,
> __a1, __c1, __m1>& __lcr);
># 319 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
> _UIntType1 __m1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::linear_congruential_engine<_UIntType1, __a1,
> __c1, __m1>& __lcr);
>
> private:
> _UIntType _M_x;
> };
># 341 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> inline bool
> operator!=(const std::linear_congruential_engine<_UIntType, __a,
> __c, __m>& __lhs,
> const std::linear_congruential_engine<_UIntType, __a,
> __c, __m>& __rhs)
> { return !(__lhs == __rhs); }
># 378 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t,
> _UIntType __c, size_t __l, _UIntType __f>
> class mersenne_twister_engine
> {
> static_assert(std::is_unsigned<_UIntType>::value, "template argument "
> "substituting _UIntType not an unsigned integral type");
> static_assert(1u <= __m && __m <= __n,
> "template argument substituting __m out of bounds");
> static_assert(__r <= __w, "template argument substituting "
> "__r out of bound");
> static_assert(__u <= __w, "template argument substituting "
> "__u out of bound");
> static_assert(__s <= __w, "template argument substituting "
> "__s out of bound");
> static_assert(__t <= __w, "template argument substituting "
> "__t out of bound");
> static_assert(__l <= __w, "template argument substituting "
> "__l out of bound");
> static_assert(__w <= std::numeric_limits<_UIntType>::digits,
> "template argument substituting __w out of bound");
> static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __a out of bound");
> static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __b out of bound");
> static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __c out of bound");
> static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __d out of bound");
> static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
> "template argument substituting __f out of bound");
>
> public:
>
> typedef _UIntType result_type;
>
>
> static constexpr size_t word_size = __w;
> static constexpr size_t state_size = __n;
> static constexpr size_t shift_size = __m;
> static constexpr size_t mask_bits = __r;
> static constexpr result_type xor_mask = __a;
> static constexpr size_t tempering_u = __u;
> static constexpr result_type tempering_d = __d;
> static constexpr size_t tempering_s = __s;
> static constexpr result_type tempering_b = __b;
> static constexpr size_t tempering_t = __t;
> static constexpr result_type tempering_c = __c;
> static constexpr size_t tempering_l = __l;
> static constexpr result_type initialization_multiplier = __f;
> static constexpr result_type default_seed = 5489u;
>
>
> explicit
> mersenne_twister_engine(result_type __sd = default_seed)
> { seed(__sd); }
>
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value>
> ::type>
> explicit
> mersenne_twister_engine(_Sseq& __q)
> { seed(__q); }
>
> void
> seed(result_type __sd = default_seed);
>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> seed(_Sseq& __q);
>
>
>
>
> static constexpr result_type
> min()
> { return 0; };
>
>
>
>
> static constexpr result_type
> max()
> { return __detail::_Shift<_UIntType, __w>::__value - 1; }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
> result_type
> operator()();
># 496 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> friend bool
> operator==(const mersenne_twister_engine& __lhs,
> const mersenne_twister_engine& __rhs)
> { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
> && __lhs._M_p == __rhs._M_p); }
># 514 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType1,
> size_t __w1, size_t __n1,
> size_t __m1, size_t __r1,
> _UIntType1 __a1, size_t __u1,
> _UIntType1 __d1, size_t __s1,
> _UIntType1 __b1, size_t __t1,
> _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
> __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
> __l1, __f1>& __x);
># 540 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType1,
> size_t __w1, size_t __n1,
> size_t __m1, size_t __r1,
> _UIntType1 __a1, size_t __u1,
> _UIntType1 __d1, size_t __s1,
> _UIntType1 __b1, size_t __t1,
> _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
> __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
> __l1, __f1>& __x);
>
> private:
> _UIntType _M_x[state_size];
> size_t _M_p;
> };
># 571 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t,
> _UIntType __c, size_t __l, _UIntType __f>
> inline bool
> operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
> __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
> const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
> __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
> { return !(__lhs == __rhs); }
># 603 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> class subtract_with_carry_engine
> {
> static_assert(std::is_unsigned<_UIntType>::value, "template argument "
> "substituting _UIntType not an unsigned integral type");
> static_assert(0u < __s && __s < __r,
> "template argument substituting __s out of bounds");
> static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
> "template argument substituting __w out of bounds");
>
> public:
>
> typedef _UIntType result_type;
>
>
> static constexpr size_t word_size = __w;
> static constexpr size_t short_lag = __s;
> static constexpr size_t long_lag = __r;
> static constexpr result_type default_seed = 19780503u;
>
>
>
>
>
> explicit
> subtract_with_carry_engine(result_type __sd = default_seed)
> { seed(__sd); }
>
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value>
> ::type>
> explicit
> subtract_with_carry_engine(_Sseq& __q)
> { seed(__q); }
># 656 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> void
> seed(result_type __sd = default_seed);
>
>
>
>
>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> seed(_Sseq& __q);
>
>
>
>
>
> static constexpr result_type
> min()
> { return 0; }
>
>
>
>
>
> static constexpr result_type
> max()
> { return __detail::_Shift<_UIntType, __w>::__value - 1; }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()();
># 711 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> friend bool
> operator==(const subtract_with_carry_engine& __lhs,
> const subtract_with_carry_engine& __rhs)
> { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
> && __lhs._M_carry == __rhs._M_carry
> && __lhs._M_p == __rhs._M_p); }
># 730 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>&,
> const std::subtract_with_carry_engine<_UIntType1, __w1,
> __s1, __r1>&);
># 749 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>&,
> std::subtract_with_carry_engine<_UIntType1, __w1,
> __s1, __r1>&);
>
> private:
> _UIntType _M_x[long_lag];
> _UIntType _M_carry;
> size_t _M_p;
> };
># 774 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> inline bool
> operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
> __s, __r>& __lhs,
> const std::subtract_with_carry_engine<_UIntType, __w,
> __s, __r>& __rhs)
> { return !(__lhs == __rhs); }
># 789 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> class discard_block_engine
> {
> static_assert(1 <= __r && __r <= __p,
> "template argument substituting __r out of bounds");
>
> public:
>
> typedef typename _RandomNumberEngine::result_type result_type;
>
>
> static constexpr size_t block_size = __p;
> static constexpr size_t used_block = __r;
>
>
>
>
>
>
> discard_block_engine()
> : _M_b(), _M_n(0) { }
>
>
>
>
>
>
>
> explicit
> discard_block_engine(const _RandomNumberEngine& __rng)
> : _M_b(__rng), _M_n(0) { }
>
>
>
>
>
>
>
> explicit
> discard_block_engine(_RandomNumberEngine&& __rng)
> : _M_b(std::move(__rng)), _M_n(0) { }
>
>
>
>
>
>
>
> explicit
> discard_block_engine(result_type __s)
> : _M_b(__s), _M_n(0) { }
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value
> && !std::is_same<_Sseq, _RandomNumberEngine>::value>
> ::type>
> explicit
> discard_block_engine(_Sseq& __q)
> : _M_b(__q), _M_n(0)
> { }
>
>
>
>
>
> void
> seed()
> {
> _M_b.seed();
> _M_n = 0;
> }
>
>
>
>
>
> void
> seed(result_type __s)
> {
> _M_b.seed(__s);
> _M_n = 0;
> }
>
>
>
>
>
>
> template<typename _Sseq>
> void
> seed(_Sseq& __q)
> {
> _M_b.seed(__q);
> _M_n = 0;
> }
>
>
>
>
>
> const _RandomNumberEngine&
> base() const noexcept
> { return _M_b; }
>
>
>
>
> static constexpr result_type
> min()
> { return _RandomNumberEngine::min(); }
>
>
>
>
> static constexpr result_type
> max()
> { return _RandomNumberEngine::max(); }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()();
># 939 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> friend bool
> operator==(const discard_block_engine& __lhs,
> const discard_block_engine& __rhs)
> { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
># 955 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::discard_block_engine<_RandomNumberEngine1,
> __p1, __r1>& __x);
># 973 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::discard_block_engine<_RandomNumberEngine1,
> __p1, __r1>& __x);
>
> private:
> _RandomNumberEngine _M_b;
> size_t _M_n;
> };
># 996 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> inline bool
> operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
> __r>& __lhs,
> const std::discard_block_engine<_RandomNumberEngine, __p,
> __r>& __rhs)
> { return !(__lhs == __rhs); }
>
>
>
>
>
>
> template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
> class independent_bits_engine
> {
> static_assert(std::is_unsigned<_UIntType>::value, "template argument "
> "substituting _UIntType not an unsigned integral type");
> static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
> "template argument substituting __w out of bounds");
>
> public:
>
> typedef _UIntType result_type;
>
>
>
>
>
>
> independent_bits_engine()
> : _M_b() { }
>
>
>
>
>
>
>
> explicit
> independent_bits_engine(const _RandomNumberEngine& __rng)
> : _M_b(__rng) { }
>
>
>
>
>
>
>
> explicit
> independent_bits_engine(_RandomNumberEngine&& __rng)
> : _M_b(std::move(__rng)) { }
>
>
>
>
>
>
>
> explicit
> independent_bits_engine(result_type __s)
> : _M_b(__s) { }
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value
> && !std::is_same<_Sseq, _RandomNumberEngine>::value>
> ::type>
> explicit
> independent_bits_engine(_Sseq& __q)
> : _M_b(__q)
> { }
>
>
>
>
>
> void
> seed()
> { _M_b.seed(); }
>
>
>
>
>
> void
> seed(result_type __s)
> { _M_b.seed(__s); }
>
>
>
>
>
>
> template<typename _Sseq>
> void
> seed(_Sseq& __q)
> { _M_b.seed(__q); }
>
>
>
>
>
> const _RandomNumberEngine&
> base() const noexcept
> { return _M_b; }
>
>
>
>
> static constexpr result_type
> min()
> { return 0U; }
>
>
>
>
> static constexpr result_type
> max()
> { return __detail::_Shift<_UIntType, __w>::__value - 1; }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()();
># 1149 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> friend bool
> operator==(const independent_bits_engine& __lhs,
> const independent_bits_engine& __rhs)
> { return __lhs._M_b == __rhs._M_b; }
># 1166 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::independent_bits_engine<_RandomNumberEngine,
> __w, _UIntType>& __x)
> {
> __is >> __x._M_b;
> return __is;
> }
>
> private:
> _RandomNumberEngine _M_b;
> };
># 1192 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
> inline bool
> operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
> _UIntType>& __lhs,
> const std::independent_bits_engine<_RandomNumberEngine, __w,
> _UIntType>& __rhs)
> { return !(__lhs == __rhs); }
># 1210 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::independent_bits_engine<_RandomNumberEngine,
> __w, _UIntType>& __x)
> {
> __os << __x.base();
> return __os;
> }
>
>
>
>
>
>
>
> template<typename _RandomNumberEngine, size_t __k>
> class shuffle_order_engine
> {
> static_assert(1u <= __k, "template argument substituting "
> "__k out of bound");
>
> public:
>
> typedef typename _RandomNumberEngine::result_type result_type;
>
> static constexpr size_t table_size = __k;
>
>
>
>
>
>
> shuffle_order_engine()
> : _M_b()
> { _M_initialize(); }
>
>
>
>
>
>
>
> explicit
> shuffle_order_engine(const _RandomNumberEngine& __rng)
> : _M_b(__rng)
> { _M_initialize(); }
>
>
>
>
>
>
>
> explicit
> shuffle_order_engine(_RandomNumberEngine&& __rng)
> : _M_b(std::move(__rng))
> { _M_initialize(); }
>
>
>
>
>
>
>
> explicit
> shuffle_order_engine(result_type __s)
> : _M_b(__s)
> { _M_initialize(); }
>
>
>
>
>
>
> template<typename _Sseq, typename = typename
> std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value
> && !std::is_same<_Sseq, _RandomNumberEngine>::value>
> ::type>
> explicit
> shuffle_order_engine(_Sseq& __q)
> : _M_b(__q)
> { _M_initialize(); }
>
>
>
>
>
> void
> seed()
> {
> _M_b.seed();
> _M_initialize();
> }
>
>
>
>
>
> void
> seed(result_type __s)
> {
> _M_b.seed(__s);
> _M_initialize();
> }
>
>
>
>
>
>
> template<typename _Sseq>
> void
> seed(_Sseq& __q)
> {
> _M_b.seed(__q);
> _M_initialize();
> }
>
>
>
>
> const _RandomNumberEngine&
> base() const noexcept
> { return _M_b; }
>
>
>
>
> static constexpr result_type
> min()
> { return _RandomNumberEngine::min(); }
>
>
>
>
> static constexpr result_type
> max()
> { return _RandomNumberEngine::max(); }
>
>
>
>
> void
> discard(unsigned long long __z)
> {
> for (; __z != 0ULL; --__z)
> (*this)();
> }
>
>
>
>
> result_type
> operator()();
># 1378 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> friend bool
> operator==(const shuffle_order_engine& __lhs,
> const shuffle_order_engine& __rhs)
> { return (__lhs._M_b == __rhs._M_b
> && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
> && __lhs._M_y == __rhs._M_y); }
># 1396 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RandomNumberEngine1, size_t __k1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::shuffle_order_engine<_RandomNumberEngine1,
> __k1>& __x);
># 1414 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RandomNumberEngine1, size_t __k1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
>
> private:
> void _M_initialize()
> {
> for (size_t __i = 0; __i < __k; ++__i)
> _M_v[__i] = _M_b();
> _M_y = _M_b();
> }
>
> _RandomNumberEngine _M_b;
> result_type _M_v[__k];
> result_type _M_y;
> };
># 1444 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RandomNumberEngine, size_t __k>
> inline bool
> operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
> __k>& __lhs,
> const std::shuffle_order_engine<_RandomNumberEngine,
> __k>& __rhs)
> { return !(__lhs == __rhs); }
>
>
>
>
>
> typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
> minstd_rand0;
>
>
>
>
> typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
> minstd_rand;
># 1473 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> typedef mersenne_twister_engine<
> uint_fast32_t,
> 32, 624, 397, 31,
> 0x9908b0dfUL, 11,
> 0xffffffffUL, 7,
> 0x9d2c5680UL, 15,
> 0xefc60000UL, 18, 1812433253UL> mt19937;
>
>
>
>
> typedef mersenne_twister_engine<
> uint_fast64_t,
> 64, 312, 156, 31,
> 0xb5026f5aa96619e9ULL, 29,
> 0x5555555555555555ULL, 17,
> 0x71d67fffeda60000ULL, 37,
> 0xfff7eee000000000ULL, 43,
> 6364136223846793005ULL> mt19937_64;
>
> typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
> ranlux24_base;
>
> typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
> ranlux48_base;
>
> typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
>
> typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
>
> typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
>
> typedef minstd_rand0 default_random_engine;
>
>
>
>
>
> class random_device
> {
> public:
>
> typedef unsigned int result_type;
>
>
>
>
>
> explicit
> random_device(const std::string& __token = "/dev/urandom")
> {
> if ((__token != "/dev/urandom" && __token != "/dev/random")
> || !(_M_file = std::fopen(__token.c_str(), "rb")))
> std::__throw_runtime_error(("random_device::" "random_device(const std::string&)")
> );
> }
>
> ~random_device()
> { std::fclose(_M_file); }
># 1560 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> static constexpr result_type
> min()
> { return std::numeric_limits<result_type>::min(); }
>
> static constexpr result_type
> max()
> { return std::numeric_limits<result_type>::max(); }
>
> double
> entropy() const noexcept
> { return 0.0; }
>
> result_type
> operator()()
> {
>
> result_type __ret;
> std::fread(reinterpret_cast<void*>(&__ret), sizeof(result_type),
> 1, _M_file);
> return __ret;
>
>
>
> }
>
>
> random_device(const random_device&) = delete;
> void operator=(const random_device&) = delete;
>
> private:
>
>
> FILE* _M_file;
>
>
>
> };
># 1617 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType = int>
> class uniform_int_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef uniform_int_distribution<_IntType> distribution_type;
>
> explicit
> param_type(_IntType __a = 0,
> _IntType __b = std::numeric_limits<_IntType>::max())
> : _M_a(__a), _M_b(__b)
> {
> ;
> }
>
> result_type
> a() const
> { return _M_a; }
>
> result_type
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _IntType _M_a;
> _IntType _M_b;
> };
>
> public:
>
>
>
> explicit
> uniform_int_distribution(_IntType __a = 0,
> _IntType __b = std::numeric_limits<_IntType>::max())
> : _M_param(__a, __b)
> { }
>
> explicit
> uniform_int_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
> result_type
> a() const
> { return _M_param.a(); }
>
> result_type
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return this->a(); }
>
>
>
>
> result_type
> max() const
> { return this->b(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator==(const std::uniform_int_distribution<_IntType>& __d1,
> const std::uniform_int_distribution<_IntType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::uniform_int_distribution<_IntType>& __d1,
> const std::uniform_int_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 1762 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>&,
> const std::uniform_int_distribution<_IntType>&);
># 1776 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>&,
> std::uniform_int_distribution<_IntType>&);
># 1789 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class uniform_real_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef uniform_real_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_a(__a), _M_b(__b)
> {
> ;
> }
>
> result_type
> a() const
> { return _M_a; }
>
> result_type
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _RealType _M_a;
> _RealType _M_b;
> };
>
> public:
>
>
>
>
>
>
> explicit
> uniform_real_distribution(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_param(__a, __b)
> { }
>
> explicit
> uniform_real_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
> result_type
> a() const
> { return _M_param.a(); }
>
> result_type
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return this->a(); }
>
>
>
>
> result_type
> max() const
> { return this->b(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> return (__aurng() * (__p.b() - __p.a())) + __p.a();
> }
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator==(const std::uniform_real_distribution<_IntType>& __d1,
> const std::uniform_real_distribution<_IntType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::uniform_real_distribution<_IntType>& __d1,
> const std::uniform_real_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 1943 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>&,
> const std::uniform_real_distribution<_RealType>&);
># 1957 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>&,
> std::uniform_real_distribution<_RealType>&);
># 1979 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class normal_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef normal_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __mean = _RealType(0),
> _RealType __stddev = _RealType(1))
> : _M_mean(__mean), _M_stddev(__stddev)
> {
> ;
> }
>
> _RealType
> mean() const
> { return _M_mean; }
>
> _RealType
> stddev() const
> { return _M_stddev; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return (__p1._M_mean == __p2._M_mean
> && __p1._M_stddev == __p2._M_stddev); }
>
> private:
> _RealType _M_mean;
> _RealType _M_stddev;
> };
>
> public:
>
>
>
>
> explicit
> normal_distribution(result_type __mean = result_type(0),
> result_type __stddev = result_type(1))
> : _M_param(__mean, __stddev), _M_saved_available(false)
> { }
>
> explicit
> normal_distribution(const param_type& __p)
> : _M_param(__p), _M_saved_available(false)
> { }
>
>
>
>
> void
> reset()
> { _M_saved_available = false; }
>
>
>
>
> _RealType
> mean() const
> { return _M_param.mean(); }
>
>
>
>
> _RealType
> stddev() const
> { return _M_param.stddev(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::min(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
>
>
>
>
>
> template<typename _RealType1>
> friend bool
> operator==(const std::normal_distribution<_RealType1>& __d1,
> const std::normal_distribution<_RealType1>& __d2);
># 2118 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::normal_distribution<_RealType1>& __x);
># 2133 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::normal_distribution<_RealType1>& __x);
>
> private:
> param_type _M_param;
> result_type _M_saved;
> bool _M_saved_available;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::normal_distribution<_RealType>& __d1,
> const std::normal_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 2163 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class lognormal_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef lognormal_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __m = _RealType(0),
> _RealType __s = _RealType(1))
> : _M_m(__m), _M_s(__s)
> { }
>
> _RealType
> m() const
> { return _M_m; }
>
> _RealType
> s() const
> { return _M_s; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
>
> private:
> _RealType _M_m;
> _RealType _M_s;
> };
>
> explicit
> lognormal_distribution(_RealType __m = _RealType(0),
> _RealType __s = _RealType(1))
> : _M_param(__m, __s), _M_nd()
> { }
>
> explicit
> lognormal_distribution(const param_type& __p)
> : _M_param(__p), _M_nd()
> { }
>
>
>
>
> void
> reset()
> { _M_nd.reset(); }
>
>
>
>
> _RealType
> m() const
> { return _M_param.m(); }
>
> _RealType
> s() const
> { return _M_param.s(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
>
>
>
>
>
>
> template<typename _RealType1>
> friend bool
> operator==(const std::lognormal_distribution<_RealType1>& __d1,
> const std::lognormal_distribution<_RealType1>& __d2)
> { return (__d1.param() == __d2.param()
> && __d1._M_nd == __d2._M_nd); }
># 2294 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::lognormal_distribution<_RealType1>& __x);
># 2309 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::lognormal_distribution<_RealType1>& __x);
>
> private:
> param_type _M_param;
>
> std::normal_distribution<result_type> _M_nd;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::lognormal_distribution<_RealType>& __d1,
> const std::lognormal_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 2339 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class gamma_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef gamma_distribution<_RealType> distribution_type;
> friend class gamma_distribution<_RealType>;
>
> explicit
> param_type(_RealType __alpha_val = _RealType(1),
> _RealType __beta_val = _RealType(1))
> : _M_alpha(__alpha_val), _M_beta(__beta_val)
> {
> ;
> _M_initialize();
> }
>
> _RealType
> alpha() const
> { return _M_alpha; }
>
> _RealType
> beta() const
> { return _M_beta; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return (__p1._M_alpha == __p2._M_alpha
> && __p1._M_beta == __p2._M_beta); }
>
> private:
> void
> _M_initialize();
>
> _RealType _M_alpha;
> _RealType _M_beta;
>
> _RealType _M_malpha, _M_a2;
> };
>
> public:
>
>
>
>
> explicit
> gamma_distribution(_RealType __alpha_val = _RealType(1),
> _RealType __beta_val = _RealType(1))
> : _M_param(__alpha_val, __beta_val), _M_nd()
> { }
>
> explicit
> gamma_distribution(const param_type& __p)
> : _M_param(__p), _M_nd()
> { }
>
>
>
>
> void
> reset()
> { _M_nd.reset(); }
>
>
>
>
> _RealType
> alpha() const
> { return _M_param.alpha(); }
>
>
>
>
> _RealType
> beta() const
> { return _M_param.beta(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
>
>
>
>
>
> template<typename _RealType1>
> friend bool
> operator==(const std::gamma_distribution<_RealType1>& __d1,
> const std::gamma_distribution<_RealType1>& __d2)
> { return (__d1.param() == __d2.param()
> && __d1._M_nd == __d2._M_nd); }
># 2487 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::gamma_distribution<_RealType1>& __x);
># 2501 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::gamma_distribution<_RealType1>& __x);
>
> private:
> param_type _M_param;
>
> std::normal_distribution<result_type> _M_nd;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::gamma_distribution<_RealType>& __d1,
> const std::gamma_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 2528 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class chi_squared_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef chi_squared_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __n = _RealType(1))
> : _M_n(__n)
> { }
>
> _RealType
> n() const
> { return _M_n; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_n == __p2._M_n; }
>
> private:
> _RealType _M_n;
> };
>
> explicit
> chi_squared_distribution(_RealType __n = _RealType(1))
> : _M_param(__n), _M_gd(__n / 2)
> { }
>
> explicit
> chi_squared_distribution(const param_type& __p)
> : _M_param(__p), _M_gd(__p.n() / 2)
> { }
>
>
>
>
> void
> reset()
> { _M_gd.reset(); }
>
>
>
>
> _RealType
> n() const
> { return _M_param.n(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return 2 * _M_gd(__urng); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> typedef typename std::gamma_distribution<result_type>::param_type
> param_type;
> return 2 * _M_gd(__urng, param_type(__p.n() / 2));
> }
>
>
>
>
>
>
> template<typename _RealType1>
> friend bool
> operator==(const std::chi_squared_distribution<_RealType1>& __d1,
> const std::chi_squared_distribution<_RealType1>& __d2)
> { return __d1.param() == __d2.param() && __d1._M_gd == __d2._M_gd; }
># 2651 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::chi_squared_distribution<_RealType1>& __x);
># 2666 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::chi_squared_distribution<_RealType1>& __x);
>
> private:
> param_type _M_param;
>
> std::gamma_distribution<result_type> _M_gd;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::chi_squared_distribution<_RealType>& __d1,
> const std::chi_squared_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 2693 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class cauchy_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef cauchy_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_a(__a), _M_b(__b)
> { }
>
> _RealType
> a() const
> { return _M_a; }
>
> _RealType
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _RealType _M_a;
> _RealType _M_b;
> };
>
> explicit
> cauchy_distribution(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_param(__a, __b)
> { }
>
> explicit
> cauchy_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> _RealType
> a() const
> { return _M_param.a(); }
>
> _RealType
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::min(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator==(const std::cauchy_distribution<_RealType>& __d1,
> const std::cauchy_distribution<_RealType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::cauchy_distribution<_RealType>& __d1,
> const std::cauchy_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 2835 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::cauchy_distribution<_RealType>& __x);
># 2850 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::cauchy_distribution<_RealType>& __x);
># 2866 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class fisher_f_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef fisher_f_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __m = _RealType(1),
> _RealType __n = _RealType(1))
> : _M_m(__m), _M_n(__n)
> { }
>
> _RealType
> m() const
> { return _M_m; }
>
> _RealType
> n() const
> { return _M_n; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
>
> private:
> _RealType _M_m;
> _RealType _M_n;
> };
>
> explicit
> fisher_f_distribution(_RealType __m = _RealType(1),
> _RealType __n = _RealType(1))
> : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
> { }
>
> explicit
> fisher_f_distribution(const param_type& __p)
> : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
> { }
>
>
>
>
> void
> reset()
> {
> _M_gd_x.reset();
> _M_gd_y.reset();
> }
>
>
>
>
> _RealType
> m() const
> { return _M_param.m(); }
>
> _RealType
> n() const
> { return _M_param.n(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> typedef typename std::gamma_distribution<result_type>::param_type
> param_type;
> return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
> / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
> }
>
>
>
>
>
>
> template<typename _RealType1>
> friend bool
> operator==(const std::fisher_f_distribution<_RealType1>& __d1,
> const std::fisher_f_distribution<_RealType1>& __d2)
> { return (__d1.param() == __d2.param()
> && __d1._M_gd_x == __d2._M_gd_x
> && __d1._M_gd_y == __d2._M_gd_y); }
># 3006 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::fisher_f_distribution<_RealType1>& __x);
># 3021 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::fisher_f_distribution<_RealType1>& __x);
>
> private:
> param_type _M_param;
>
> std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::fisher_f_distribution<_RealType>& __d1,
> const std::fisher_f_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 3050 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class student_t_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef student_t_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __n = _RealType(1))
> : _M_n(__n)
> { }
>
> _RealType
> n() const
> { return _M_n; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_n == __p2._M_n; }
>
> private:
> _RealType _M_n;
> };
>
> explicit
> student_t_distribution(_RealType __n = _RealType(1))
> : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
> { }
>
> explicit
> student_t_distribution(const param_type& __p)
> : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
> { }
>
>
>
>
> void
> reset()
> {
> _M_nd.reset();
> _M_gd.reset();
> }
>
>
>
>
> _RealType
> n() const
> { return _M_param.n(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::min(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> typedef typename std::gamma_distribution<result_type>::param_type
> param_type;
>
> const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
> return _M_nd(__urng) * std::sqrt(__p.n() / __g);
> }
>
>
>
>
>
>
> template<typename _RealType1>
> friend bool
> operator==(const std::student_t_distribution<_RealType1>& __d1,
> const std::student_t_distribution<_RealType1>& __d2)
> { return (__d1.param() == __d2.param()
> && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
># 3179 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::student_t_distribution<_RealType1>& __x);
># 3194 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::student_t_distribution<_RealType1>& __x);
>
> private:
> param_type _M_param;
>
> std::normal_distribution<result_type> _M_nd;
> std::gamma_distribution<result_type> _M_gd;
> };
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::student_t_distribution<_RealType>& __d1,
> const std::student_t_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 3230 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> class bernoulli_distribution
> {
> public:
>
> typedef bool result_type;
>
> struct param_type
> {
> typedef bernoulli_distribution distribution_type;
>
> explicit
> param_type(double __p = 0.5)
> : _M_p(__p)
> {
> ;
> }
>
> double
> p() const
> { return _M_p; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_p == __p2._M_p; }
>
> private:
> double _M_p;
> };
>
> public:
>
>
>
>
>
>
> explicit
> bernoulli_distribution(double __p = 0.5)
> : _M_param(__p)
> { }
>
> explicit
> bernoulli_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
>
>
>
> double
> p() const
> { return _M_param.p(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::min(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
> if ((__aurng() - __aurng.min())
> < __p.p() * (__aurng.max() - __aurng.min()))
> return true;
> return false;
> }
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> inline bool
> operator==(const std::bernoulli_distribution& __d1,
> const std::bernoulli_distribution& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> inline bool
> operator!=(const std::bernoulli_distribution& __d1,
> const std::bernoulli_distribution& __d2)
> { return !(__d1 == __d2); }
># 3373 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::bernoulli_distribution& __x);
># 3387 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::bernoulli_distribution& __x)
> {
> double __p;
> __is >> __p;
> __x.param(bernoulli_distribution::param_type(__p));
> return __is;
> }
># 3406 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType = int>
> class binomial_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef binomial_distribution<_IntType> distribution_type;
> friend class binomial_distribution<_IntType>;
>
> explicit
> param_type(_IntType __t = _IntType(1), double __p = 0.5)
> : _M_t(__t), _M_p(__p)
> {
> 
>
> ;
> _M_initialize();
> }
>
> _IntType
> t() const
> { return _M_t; }
>
> double
> p() const
> { return _M_p; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
>
> private:
> void
> _M_initialize();
>
> _IntType _M_t;
> double _M_p;
>
> double _M_q;
>
> double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
> _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
>
> bool _M_easy;
> };
>
>
> explicit
> binomial_distribution(_IntType __t = _IntType(1),
> double __p = 0.5)
> : _M_param(__t, __p), _M_nd()
> { }
>
> explicit
> binomial_distribution(const param_type& __p)
> : _M_param(__p), _M_nd()
> { }
>
>
>
>
> void
> reset()
> { _M_nd.reset(); }
>
>
>
>
> _IntType
> t() const
> { return _M_param.t(); }
>
>
>
>
> double
> p() const
> { return _M_param.p(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return 0; }
>
>
>
>
> result_type
> max() const
> { return _M_param.t(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
>
>
>
>
>
> template<typename _IntType1>
> friend bool
> operator==(const std::binomial_distribution<_IntType1>& __d1,
> const std::binomial_distribution<_IntType1>& __d2)
>
> { return __d1.param() == __d2.param() && __d1._M_nd == __d2._M_nd; }
># 3558 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType1,
> typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::binomial_distribution<_IntType1>& __x);
># 3574 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType1,
> typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::binomial_distribution<_IntType1>& __x);
>
> private:
> template<typename _UniformRandomNumberGenerator>
> result_type
> _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
>
> param_type _M_param;
>
>
> std::normal_distribution<double> _M_nd;
> };
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::binomial_distribution<_IntType>& __d1,
> const std::binomial_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 3608 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType = int>
> class geometric_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef geometric_distribution<_IntType> distribution_type;
> friend class geometric_distribution<_IntType>;
>
> explicit
> param_type(double __p = 0.5)
> : _M_p(__p)
> {
> ;
> _M_initialize();
> }
>
> double
> p() const
> { return _M_p; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_p == __p2._M_p; }
>
> private:
> void
> _M_initialize()
> { _M_log_1_p = std::log(1.0 - _M_p); }
>
> double _M_p;
>
> double _M_log_1_p;
> };
>
>
> explicit
> geometric_distribution(double __p = 0.5)
> : _M_param(__p)
> { }
>
> explicit
> geometric_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
>
>
>
> double
> p() const
> { return _M_param.p(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return 0; }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator==(const std::geometric_distribution<_IntType>& __d1,
> const std::geometric_distribution<_IntType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::geometric_distribution<_IntType>& __d1,
> const std::geometric_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 3751 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::geometric_distribution<_IntType>& __x);
># 3766 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::geometric_distribution<_IntType>& __x);
># 3780 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType = int>
> class negative_binomial_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef negative_binomial_distribution<_IntType> distribution_type;
>
> explicit
> param_type(_IntType __k = 1, double __p = 0.5)
> : _M_k(__k), _M_p(__p)
> {
> ;
> }
>
> _IntType
> k() const
> { return _M_k; }
>
> double
> p() const
> { return _M_p; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
>
> private:
> _IntType _M_k;
> double _M_p;
> };
>
> explicit
> negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
> : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
> { }
>
> explicit
> negative_binomial_distribution(const param_type& __p)
> : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
> { }
>
>
>
>
> void
> reset()
> { _M_gd.reset(); }
>
>
>
>
> _IntType
> k() const
> { return _M_param.k(); }
>
>
>
>
> double
> p() const
> { return _M_param.p(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng);
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
>
>
>
>
>
> template<typename _IntType1>
> friend bool
> operator==(const std::negative_binomial_distribution<_IntType1>& __d1,
> const std::negative_binomial_distribution<_IntType1>& __d2)
> { return __d1.param() == __d2.param() && __d1._M_gd == __d2._M_gd; }
># 3912 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::negative_binomial_distribution<_IntType1>& __x);
># 3927 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::negative_binomial_distribution<_IntType1>& __x);
>
> private:
> param_type _M_param;
>
> std::gamma_distribution<double> _M_gd;
> };
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
> const std::negative_binomial_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 3963 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType = int>
> class poisson_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef poisson_distribution<_IntType> distribution_type;
> friend class poisson_distribution<_IntType>;
>
> explicit
> param_type(double __mean = 1.0)
> : _M_mean(__mean)
> {
> ;
> _M_initialize();
> }
>
> double
> mean() const
> { return _M_mean; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_mean == __p2._M_mean; }
>
> private:
>
> void
> _M_initialize();
>
> double _M_mean;
>
> double _M_lm_thr;
>
> double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
>
> };
>
>
> explicit
> poisson_distribution(double __mean = 1.0)
> : _M_param(__mean), _M_nd()
> { }
>
> explicit
> poisson_distribution(const param_type& __p)
> : _M_param(__p), _M_nd()
> { }
>
>
>
>
> void
> reset()
> { _M_nd.reset(); }
>
>
>
>
> double
> mean() const
> { return _M_param.mean(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return 0; }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
>
>
>
>
>
> template<typename _IntType1>
> friend bool
> operator==(const std::poisson_distribution<_IntType1>& __d1,
> const std::poisson_distribution<_IntType1>& __d2)
>
> { return __d1.param() == __d2.param() && __d1._M_nd == __d2._M_nd; }
># 4099 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::poisson_distribution<_IntType1>& __x);
># 4114 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::poisson_distribution<_IntType1>& __x);
>
> private:
> param_type _M_param;
>
>
> std::normal_distribution<double> _M_nd;
> };
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::poisson_distribution<_IntType>& __d1,
> const std::poisson_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 4151 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class exponential_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef exponential_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __lambda = _RealType(1))
> : _M_lambda(__lambda)
> {
> ;
> }
>
> _RealType
> lambda() const
> { return _M_lambda; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_lambda == __p2._M_lambda; }
>
> private:
> _RealType _M_lambda;
> };
>
> public:
>
>
>
>
> explicit
> exponential_distribution(const result_type& __lambda = result_type(1))
> : _M_param(__lambda)
> { }
>
> explicit
> exponential_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
>
>
> void
> reset() { }
>
>
>
>
> _RealType
> lambda() const
> { return _M_param.lambda(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> return -std::log(__aurng()) / __p.lambda();
> }
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator==(const std::exponential_distribution<_RealType>& __d1,
> const std::exponential_distribution<_RealType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::exponential_distribution<_RealType>& __d1,
> const std::exponential_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 4295 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::exponential_distribution<_RealType>& __x);
># 4310 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::exponential_distribution<_RealType>& __x);
># 4325 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class weibull_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef weibull_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __a = _RealType(1),
> _RealType __b = _RealType(1))
> : _M_a(__a), _M_b(__b)
> { }
>
> _RealType
> a() const
> { return _M_a; }
>
> _RealType
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _RealType _M_a;
> _RealType _M_b;
> };
>
> explicit
> weibull_distribution(_RealType __a = _RealType(1),
> _RealType __b = _RealType(1))
> : _M_param(__a, __b)
> { }
>
> explicit
> weibull_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> _RealType
> a() const
> { return _M_param.a(); }
>
>
>
>
> _RealType
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator==(const std::weibull_distribution<_RealType>& __d1,
> const std::weibull_distribution<_RealType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::weibull_distribution<_RealType>& __d1,
> const std::weibull_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 4470 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::weibull_distribution<_RealType>& __x);
># 4485 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::weibull_distribution<_RealType>& __x);
># 4500 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class extreme_value_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef extreme_value_distribution<_RealType> distribution_type;
>
> explicit
> param_type(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_a(__a), _M_b(__b)
> { }
>
> _RealType
> a() const
> { return _M_a; }
>
> _RealType
> b() const
> { return _M_b; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
>
> private:
> _RealType _M_a;
> _RealType _M_b;
> };
>
> explicit
> extreme_value_distribution(_RealType __a = _RealType(0),
> _RealType __b = _RealType(1))
> : _M_param(__a, __b)
> { }
>
> explicit
> extreme_value_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> _RealType
> a() const
> { return _M_param.a(); }
>
>
>
>
> _RealType
> b() const
> { return _M_param.b(); }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return std::numeric_limits<result_type>::min(); }
>
>
>
>
> result_type
> max() const
> { return std::numeric_limits<result_type>::max(); }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator==(const std::extreme_value_distribution<_RealType>& __d1,
> const std::extreme_value_distribution<_RealType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::extreme_value_distribution<_RealType>& __d1,
> const std::extreme_value_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 4645 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::extreme_value_distribution<_RealType>& __x);
># 4660 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::extreme_value_distribution<_RealType>& __x);
># 4672 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType = int>
> class discrete_distribution
> {
> static_assert(std::is_integral<_IntType>::value,
> "template argument not an integral type");
>
> public:
>
> typedef _IntType result_type;
>
> struct param_type
> {
> typedef discrete_distribution<_IntType> distribution_type;
> friend class discrete_distribution<_IntType>;
>
> param_type()
> : _M_prob(), _M_cp()
> { }
>
> template<typename _InputIterator>
> param_type(_InputIterator __wbegin,
> _InputIterator __wend)
> : _M_prob(__wbegin, __wend), _M_cp()
> { _M_initialize(); }
>
> param_type(initializer_list<double> __wil)
> : _M_prob(__wil.begin(), __wil.end()), _M_cp()
> { _M_initialize(); }
>
> template<typename _Func>
> param_type(size_t __nw, double __xmin, double __xmax,
> _Func __fw);
>
>
> param_type(const param_type&) = default;
> param_type& operator=(const param_type&) = default;
>
> std::vector<double>
> probabilities() const
> { return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_prob == __p2._M_prob; }
>
> private:
> void
> _M_initialize();
>
> std::vector<double> _M_prob;
> std::vector<double> _M_cp;
> };
>
> discrete_distribution()
> : _M_param()
> { }
>
> template<typename _InputIterator>
> discrete_distribution(_InputIterator __wbegin,
> _InputIterator __wend)
> : _M_param(__wbegin, __wend)
> { }
>
> discrete_distribution(initializer_list<double> __wl)
> : _M_param(__wl)
> { }
>
> template<typename _Func>
> discrete_distribution(size_t __nw, double __xmin, double __xmax,
> _Func __fw)
> : _M_param(__nw, __xmin, __xmax, __fw)
> { }
>
> explicit
> discrete_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> std::vector<double>
> probabilities() const
> {
> return _M_param._M_prob.empty()
> ? std::vector<double>(1, 1.0) : _M_param._M_prob;
> }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> { return result_type(0); }
>
>
>
>
> result_type
> max() const
> {
> return _M_param._M_prob.empty()
> ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
> }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
># 4822 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::discrete_distribution<_IntType1>& __x);
># 4838 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _IntType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::discrete_distribution<_IntType1>& __x);
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator==(const std::discrete_distribution<_IntType>& __d1,
> const std::discrete_distribution<_IntType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _IntType>
> inline bool
> operator!=(const std::discrete_distribution<_IntType>& __d1,
> const std::discrete_distribution<_IntType>& __d2)
> { return !(__d1 == __d2); }
># 4874 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class piecewise_constant_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef piecewise_constant_distribution<_RealType> distribution_type;
> friend class piecewise_constant_distribution<_RealType>;
>
> param_type()
> : _M_int(), _M_den(), _M_cp()
> { }
>
> template<typename _InputIteratorB, typename _InputIteratorW>
> param_type(_InputIteratorB __bfirst,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin);
>
> template<typename _Func>
> param_type(initializer_list<_RealType> __bi, _Func __fw);
>
> template<typename _Func>
> param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
> _Func __fw);
>
>
> param_type(const param_type&) = default;
> param_type& operator=(const param_type&) = default;
>
> std::vector<_RealType>
> intervals() const
> {
> if (_M_int.empty())
> {
> std::vector<_RealType> __tmp(2);
> __tmp[1] = _RealType(1);
> return __tmp;
> }
> else
> return _M_int;
> }
>
> std::vector<double>
> densities() const
> { return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
>
> private:
> void
> _M_initialize();
>
> std::vector<_RealType> _M_int;
> std::vector<double> _M_den;
> std::vector<double> _M_cp;
> };
>
> explicit
> piecewise_constant_distribution()
> : _M_param()
> { }
>
> template<typename _InputIteratorB, typename _InputIteratorW>
> piecewise_constant_distribution(_InputIteratorB __bfirst,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin)
> : _M_param(__bfirst, __bend, __wbegin)
> { }
>
> template<typename _Func>
> piecewise_constant_distribution(initializer_list<_RealType> __bl,
> _Func __fw)
> : _M_param(__bl, __fw)
> { }
>
> template<typename _Func>
> piecewise_constant_distribution(size_t __nw,
> _RealType __xmin, _RealType __xmax,
> _Func __fw)
> : _M_param(__nw, __xmin, __xmax, __fw)
> { }
>
> explicit
> piecewise_constant_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> std::vector<_RealType>
> intervals() const
> {
> if (_M_param._M_int.empty())
> {
> std::vector<_RealType> __tmp(2);
> __tmp[1] = _RealType(1);
> return __tmp;
> }
> else
> return _M_param._M_int;
> }
>
>
>
>
> std::vector<double>
> densities() const
> {
> return _M_param._M_den.empty()
> ? std::vector<double>(1, 1.0) : _M_param._M_den;
> }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> {
> return _M_param._M_int.empty()
> ? result_type(0) : _M_param._M_int.front();
> }
>
>
>
>
> result_type
> max() const
> {
> return _M_param._M_int.empty()
> ? result_type(1) : _M_param._M_int.back();
> }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
># 5061 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::piecewise_constant_distribution<_RealType1>& __x);
># 5077 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::piecewise_constant_distribution<_RealType1>& __x);
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator==(const std::piecewise_constant_distribution<_RealType>& __d1,
> const std::piecewise_constant_distribution<_RealType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
> const std::piecewise_constant_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 5113 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType = double>
> class piecewise_linear_distribution
> {
> static_assert(std::is_floating_point<_RealType>::value,
> "template argument not a floating point type");
>
> public:
>
> typedef _RealType result_type;
>
> struct param_type
> {
> typedef piecewise_linear_distribution<_RealType> distribution_type;
> friend class piecewise_linear_distribution<_RealType>;
>
> param_type()
> : _M_int(), _M_den(), _M_cp(), _M_m()
> { }
>
> template<typename _InputIteratorB, typename _InputIteratorW>
> param_type(_InputIteratorB __bfirst,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin);
>
> template<typename _Func>
> param_type(initializer_list<_RealType> __bl, _Func __fw);
>
> template<typename _Func>
> param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
> _Func __fw);
>
>
> param_type(const param_type&) = default;
> param_type& operator=(const param_type&) = default;
>
> std::vector<_RealType>
> intervals() const
> {
> if (_M_int.empty())
> {
> std::vector<_RealType> __tmp(2);
> __tmp[1] = _RealType(1);
> return __tmp;
> }
> else
> return _M_int;
> }
>
> std::vector<double>
> densities() const
> { return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
>
> friend bool
> operator==(const param_type& __p1, const param_type& __p2)
> { return (__p1._M_int == __p2._M_int
> && __p1._M_den == __p2._M_den); }
>
> private:
> void
> _M_initialize();
>
> std::vector<_RealType> _M_int;
> std::vector<double> _M_den;
> std::vector<double> _M_cp;
> std::vector<double> _M_m;
> };
>
> explicit
> piecewise_linear_distribution()
> : _M_param()
> { }
>
> template<typename _InputIteratorB, typename _InputIteratorW>
> piecewise_linear_distribution(_InputIteratorB __bfirst,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin)
> : _M_param(__bfirst, __bend, __wbegin)
> { }
>
> template<typename _Func>
> piecewise_linear_distribution(initializer_list<_RealType> __bl,
> _Func __fw)
> : _M_param(__bl, __fw)
> { }
>
> template<typename _Func>
> piecewise_linear_distribution(size_t __nw,
> _RealType __xmin, _RealType __xmax,
> _Func __fw)
> : _M_param(__nw, __xmin, __xmax, __fw)
> { }
>
> explicit
> piecewise_linear_distribution(const param_type& __p)
> : _M_param(__p)
> { }
>
>
>
>
> void
> reset()
> { }
>
>
>
>
> std::vector<_RealType>
> intervals() const
> {
> if (_M_param._M_int.empty())
> {
> std::vector<_RealType> __tmp(2);
> __tmp[1] = _RealType(1);
> return __tmp;
> }
> else
> return _M_param._M_int;
> }
>
>
>
>
>
> std::vector<double>
> densities() const
> {
> return _M_param._M_den.empty()
> ? std::vector<double>(2, 1.0) : _M_param._M_den;
> }
>
>
>
>
> param_type
> param() const
> { return _M_param; }
>
>
>
>
>
> void
> param(const param_type& __param)
> { _M_param = __param; }
>
>
>
>
> result_type
> min() const
> {
> return _M_param._M_int.empty()
> ? result_type(0) : _M_param._M_int.front();
> }
>
>
>
>
> result_type
> max() const
> {
> return _M_param._M_int.empty()
> ? result_type(1) : _M_param._M_int.back();
> }
>
>
>
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng)
> { return this->operator()(__urng, this->param()); }
>
> template<typename _UniformRandomNumberGenerator>
> result_type
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p);
># 5303 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const std::piecewise_linear_distribution<_RealType1>& __x);
># 5319 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> template<typename _RealType1, typename _CharT, typename _Traits>
> friend std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> std::piecewise_linear_distribution<_RealType1>& __x);
>
> private:
> param_type _M_param;
> };
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator==(const std::piecewise_linear_distribution<_RealType>& __d1,
> const std::piecewise_linear_distribution<_RealType>& __d2)
> { return __d1.param() == __d2.param(); }
>
>
>
>
>
> template<typename _RealType>
> inline bool
> operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
> const std::piecewise_linear_distribution<_RealType>& __d2)
> { return !(__d1 == __d2); }
># 5363 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.h" 3
> class seed_seq
> {
>
> public:
>
> typedef uint_least32_t result_type;
>
>
> seed_seq()
> : _M_v()
> { }
>
> template<typename _IntType>
> seed_seq(std::initializer_list<_IntType> il);
>
> template<typename _InputIterator>
> seed_seq(_InputIterator __begin, _InputIterator __end);
>
>
> template<typename _RandomAccessIterator>
> void
> generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
>
>
> size_t size() const
> { return _M_v.size(); }
>
> template<typename OutputIterator>
> void
> param(OutputIterator __dest) const
> { std::copy(_M_v.begin(), _M_v.end(), __dest); }
>
> private:
>
> std::vector<result_type> _M_v;
> };
>
>
>
>
>
>
>}
># 51 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.tcc" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.tcc" 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/numeric" 1 3
># 58 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/numeric" 3
> 
># 59 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/numeric" 3
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 1 3
># 66 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 81 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
> template<typename _ForwardIterator, typename _Tp>
> void
> iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
> {
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> {
> *__first = __value;
> ++__value;
> }
> }
>
>
>}
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 119 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _Tp>
> inline _Tp
> accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
> {
>
> 
> ;
>
> for (; __first != __last; ++__first)
> __init = __init + *__first;
> return __init;
> }
># 145 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
> inline _Tp
> accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
> _BinaryOperation __binary_op)
> {
>
> 
> ;
>
> for (; __first != __last; ++__first)
> __init = __binary_op(__init, *__first);
> return __init;
> }
># 173 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
> template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
> inline _Tp
> inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _Tp __init)
> {
>
> 
> 
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> __init = __init + (*__first1 * *__first2);
> return __init;
> }
># 204 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
> template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
> typename _BinaryOperation1, typename _BinaryOperation2>
> inline _Tp
> inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _Tp __init,
> _BinaryOperation1 __binary_op1,
> _BinaryOperation2 __binary_op2)
> {
>
> 
> 
> ;
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
> return __init;
> }
># 236 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> _OutputIterator
> partial_sum(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
>
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> _ValueType __value = *__first;
> *__result = __value;
> while (++__first != __last)
> {
> __value = __value + *__first;
> *++__result = __value;
> }
> return ++__result;
> }
># 276 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryOperation>
> _OutputIterator
> partial_sum(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _BinaryOperation __binary_op)
> {
> typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
>
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> _ValueType __value = *__first;
> *__result = __value;
> while (++__first != __last)
> {
> __value = __binary_op(__value, *__first);
> *++__result = __value;
> }
> return ++__result;
> }
># 316 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> _OutputIterator
> adjacent_difference(_InputIterator __first,
> _InputIterator __last, _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
>
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> _ValueType __value = *__first;
> *__result = __value;
> while (++__first != __last)
> {
> _ValueType __tmp = *__first;
> *++__result = __tmp - __value;
> __value = std::move(__tmp);
> }
> return ++__result;
> }
># 358 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_numeric.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryOperation>
> _OutputIterator
> adjacent_difference(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _BinaryOperation __binary_op)
> {
> typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
>
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __result;
> _ValueType __value = *__first;
> *__result = __value;
> while (++__first != __last)
> {
> _ValueType __tmp = *__first;
> *++__result = __binary_op(__tmp, __value);
> __value = std::move(__tmp);
> }
> return ++__result;
> }
>
>
>}
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/numeric" 2 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.tcc" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> namespace __detail
> {
> 
># 54 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.tcc" 3
> template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool>
> struct _Mod
> {
> static _Tp
> __calc(_Tp __x)
> {
> if (__a == 1)
> __x %= __m;
> else
> {
> static const _Tp __q = __m / __a;
> static const _Tp __r = __m % __a;
>
> _Tp __t1 = __a * (__x % __q);
> _Tp __t2 = __r * (__x / __q);
> if (__t1 >= __t2)
> __x = __t1 - __t2;
> else
> __x = __m - __t2 + __t1;
> }
>
> if (__c != 0)
> {
> const _Tp __d = __m - __x;
> if (__d > __c)
> __x += __c;
> else
> __x = __c - __d;
> }
> return __x;
> }
> };
>
>
>
> template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
> struct _Mod<_Tp, __m, __a, __c, true>
> {
> static _Tp
> __calc(_Tp __x)
> { return __a * __x + __c; }
> };
>
> template<typename _InputIterator, typename _OutputIterator,
> typename _UnaryOperation>
> _OutputIterator
> __transform(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _UnaryOperation __unary_op)
> {
> for (; __first != __last; ++__first, ++__result)
> *__result = __unary_op(*__first);
> return __result;
> }
>
> 
> }
>
>
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> constexpr _UIntType
> linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> constexpr _UIntType
> linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> constexpr _UIntType
> linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> constexpr _UIntType
> linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
>
>
>
>
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> void
> linear_congruential_engine<_UIntType, __a, __c, __m>::
> seed(result_type __s)
> {
> if ((__detail::__mod<_UIntType, __m>(__c) == 0)
> && (__detail::__mod<_UIntType, __m>(__s) == 0))
> _M_x = 1;
> else
> _M_x = __detail::__mod<_UIntType, __m>(__s);
> }
>
>
>
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> linear_congruential_engine<_UIntType, __a, __c, __m>::
> seed(_Sseq& __q)
> {
> const _UIntType __k0 = __m == 0 ? std::numeric_limits<_UIntType>::digits
> : std::__lg(__m);
> const _UIntType __k = (__k0 + 31) / 32;
> uint_least32_t __arr[__k + 3];
> __q.generate(__arr + 0, __arr + __k + 3);
> _UIntType __factor = 1u;
> _UIntType __sum = 0u;
> for (size_t __j = 0; __j < __k; ++__j)
> {
> __sum += __arr[__j + 3] * __factor;
> __factor *= __detail::_Shift<_UIntType, 32>::__value;
> }
> seed(__sum);
> }
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const linear_congruential_engine<_UIntType,
> __a, __c, __m>& __lcr)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__os.widen(' '));
>
> __os << __lcr._M_x;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec);
>
> __is >> __lcr._M_x;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::word_size;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::state_size;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::shift_size;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::mask_bits;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::xor_mask;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_u;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_d;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_s;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_b;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_t;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_c;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr size_t
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::tempering_l;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> initialization_multiplier;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> constexpr _UIntType
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::default_seed;
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> void
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> seed(result_type __sd)
> {
> _M_x[0] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__sd);
>
> for (size_t __i = 1; __i < state_size; ++__i)
> {
> _UIntType __x = _M_x[__i - 1];
> __x ^= __x >> (__w - 2);
> __x *= __f;
> __x += __detail::__mod<_UIntType, __n>(__i);
> _M_x[__i] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__x);
> }
> _M_p = state_size;
> }
>
> template<typename _UIntType,
> size_t __w, size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> seed(_Sseq& __q)
> {
> const _UIntType __upper_mask = (~_UIntType()) << __r;
> const size_t __k = (__w + 31) / 32;
> uint_least32_t __arr[__n * __k];
> __q.generate(__arr + 0, __arr + __n * __k);
>
> bool __zero = true;
> for (size_t __i = 0; __i < state_size; ++__i)
> {
> _UIntType __factor = 1u;
> _UIntType __sum = 0u;
> for (size_t __j = 0; __j < __k; ++__j)
> {
> __sum += __arr[__k * __i + __j] * __factor;
> __factor *= __detail::_Shift<_UIntType, 32>::__value;
> }
> _M_x[__i] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__sum);
>
> if (__zero)
> {
> if (__i == 0)
> {
> if ((_M_x[0] & __upper_mask) != 0u)
> __zero = false;
> }
> else if (_M_x[__i] != 0u)
> __zero = false;
> }
> }
> if (__zero)
> _M_x[0] = __detail::_Shift<_UIntType, __w - 1>::__value;
> }
>
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f>
> typename
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::result_type
> mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
> __s, __b, __t, __c, __l, __f>::
> operator()()
> {
>
> if (_M_p >= state_size)
> {
> const _UIntType __upper_mask = (~_UIntType()) << __r;
> const _UIntType __lower_mask = ~__upper_mask;
>
> for (size_t __k = 0; __k < (__n - __m); ++__k)
> {
> _UIntType __y = ((_M_x[__k] & __upper_mask)
> | (_M_x[__k + 1] & __lower_mask));
> _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1)
> ^ ((__y & 0x01) ? __a : 0));
> }
>
> for (size_t __k = (__n - __m); __k < (__n - 1); ++__k)
> {
> _UIntType __y = ((_M_x[__k] & __upper_mask)
> | (_M_x[__k + 1] & __lower_mask));
> _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1)
> ^ ((__y & 0x01) ? __a : 0));
> }
>
> _UIntType __y = ((_M_x[__n - 1] & __upper_mask)
> | (_M_x[0] & __lower_mask));
> _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1)
> ^ ((__y & 0x01) ? __a : 0));
> _M_p = 0;
> }
>
>
> result_type __z = _M_x[_M_p++];
> __z ^= (__z >> __u) & __d;
> __z ^= (__z << __s) & __b;
> __z ^= (__z << __t) & __c;
> __z ^= (__z >> __l);
>
> return __z;
> }
>
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const mersenne_twister_engine<_UIntType, __w, __n, __m,
> __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__space);
>
> for (size_t __i = 0; __i < __n; ++__i)
> __os << __x._M_x[__i] << __space;
> __os << __x._M_p;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _UIntType, size_t __w,
> size_t __n, size_t __m, size_t __r,
> _UIntType __a, size_t __u, _UIntType __d, size_t __s,
> _UIntType __b, size_t __t, _UIntType __c, size_t __l,
> _UIntType __f, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> mersenne_twister_engine<_UIntType, __w, __n, __m,
> __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> for (size_t __i = 0; __i < __n; ++__i)
> __is >> __x._M_x[__i];
> __is >> __x._M_p;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> constexpr size_t
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> constexpr size_t
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> constexpr size_t
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> constexpr _UIntType
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> void
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::
> seed(result_type __value)
> {
> std::linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
> __lcg(__value == 0u ? default_seed : __value);
>
> const size_t __n = (__w + 31) / 32;
>
> for (size_t __i = 0; __i < long_lag; ++__i)
> {
> _UIntType __sum = 0u;
> _UIntType __factor = 1u;
> for (size_t __j = 0; __j < __n; ++__j)
> {
> __sum += __detail::__mod<uint_least32_t,
> __detail::_Shift<uint_least32_t, 32>::__value>
> (__lcg()) * __factor;
> __factor *= __detail::_Shift<_UIntType, 32>::__value;
> }
> _M_x[__i] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__sum);
> }
> _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
> _M_p = 0;
> }
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> template<typename _Sseq>
> typename std::enable_if<std::is_class<_Sseq>::value>::type
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::
> seed(_Sseq& __q)
> {
> const size_t __k = (__w + 31) / 32;
> uint_least32_t __arr[__r * __k];
> __q.generate(__arr + 0, __arr + __r * __k);
>
> for (size_t __i = 0; __i < long_lag; ++__i)
> {
> _UIntType __sum = 0u;
> _UIntType __factor = 1u;
> for (size_t __j = 0; __j < __k; ++__j)
> {
> __sum += __arr[__k * __i + __j] * __factor;
> __factor *= __detail::_Shift<_UIntType, 32>::__value;
> }
> _M_x[__i] = __detail::__mod<_UIntType,
> __detail::_Shift<_UIntType, __w>::__value>(__sum);
> }
> _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
> _M_p = 0;
> }
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r>
> typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::
> result_type
> subtract_with_carry_engine<_UIntType, __w, __s, __r>::
> operator()()
> {
>
> long __ps = _M_p - short_lag;
> if (__ps < 0)
> __ps += long_lag;
>
>
>
>
> _UIntType __xi;
> if (_M_x[__ps] >= _M_x[_M_p] + _M_carry)
> {
> __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry;
> _M_carry = 0;
> }
> else
> {
> __xi = (__detail::_Shift<_UIntType, __w>::__value
> - _M_x[_M_p] - _M_carry + _M_x[__ps]);
> _M_carry = 1;
> }
> _M_x[_M_p] = __xi;
>
>
> if (++_M_p >= long_lag)
> _M_p = 0;
>
> return __xi;
> }
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const subtract_with_carry_engine<_UIntType,
> __w, __s, __r>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__space);
>
> for (size_t __i = 0; __i < __r; ++__i)
> __os << __x._M_x[__i] << __space;
> __os << __x._M_carry << __space << __x._M_p;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _UIntType, size_t __w, size_t __s, size_t __r,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> for (size_t __i = 0; __i < __r; ++__i)
> __is >> __x._M_x[__i];
> __is >> __x._M_carry;
> __is >> __x._M_p;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> constexpr size_t
> discard_block_engine<_RandomNumberEngine, __p, __r>::block_size;
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> constexpr size_t
> discard_block_engine<_RandomNumberEngine, __p, __r>::used_block;
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r>
> typename discard_block_engine<_RandomNumberEngine,
> __p, __r>::result_type
> discard_block_engine<_RandomNumberEngine, __p, __r>::
> operator()()
> {
> if (_M_n >= used_block)
> {
> _M_b.discard(block_size - _M_n);
> _M_n = 0;
> }
> ++_M_n;
> return _M_b();
> }
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const discard_block_engine<_RandomNumberEngine,
> __p, __r>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__space);
>
> __os << __x.base() << __space << __x._M_n;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _RandomNumberEngine, size_t __p, size_t __r,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> discard_block_engine<_RandomNumberEngine, __p, __r>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> __is >> __x._M_b >> __x._M_n;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
> typename independent_bits_engine<_RandomNumberEngine, __w, _UIntType>::
> result_type
> independent_bits_engine<_RandomNumberEngine, __w, _UIntType>::
> operator()()
> {
> typedef typename _RandomNumberEngine::result_type _Eresult_type;
> const _Eresult_type __r
> = (_M_b.max() - _M_b.min() < std::numeric_limits<_Eresult_type>::max()
> ? _M_b.max() - _M_b.min() + 1 : 0);
> const unsigned __edig = std::numeric_limits<_Eresult_type>::digits;
> const unsigned __m = __r ? std::__lg(__r) : __edig;
>
> typedef typename std::common_type<_Eresult_type, result_type>::type
> __ctype;
> const unsigned __cdig = std::numeric_limits<__ctype>::digits;
>
> unsigned __n, __n0;
> __ctype __s0, __s1, __y0, __y1;
>
> for (size_t __i = 0; __i < 2; ++__i)
> {
> __n = (__w + __m - 1) / __m + __i;
> __n0 = __n - __w % __n;
> const unsigned __w0 = __w / __n;
>
> __s0 = 0;
> __s1 = 0;
> if (__w0 < __cdig)
> {
> __s0 = __ctype(1) << __w0;
> __s1 = __s0 << 1;
> }
>
> __y0 = 0;
> __y1 = 0;
> if (__r)
> {
> __y0 = __s0 * (__r / __s0);
> if (__s1)
> __y1 = __s1 * (__r / __s1);
>
> if (__r - __y0 <= __y0 / __n)
> break;
> }
> else
> break;
> }
>
> result_type __sum = 0;
> for (size_t __k = 0; __k < __n0; ++__k)
> {
> __ctype __u;
> do
> __u = _M_b() - _M_b.min();
> while (__y0 && __u >= __y0);
> __sum = __s0 * __sum + (__s0 ? __u % __s0 : __u);
> }
> for (size_t __k = __n0; __k < __n; ++__k)
> {
> __ctype __u;
> do
> __u = _M_b() - _M_b.min();
> while (__y1 && __u >= __y1);
> __sum = __s1 * __sum + (__s1 ? __u % __s1 : __u);
> }
> return __sum;
> }
>
>
> template<typename _RandomNumberEngine, size_t __k>
> constexpr size_t
> shuffle_order_engine<_RandomNumberEngine, __k>::table_size;
>
> template<typename _RandomNumberEngine, size_t __k>
> typename shuffle_order_engine<_RandomNumberEngine, __k>::result_type
> shuffle_order_engine<_RandomNumberEngine, __k>::
> operator()()
> {
> size_t __j = __k * ((_M_y - _M_b.min())
> / (_M_b.max() - _M_b.min() + 1.0L));
> _M_y = _M_v[__j];
> _M_v[__j] = _M_b();
>
> return _M_y;
> }
>
> template<typename _RandomNumberEngine, size_t __k,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const shuffle_order_engine<_RandomNumberEngine, __k>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
> __os.fill(__space);
>
> __os << __x.base();
> for (size_t __i = 0; __i < __k; ++__i)
> __os << __space << __x._M_v[__i];
> __os << __space << __x._M_y;
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _RandomNumberEngine, size_t __k,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> shuffle_order_engine<_RandomNumberEngine, __k>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> __is >> __x._M_b;
> for (size_t __i = 0; __i < __k; ++__i)
> __is >> __x._M_v[__i];
> __is >> __x._M_y;
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename uniform_int_distribution<_IntType>::result_type
> uniform_int_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> typedef typename _UniformRandomNumberGenerator::result_type
> _Gresult_type;
> typedef typename std::make_unsigned<result_type>::type __utype;
> typedef typename std::common_type<_Gresult_type, __utype>::type
> __uctype;
>
> const __uctype __urngmin = __urng.min();
> const __uctype __urngmax = __urng.max();
> const __uctype __urngrange = __urngmax - __urngmin;
> const __uctype __urange
> = __uctype(__param.b()) - __uctype(__param.a());
>
> __uctype __ret;
>
> if (__urngrange > __urange)
> {
>
> const __uctype __uerange = __urange + 1;
> const __uctype __scaling = __urngrange / __uerange;
> const __uctype __past = __uerange * __scaling;
> do
> __ret = __uctype(__urng()) - __urngmin;
> while (__ret >= __past);
> __ret /= __scaling;
> }
> else if (__urngrange < __urange)
> {
># 910 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.tcc" 3
> __uctype __tmp;
> do
> {
> const __uctype __uerngrange = __urngrange + 1;
> __tmp = (__uerngrange * operator()
> (__urng, param_type(0, __urange / __uerngrange)));
> __ret = __tmp + (__uctype(__urng()) - __urngmin);
> }
> while (__ret > __urange || __ret < __tmp);
> }
> else
> __ret = __uctype(__urng()) - __urngmin;
>
> return __ret + __param.a();
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const uniform_int_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> return __os;
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> uniform_int_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _IntType __a, __b;
> __is >> __a >> __b;
> __x.param(typename uniform_int_distribution<_IntType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const uniform_real_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> uniform_real_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::skipws);
>
> _RealType __a, __b;
> __is >> __a >> __b;
> __x.param(typename uniform_real_distribution<_RealType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const bernoulli_distribution& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__os.widen(' '));
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.p();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename geometric_distribution<_IntType>::result_type
> geometric_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
>
>
> const double __naf =
> (1 - std::numeric_limits<double>::epsilon()) / 2;
>
> const double __thr =
> std::numeric_limits<_IntType>::max() + __naf;
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> double __cand;
> do
> __cand = std::floor(std::log(__aurng()) / __param._M_log_1_p);
> while (__cand >= __thr);
>
> return result_type(__cand + __naf);
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const geometric_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__os.widen(' '));
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.p();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> geometric_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::skipws);
>
> double __p;
> __is >> __p;
> __x.param(typename geometric_distribution<_IntType>::param_type(__p));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename negative_binomial_distribution<_IntType>::result_type
> negative_binomial_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng)
> {
> const double __y = _M_gd(__urng);
>
>
> std::poisson_distribution<result_type> __poisson(__y);
> return __poisson(__urng);
> }
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename negative_binomial_distribution<_IntType>::result_type
> negative_binomial_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> typedef typename std::gamma_distribution<result_type>::param_type
> param_type;
>
> const double __y =
> _M_gd(__urng, param_type(__p.k(), (1.0 - __p.p()) / __p.p()));
>
> std::poisson_distribution<result_type> __poisson(__y);
> return __poisson(__urng);
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const negative_binomial_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__os.widen(' '));
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.k() << __space << __x.p()
> << __space << __x._M_gd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> negative_binomial_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::skipws);
>
> _IntType __k;
> double __p;
> __is >> __k >> __p >> __x._M_gd;
> __x.param(typename negative_binomial_distribution<_IntType>::
> param_type(__k, __p));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> void
> poisson_distribution<_IntType>::param_type::
> _M_initialize()
> {
>
> if (_M_mean >= 12)
> {
> const double __m = std::floor(_M_mean);
> _M_lm_thr = std::log(_M_mean);
> _M_lfm = std::lgamma(__m + 1);
> _M_sm = std::sqrt(__m);
>
> const double __pi_4 = 0.7853981633974483096156608458198757L;
> const double __dx = std::sqrt(2 * __m * std::log(32 * __m
> / __pi_4));
> _M_d = std::round(std::max(6.0, std::min(__m, __dx)));
> const double __cx = 2 * __m + _M_d;
> _M_scx = std::sqrt(__cx / 2);
> _M_1cx = 1 / __cx;
>
> _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx);
> _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2))
> / _M_d;
> }
> else
>
> _M_lm_thr = std::exp(-_M_mean);
> }
># 1224 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.tcc" 3
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename poisson_distribution<_IntType>::result_type
> poisson_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> if (__param.mean() >= 12)
> {
> double __x;
>
>
> const double __naf =
> (1 - std::numeric_limits<double>::epsilon()) / 2;
> const double __thr =
> std::numeric_limits<_IntType>::max() + __naf;
>
> const double __m = std::floor(__param.mean());
>
> const double __spi_2 = 1.2533141373155002512078826424055226L;
> const double __c1 = __param._M_sm * __spi_2;
> const double __c2 = __param._M_c2b + __c1;
> const double __c3 = __c2 + 1;
> const double __c4 = __c3 + 1;
>
> const double __e178 = 1.0129030479320018583185514777512983L;
> const double __c5 = __c4 + __e178;
> const double __c = __param._M_cb + __c5;
> const double __2cx = 2 * (2 * __m + __param._M_d);
>
> bool __reject = true;
> do
> {
> const double __u = __c * __aurng();
> const double __e = -std::log(__aurng());
>
> double __w = 0.0;
>
> if (__u <= __c1)
> {
> const double __n = _M_nd(__urng);
> const double __y = -std::abs(__n) * __param._M_sm - 1;
> __x = std::floor(__y);
> __w = -__n * __n / 2;
> if (__x < -__m)
> continue;
> }
> else if (__u <= __c2)
> {
> const double __n = _M_nd(__urng);
> const double __y = 1 + std::abs(__n) * __param._M_scx;
> __x = std::ceil(__y);
> __w = __y * (2 - __y) * __param._M_1cx;
> if (__x > __param._M_d)
> continue;
> }
> else if (__u <= __c3)
>
>
> __x = -1;
> else if (__u <= __c4)
> __x = 0;
> else if (__u <= __c5)
> __x = 1;
> else
> {
> const double __v = -std::log(__aurng());
> const double __y = __param._M_d
> + __v * __2cx / __param._M_d;
> __x = std::ceil(__y);
> __w = -__param._M_d * __param._M_1cx * (1 + __y / 2);
> }
>
> __reject = (__w - __e - __x * __param._M_lm_thr
> > __param._M_lfm - std::lgamma(__x + __m + 1));
>
> __reject |= __x + __m >= __thr;
>
> } while (__reject);
>
> return result_type(__x + __m + __naf);
> }
> else
>
> {
> _IntType __x = 0;
> double __prod = 1.0;
>
> do
> {
> __prod *= __aurng();
> __x += 1;
> }
> while (__prod > __param._M_lm_thr);
>
> return __x - 1;
> }
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const poisson_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.mean() << __space << __x._M_nd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> poisson_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::skipws);
>
> double __mean;
> __is >> __mean >> __x._M_nd;
> __x.param(typename poisson_distribution<_IntType>::param_type(__mean));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> void
> binomial_distribution<_IntType>::param_type::
> _M_initialize()
> {
> const double __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p;
>
> _M_easy = true;
>
>
> if (_M_t * __p12 >= 8)
> {
> _M_easy = false;
> const double __np = std::floor(_M_t * __p12);
> const double __pa = __np / _M_t;
> const double __1p = 1 - __pa;
>
> const double __pi_4 = 0.7853981633974483096156608458198757L;
> const double __d1x =
> std::sqrt(__np * __1p * std::log(32 * __np
> / (81 * __pi_4 * __1p)));
> _M_d1 = std::round(std::max(1.0, __d1x));
> const double __d2x =
> std::sqrt(__np * __1p * std::log(32 * _M_t * __1p
> / (__pi_4 * __pa)));
> _M_d2 = std::round(std::max(1.0, __d2x));
>
>
> const double __spi_2 = 1.2533141373155002512078826424055226L;
> _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np));
> _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p));
> _M_c = 2 * _M_d1 / __np;
> _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2;
> const double __a12 = _M_a1 + _M_s2 * __spi_2;
> const double __s1s = _M_s1 * _M_s1;
> _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p))
> * 2 * __s1s / _M_d1
> * std::exp(-_M_d1 * _M_d1 / (2 * __s1s)));
> const double __s2s = _M_s2 * _M_s2;
> _M_s = (_M_a123 + 2 * __s2s / _M_d2
> * std::exp(-_M_d2 * _M_d2 / (2 * __s2s)));
> _M_lf = (std::lgamma(__np + 1)
> + std::lgamma(_M_t - __np + 1));
> _M_lp1p = std::log(__pa / __1p);
>
> _M_q = -std::log(1 - (__p12 - __pa) / __1p);
> }
> else
>
> _M_q = -std::log(1 - __p12);
> }
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename binomial_distribution<_IntType>::result_type
> binomial_distribution<_IntType>::
> _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t)
> {
> _IntType __x = 0;
> double __sum = 0.0;
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> do
> {
> const double __e = -std::log(__aurng());
> __sum += __e / (__t - __x);
> __x += 1;
> }
> while (__sum <= _M_param._M_q);
>
> return __x - 1;
> }
># 1456 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.tcc" 3
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename binomial_distribution<_IntType>::result_type
> binomial_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> result_type __ret;
> const _IntType __t = __param.t();
> const double __p = __param.p();
> const double __p12 = __p <= 0.5 ? __p : 1.0 - __p;
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
>
> if (!__param._M_easy)
> {
> double __x;
>
>
> const double __naf =
> (1 - std::numeric_limits<double>::epsilon()) / 2;
> const double __thr =
> std::numeric_limits<_IntType>::max() + __naf;
>
> const double __np = std::floor(__t * __p12);
>
>
> const double __spi_2 = 1.2533141373155002512078826424055226L;
> const double __a1 = __param._M_a1;
> const double __a12 = __a1 + __param._M_s2 * __spi_2;
> const double __a123 = __param._M_a123;
> const double __s1s = __param._M_s1 * __param._M_s1;
> const double __s2s = __param._M_s2 * __param._M_s2;
>
> bool __reject;
> do
> {
> const double __u = __param._M_s * __aurng();
>
> double __v;
>
> if (__u <= __a1)
> {
> const double __n = _M_nd(__urng);
> const double __y = __param._M_s1 * std::abs(__n);
> __reject = __y >= __param._M_d1;
> if (!__reject)
> {
> const double __e = -std::log(__aurng());
> __x = std::floor(__y);
> __v = -__e - __n * __n / 2 + __param._M_c;
> }
> }
> else if (__u <= __a12)
> {
> const double __n = _M_nd(__urng);
> const double __y = __param._M_s2 * std::abs(__n);
> __reject = __y >= __param._M_d2;
> if (!__reject)
> {
> const double __e = -std::log(__aurng());
> __x = std::floor(-__y);
> __v = -__e - __n * __n / 2;
> }
> }
> else if (__u <= __a123)
> {
> const double __e1 = -std::log(__aurng());
> const double __e2 = -std::log(__aurng());
>
> const double __y = __param._M_d1
> + 2 * __s1s * __e1 / __param._M_d1;
> __x = std::floor(__y);
> __v = (-__e2 + __param._M_d1 * (1 / (__t - __np)
> -__y / (2 * __s1s)));
> __reject = false;
> }
> else
> {
> const double __e1 = -std::log(__aurng());
> const double __e2 = -std::log(__aurng());
>
> const double __y = __param._M_d2
> + 2 * __s2s * __e1 / __param._M_d2;
> __x = std::floor(-__y);
> __v = -__e2 - __param._M_d2 * __y / (2 * __s2s);
> __reject = false;
> }
>
> __reject = __reject || __x < -__np || __x > __t - __np;
> if (!__reject)
> {
> const double __lfx =
> std::lgamma(__np + __x + 1)
> + std::lgamma(__t - (__np + __x) + 1);
> __reject = __v > __param._M_lf - __lfx
> + __x * __param._M_lp1p;
> }
>
> __reject |= __x + __np >= __thr;
> }
> while (__reject);
>
> __x += __np + __naf;
>
> const _IntType __z = _M_waiting(__urng, __t - _IntType(__x));
> __ret = _IntType(__x) + __z;
> }
> else
>
> __ret = _M_waiting(__urng, __t);
>
> if (__p12 != __p)
> __ret = __t - __ret;
> return __ret;
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const binomial_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> __os << __x.t() << __space << __x.p()
> << __space << __x._M_nd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType,
> typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> binomial_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _IntType __t;
> double __p;
> __is >> __t >> __p >> __x._M_nd;
> __x.param(typename binomial_distribution<_IntType>::
> param_type(__t, __p));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const exponential_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__os.widen(' '));
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.lambda();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> exponential_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __lambda;
> __is >> __lambda;
> __x.param(typename exponential_distribution<_RealType>::
> param_type(__lambda));
>
> __is.flags(__flags);
> return __is;
> }
># 1673 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/random.tcc" 3
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename normal_distribution<_RealType>::result_type
> normal_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> result_type __ret;
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
>
> if (_M_saved_available)
> {
> _M_saved_available = false;
> __ret = _M_saved;
> }
> else
> {
> result_type __x, __y, __r2;
> do
> {
> __x = result_type(2.0) * __aurng() - 1.0;
> __y = result_type(2.0) * __aurng() - 1.0;
> __r2 = __x * __x + __y * __y;
> }
> while (__r2 > 1.0 || __r2 == 0.0);
>
> const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
> _M_saved = __x * __mult;
> _M_saved_available = true;
> __ret = __y * __mult;
> }
>
> __ret = __ret * __param.stddev() + __param.mean();
> return __ret;
> }
>
> template<typename _RealType>
> bool
> operator==(const std::normal_distribution<_RealType>& __d1,
> const std::normal_distribution<_RealType>& __d2)
> {
> if (__d1._M_param == __d2._M_param
> && __d1._M_saved_available == __d2._M_saved_available)
> {
> if (__d1._M_saved_available
> && __d1._M_saved == __d2._M_saved)
> return true;
> else if(!__d1._M_saved_available)
> return true;
> else
> return false;
> }
> else
> return false;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const normal_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.mean() << __space << __x.stddev()
> << __space << __x._M_saved_available;
> if (__x._M_saved_available)
> __os << __space << __x._M_saved;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> normal_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> double __mean, __stddev;
> __is >> __mean >> __stddev
> >> __x._M_saved_available;
> if (__x._M_saved_available)
> __is >> __x._M_saved;
> __x.param(typename normal_distribution<_RealType>::
> param_type(__mean, __stddev));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const lognormal_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.m() << __space << __x.s()
> << __space << __x._M_nd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> lognormal_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __m, __s;
> __is >> __m >> __s >> __x._M_nd;
> __x.param(typename lognormal_distribution<_RealType>::
> param_type(__m, __s));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const chi_squared_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.n() << __space << __x._M_gd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> chi_squared_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __n;
> __is >> __n >> __x._M_gd;
> __x.param(typename chi_squared_distribution<_RealType>::
> param_type(__n));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename cauchy_distribution<_RealType>::result_type
> cauchy_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> _RealType __u;
> do
> __u = __aurng();
> while (__u == 0.5);
>
> const _RealType __pi = 3.1415926535897932384626433832795029L;
> return __p.a() + __p.b() * std::tan(__pi * __u);
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const cauchy_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> cauchy_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __a, __b;
> __is >> __a >> __b;
> __x.param(typename cauchy_distribution<_RealType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const fisher_f_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.m() << __space << __x.n()
> << __space << __x._M_gd_x << __space << __x._M_gd_y;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> fisher_f_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __m, __n;
> __is >> __m >> __n >> __x._M_gd_x >> __x._M_gd_y;
> __x.param(typename fisher_f_distribution<_RealType>::
> param_type(__m, __n));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const student_t_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.n() << __space << __x._M_nd << __space << __x._M_gd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> student_t_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __n;
> __is >> __n >> __x._M_nd >> __x._M_gd;
> __x.param(typename student_t_distribution<_RealType>::param_type(__n));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> void
> gamma_distribution<_RealType>::param_type::
> _M_initialize()
> {
> _M_malpha = _M_alpha < 1.0 ? _M_alpha + _RealType(1.0) : _M_alpha;
>
> const _RealType __a1 = _M_malpha - _RealType(1.0) / _RealType(3.0);
> _M_a2 = _RealType(1.0) / std::sqrt(_RealType(9.0) * __a1);
> }
>
>
>
>
>
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename gamma_distribution<_RealType>::result_type
> gamma_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
>
> result_type __u, __v, __n;
> const result_type __a1 = (__param._M_malpha
> - _RealType(1.0) / _RealType(3.0));
>
> do
> {
> do
> {
> __n = _M_nd(__urng);
> __v = result_type(1.0) + __param._M_a2 * __n;
> }
> while (__v <= 0.0);
>
> __v = __v * __v * __v;
> __u = __aurng();
> }
> while (__u > result_type(1.0) - 0.331 * __n * __n * __n * __n
> && (std::log(__u) > (0.5 * __n * __n + __a1
> * (1.0 - __v + std::log(__v)))));
>
> if (__param.alpha() == __param._M_malpha)
> return __a1 * __v * __param.beta();
> else
> {
> do
> __u = __aurng();
> while (__u == 0.0);
>
> return (std::pow(__u, result_type(1.0) / __param.alpha())
> * __a1 * __v * __param.beta());
> }
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const gamma_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.alpha() << __space << __x.beta()
> << __space << __x._M_nd;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> gamma_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __alpha_val, __beta_val;
> __is >> __alpha_val >> __beta_val >> __x._M_nd;
> __x.param(typename gamma_distribution<_RealType>::
> param_type(__alpha_val, __beta_val));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename weibull_distribution<_RealType>::result_type
> weibull_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> return __p.b() * std::pow(-std::log(__aurng()),
> result_type(1) / __p.a());
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const weibull_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> weibull_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __a, __b;
> __is >> __a >> __b;
> __x.param(typename weibull_distribution<_RealType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename extreme_value_distribution<_RealType>::result_type
> extreme_value_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __p)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
> __aurng(__urng);
> return __p.a() - __p.b() * std::log(-std::log(__aurng()));
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const extreme_value_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> __os << __x.a() << __space << __x.b();
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> extreme_value_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> _RealType __a, __b;
> __is >> __a >> __b;
> __x.param(typename extreme_value_distribution<_RealType>::
> param_type(__a, __b));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> void
> discrete_distribution<_IntType>::param_type::
> _M_initialize()
> {
> if (_M_prob.size() < 2)
> {
> _M_prob.clear();
> return;
> }
>
> const double __sum = std::accumulate(_M_prob.begin(),
> _M_prob.end(), 0.0);
>
> __detail::__transform(_M_prob.begin(), _M_prob.end(), _M_prob.begin(),
> std::bind2nd(std::divides<double>(), __sum));
>
> _M_cp.reserve(_M_prob.size());
> std::partial_sum(_M_prob.begin(), _M_prob.end(),
> std::back_inserter(_M_cp));
>
> _M_cp[_M_cp.size() - 1] = 1.0;
> }
>
> template<typename _IntType>
> template<typename _Func>
> discrete_distribution<_IntType>::param_type::
> param_type(size_t __nw, double __xmin, double __xmax, _Func __fw)
> : _M_prob(), _M_cp()
> {
> const size_t __n = __nw == 0 ? 1 : __nw;
> const double __delta = (__xmax - __xmin) / __n;
>
> _M_prob.reserve(__n);
> for (size_t __k = 0; __k < __nw; ++__k)
> _M_prob.push_back(__fw(__xmin + __k * __delta + 0.5 * __delta));
>
> _M_initialize();
> }
>
> template<typename _IntType>
> template<typename _UniformRandomNumberGenerator>
> typename discrete_distribution<_IntType>::result_type
> discrete_distribution<_IntType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> if (__param._M_cp.empty())
> return result_type(0);
>
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> const double __p = __aurng();
> auto __pos = std::lower_bound(__param._M_cp.begin(),
> __param._M_cp.end(), __p);
>
> return __pos - __param._M_cp.begin();
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const discrete_distribution<_IntType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<double>::max_digits10);
>
> std::vector<double> __prob = __x.probabilities();
> __os << __prob.size();
> for (auto __dit = __prob.begin(); __dit != __prob.end(); ++__dit)
> __os << __space << *__dit;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _IntType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> discrete_distribution<_IntType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> size_t __n;
> __is >> __n;
>
> std::vector<double> __prob_vec;
> __prob_vec.reserve(__n);
> for (; __n != 0; --__n)
> {
> double __prob;
> __is >> __prob;
> __prob_vec.push_back(__prob);
> }
>
> __x.param(typename discrete_distribution<_IntType>::
> param_type(__prob_vec.begin(), __prob_vec.end()));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> void
> piecewise_constant_distribution<_RealType>::param_type::
> _M_initialize()
> {
> if (_M_int.size() < 2
> || (_M_int.size() == 2
> && _M_int[0] == _RealType(0)
> && _M_int[1] == _RealType(1)))
> {
> _M_int.clear();
> _M_den.clear();
> return;
> }
>
> const double __sum = std::accumulate(_M_den.begin(),
> _M_den.end(), 0.0);
>
> __detail::__transform(_M_den.begin(), _M_den.end(), _M_den.begin(),
> std::bind2nd(std::divides<double>(), __sum));
>
> _M_cp.reserve(_M_den.size());
> std::partial_sum(_M_den.begin(), _M_den.end(),
> std::back_inserter(_M_cp));
>
>
> _M_cp[_M_cp.size() - 1] = 1.0;
>
> for (size_t __k = 0; __k < _M_den.size(); ++__k)
> _M_den[__k] /= _M_int[__k + 1] - _M_int[__k];
> }
>
> template<typename _RealType>
> template<typename _InputIteratorB, typename _InputIteratorW>
> piecewise_constant_distribution<_RealType>::param_type::
> param_type(_InputIteratorB __bbegin,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin)
> : _M_int(), _M_den(), _M_cp()
> {
> if (__bbegin != __bend)
> {
> for (;;)
> {
> _M_int.push_back(*__bbegin);
> ++__bbegin;
> if (__bbegin == __bend)
> break;
>
> _M_den.push_back(*__wbegin);
> ++__wbegin;
> }
> }
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _Func>
> piecewise_constant_distribution<_RealType>::param_type::
> param_type(initializer_list<_RealType> __bl, _Func __fw)
> : _M_int(), _M_den(), _M_cp()
> {
> _M_int.reserve(__bl.size());
> for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
> _M_int.push_back(*__biter);
>
> _M_den.reserve(_M_int.size() - 1);
> for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
> _M_den.push_back(__fw(0.5 * (_M_int[__k + 1] + _M_int[__k])));
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _Func>
> piecewise_constant_distribution<_RealType>::param_type::
> param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
> : _M_int(), _M_den(), _M_cp()
> {
> const size_t __n = __nw == 0 ? 1 : __nw;
> const _RealType __delta = (__xmax - __xmin) / __n;
>
> _M_int.reserve(__n + 1);
> for (size_t __k = 0; __k <= __nw; ++__k)
> _M_int.push_back(__xmin + __k * __delta);
>
> _M_den.reserve(__n);
> for (size_t __k = 0; __k < __nw; ++__k)
> _M_den.push_back(__fw(_M_int[__k] + 0.5 * __delta));
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename piecewise_constant_distribution<_RealType>::result_type
> piecewise_constant_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> const double __p = __aurng();
> if (__param._M_cp.empty())
> return __p;
>
> auto __pos = std::lower_bound(__param._M_cp.begin(),
> __param._M_cp.end(), __p);
> const size_t __i = __pos - __param._M_cp.begin();
>
> const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
>
> return __param._M_int[__i] + (__p - __pref) / __param._M_den[__i];
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const piecewise_constant_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> std::vector<_RealType> __int = __x.intervals();
> __os << __int.size() - 1;
>
> for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
> __os << __space << *__xit;
>
> std::vector<double> __den = __x.densities();
> for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
> __os << __space << *__dit;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> piecewise_constant_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> size_t __n;
> __is >> __n;
>
> std::vector<_RealType> __int_vec;
> __int_vec.reserve(__n + 1);
> for (size_t __i = 0; __i <= __n; ++__i)
> {
> _RealType __int;
> __is >> __int;
> __int_vec.push_back(__int);
> }
>
> std::vector<double> __den_vec;
> __den_vec.reserve(__n);
> for (size_t __i = 0; __i < __n; ++__i)
> {
> double __den;
> __is >> __den;
> __den_vec.push_back(__den);
> }
>
> __x.param(typename piecewise_constant_distribution<_RealType>::
> param_type(__int_vec.begin(), __int_vec.end(), __den_vec.begin()));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _RealType>
> void
> piecewise_linear_distribution<_RealType>::param_type::
> _M_initialize()
> {
> if (_M_int.size() < 2
> || (_M_int.size() == 2
> && _M_int[0] == _RealType(0)
> && _M_int[1] == _RealType(1)
> && _M_den[0] == _M_den[1]))
> {
> _M_int.clear();
> _M_den.clear();
> return;
> }
>
> double __sum = 0.0;
> _M_cp.reserve(_M_int.size() - 1);
> _M_m.reserve(_M_int.size() - 1);
> for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
> {
> const _RealType __delta = _M_int[__k + 1] - _M_int[__k];
> __sum += 0.5 * (_M_den[__k + 1] + _M_den[__k]) * __delta;
> _M_cp.push_back(__sum);
> _M_m.push_back((_M_den[__k + 1] - _M_den[__k]) / __delta);
> }
>
>
> __detail::__transform(_M_den.begin(), _M_den.end(), _M_den.begin(),
> std::bind2nd(std::divides<double>(), __sum));
>
> __detail::__transform(_M_cp.begin(), _M_cp.end(), _M_cp.begin(),
> std::bind2nd(std::divides<double>(), __sum));
>
> __detail::__transform(_M_m.begin(), _M_m.end(), _M_m.begin(),
> std::bind2nd(std::divides<double>(), __sum));
>
> _M_cp[_M_cp.size() - 1] = 1.0;
> }
>
> template<typename _RealType>
> template<typename _InputIteratorB, typename _InputIteratorW>
> piecewise_linear_distribution<_RealType>::param_type::
> param_type(_InputIteratorB __bbegin,
> _InputIteratorB __bend,
> _InputIteratorW __wbegin)
> : _M_int(), _M_den(), _M_cp(), _M_m()
> {
> for (; __bbegin != __bend; ++__bbegin, ++__wbegin)
> {
> _M_int.push_back(*__bbegin);
> _M_den.push_back(*__wbegin);
> }
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _Func>
> piecewise_linear_distribution<_RealType>::param_type::
> param_type(initializer_list<_RealType> __bl, _Func __fw)
> : _M_int(), _M_den(), _M_cp(), _M_m()
> {
> _M_int.reserve(__bl.size());
> _M_den.reserve(__bl.size());
> for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
> {
> _M_int.push_back(*__biter);
> _M_den.push_back(__fw(*__biter));
> }
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _Func>
> piecewise_linear_distribution<_RealType>::param_type::
> param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
> : _M_int(), _M_den(), _M_cp(), _M_m()
> {
> const size_t __n = __nw == 0 ? 1 : __nw;
> const _RealType __delta = (__xmax - __xmin) / __n;
>
> _M_int.reserve(__n + 1);
> _M_den.reserve(__n + 1);
> for (size_t __k = 0; __k <= __nw; ++__k)
> {
> _M_int.push_back(__xmin + __k * __delta);
> _M_den.push_back(__fw(_M_int[__k] + __delta));
> }
>
> _M_initialize();
> }
>
> template<typename _RealType>
> template<typename _UniformRandomNumberGenerator>
> typename piecewise_linear_distribution<_RealType>::result_type
> piecewise_linear_distribution<_RealType>::
> operator()(_UniformRandomNumberGenerator& __urng,
> const param_type& __param)
> {
> __detail::_Adaptor<_UniformRandomNumberGenerator, double>
> __aurng(__urng);
>
> const double __p = __aurng();
> if (__param._M_cp.empty())
> return __p;
>
> auto __pos = std::lower_bound(__param._M_cp.begin(),
> __param._M_cp.end(), __p);
> const size_t __i = __pos - __param._M_cp.begin();
>
> const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
>
> const double __a = 0.5 * __param._M_m[__i];
> const double __b = __param._M_den[__i];
> const double __cm = __p - __pref;
>
> _RealType __x = __param._M_int[__i];
> if (__a == 0)
> __x += __cm / __b;
> else
> {
> const double __d = __b * __b + 4.0 * __a * __cm;
> __x += 0.5 * (std::sqrt(__d) - __b) / __a;
> }
>
> return __x;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_ostream<_CharT, _Traits>&
> operator<<(std::basic_ostream<_CharT, _Traits>& __os,
> const piecewise_linear_distribution<_RealType>& __x)
> {
> typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
> typedef typename __ostream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __os.flags();
> const _CharT __fill = __os.fill();
> const std::streamsize __precision = __os.precision();
> const _CharT __space = __os.widen(' ');
> __os.flags(__ios_base::scientific | __ios_base::left);
> __os.fill(__space);
> __os.precision(std::numeric_limits<_RealType>::max_digits10);
>
> std::vector<_RealType> __int = __x.intervals();
> __os << __int.size() - 1;
>
> for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
> __os << __space << *__xit;
>
> std::vector<double> __den = __x.densities();
> for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
> __os << __space << *__dit;
>
> __os.flags(__flags);
> __os.fill(__fill);
> __os.precision(__precision);
> return __os;
> }
>
> template<typename _RealType, typename _CharT, typename _Traits>
> std::basic_istream<_CharT, _Traits>&
> operator>>(std::basic_istream<_CharT, _Traits>& __is,
> piecewise_linear_distribution<_RealType>& __x)
> {
> typedef std::basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::ios_base __ios_base;
>
> const typename __ios_base::fmtflags __flags = __is.flags();
> __is.flags(__ios_base::dec | __ios_base::skipws);
>
> size_t __n;
> __is >> __n;
>
> std::vector<_RealType> __int_vec;
> __int_vec.reserve(__n + 1);
> for (size_t __i = 0; __i <= __n; ++__i)
> {
> _RealType __int;
> __is >> __int;
> __int_vec.push_back(__int);
> }
>
> std::vector<double> __den_vec;
> __den_vec.reserve(__n + 1);
> for (size_t __i = 0; __i <= __n; ++__i)
> {
> double __den;
> __is >> __den;
> __den_vec.push_back(__den);
> }
>
> __x.param(typename piecewise_linear_distribution<_RealType>::
> param_type(__int_vec.begin(), __int_vec.end(), __den_vec.begin()));
>
> __is.flags(__flags);
> return __is;
> }
>
>
> template<typename _IntType>
> seed_seq::seed_seq(std::initializer_list<_IntType> __il)
> {
> for (auto __iter = __il.begin(); __iter != __il.end(); ++__iter)
> _M_v.push_back(__detail::__mod<result_type,
> __detail::_Shift<result_type, 32>::__value>(*__iter));
> }
>
> template<typename _InputIterator>
> seed_seq::seed_seq(_InputIterator __begin, _InputIterator __end)
> {
> for (_InputIterator __iter = __begin; __iter != __end; ++__iter)
> _M_v.push_back(__detail::__mod<result_type,
> __detail::_Shift<result_type, 32>::__value>(*__iter));
> }
>
> template<typename _RandomAccessIterator>
> void
> seed_seq::generate(_RandomAccessIterator __begin,
> _RandomAccessIterator __end)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _Type;
>
> if (__begin == __end)
> return;
>
> std::fill(__begin, __end, _Type(0x8b8b8b8bu));
>
> const size_t __n = __end - __begin;
> const size_t __s = _M_v.size();
> const size_t __t = (__n >= 623) ? 11
> : (__n >= 68) ? 7
> : (__n >= 39) ? 5
> : (__n >= 7) ? 3
> : (__n - 1) / 2;
> const size_t __p = (__n - __t) / 2;
> const size_t __q = __p + __t;
> const size_t __m = std::max(__s + 1, __n);
>
> for (size_t __k = 0; __k < __m; ++__k)
> {
> _Type __arg = (__begin[__k % __n]
> ^ __begin[(__k + __p) % __n]
> ^ __begin[(__k - 1) % __n]);
> _Type __r1 = __arg ^ (__arg >> 27);
> __r1 = __detail::__mod<_Type,
> __detail::_Shift<_Type, 32>::__value>(1664525u * __r1);
> _Type __r2 = __r1;
> if (__k == 0)
> __r2 += __s;
> else if (__k <= __s)
> __r2 += __k % __n + _M_v[__k - 1];
> else
> __r2 += __k % __n;
> __r2 = __detail::__mod<_Type,
> __detail::_Shift<_Type, 32>::__value>(__r2);
> __begin[(__k + __p) % __n] += __r1;
> __begin[(__k + __q) % __n] += __r2;
> __begin[__k % __n] = __r2;
> }
>
> for (size_t __k = __m; __k < __m + __n; ++__k)
> {
> _Type __arg = (__begin[__k % __n]
> + __begin[(__k + __p) % __n]
> + __begin[(__k - 1) % __n]);
> _Type __r3 = __arg ^ (__arg >> 27);
> __r3 = __detail::__mod<_Type,
> __detail::_Shift<_Type, 32>::__value>(1566083941u * __r3);
> _Type __r4 = __r3 - __k % __n;
> __r4 = __detail::__mod<_Type,
> __detail::_Shift<_Type, 32>::__value>(__r4);
> __begin[(__k + __p) % __n] ^= __r3;
> __begin[(__k + __q) % __n] ^= __r4;
> __begin[__k % __n] = __r4;
> }
> }
>
> template<typename _RealType, size_t __bits,
> typename _UniformRandomNumberGenerator>
> _RealType
> generate_canonical(_UniformRandomNumberGenerator& __urng)
> {
> const size_t __b
> = std::min(static_cast<size_t>(std::numeric_limits<_RealType>::digits),
> __bits);
> const long double __r = static_cast<long double>(__urng.max())
> - static_cast<long double>(__urng.min()) + 1.0L;
> const size_t __log2r = std::log(__r) / std::log(2.0L);
> size_t __k = std::max<size_t>(1UL, (__b + __log2r - 1UL) / __log2r);
> _RealType __sum = _RealType(0);
> _RealType __tmp = _RealType(1);
> for (; __k != 0; --__k)
> {
> __sum += _RealType(__urng() - __urng.min()) * __tmp;
> __tmp *= __r;
> }
> return __sum / __tmp;
> }
>
>
>}
># 52 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/random" 2 3
># 68 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 1 3
># 47 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> 
># 48 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/typeinfo" 1 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/typeinfo" 3
> 
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/typeinfo" 3
>
>
>
>
>
>
>#pragma GCC visibility push(default)
>
>extern "C++" {
>
>namespace __cxxabiv1
>{
> class __class_type_info;
>}
># 82 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/typeinfo" 3
>namespace std
>{
>
>
>
>
>
>
> class type_info
> {
> public:
>
>
>
>
> virtual ~type_info();
>
>
>
> const char* name() const
> { return __name[0] == '*' ? __name + 1 : __name; }
># 117 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/typeinfo" 3
> bool before(const type_info& __arg) const
> { return (__name[0] == '*' && __arg.__name[0] == '*')
> ? __name < __arg.__name
> : __builtin_strcmp (__name, __arg.__name) < 0; }
>
> bool operator==(const type_info& __arg) const
> {
> return ((__name == __arg.__name)
> || (__name[0] != '*' &&
> __builtin_strcmp (__name, __arg.__name) == 0));
> }
># 138 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/typeinfo" 3
> bool operator!=(const type_info& __arg) const
> { return !operator==(__arg); }
>
>
> size_t hash_code() const noexcept
> {
>
> return _Hash_bytes(name(), __builtin_strlen(name()),
> static_cast<size_t>(0xc70f6907UL));
>
>
>
> }
>
>
>
> virtual bool __is_pointer_p() const;
>
>
> virtual bool __is_function_p() const;
>
>
>
>
>
>
>
> virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
> unsigned __outer) const;
>
>
> virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
> void **__obj_ptr) const;
>
> protected:
> const char *__name;
>
> explicit type_info(const char *__n): __name(__n) { }
>
> private:
>
> type_info& operator=(const type_info&);
> type_info(const type_info&);
> };
>
>
>
>
>
>
>
> class bad_cast : public exception
> {
> public:
> bad_cast() noexcept { }
>
>
>
> virtual ~bad_cast() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>
>
>
>
>
> class bad_typeid : public exception
> {
> public:
> bad_typeid () noexcept { }
>
>
>
> virtual ~bad_typeid() noexcept;
>
>
> virtual const char* what() const noexcept;
> };
>}
>
>}
>
>#pragma GCC visibility pop
># 55 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 2 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/tuple" 1 3
># 32 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/tuple" 3
> 
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/tuple" 3
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/uses_allocator.h" 1 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/uses_allocator.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> struct allocator_arg_t { };
>
> constexpr allocator_arg_t allocator_arg = allocator_arg_t();
>
>template<typename _Tp> class __has_allocator_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::allocator_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_allocator_type : integral_constant<bool, __has_allocator_type_helper <typename remove_cv<_Tp>::type>::value> { };
>
> template<typename _Tp, typename _Alloc,
> bool = __has_allocator_type<_Tp>::value>
> struct __uses_allocator_helper
> : public false_type { };
>
> template<typename _Tp, typename _Alloc>
> struct __uses_allocator_helper<_Tp, _Alloc, true>
> : public integral_constant<bool, is_convertible<_Alloc,
> typename _Tp::allocator_type>::value>
> { };
>
>
> template<typename _Tp, typename _Alloc>
> struct uses_allocator
> : public integral_constant<bool,
> __uses_allocator_helper<_Tp, _Alloc>::value>
> { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_allocator_arg
> : is_constructible<_Tp, _Alloc, _Args...>
> { static_assert( uses_allocator<_Tp, _Alloc>::value, "uses allocator" ); };
>
> struct __uses_alloc_base { };
> struct __uses_alloc0 : __uses_alloc_base
> { struct _Anything { _Anything(...) { } } _M_a; };
> template<typename _Alloc>
> struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };
> template<typename _Alloc>
> struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };
>
> template<bool, typename _Alloc, typename... _Args>
> struct __uses_alloc;
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_alloc<true, _Tp, _Alloc, _Args...>
> : conditional<
> is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value,
> __uses_alloc1<_Alloc>,
> __uses_alloc2<_Alloc>>::type
> { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_alloc<false, _Tp, _Alloc, _Args...>
> : __uses_alloc0 { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> struct __uses_alloc_impl
> : __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>
> { };
>
> template<typename _Tp, typename _Alloc, typename... _Args>
> __uses_alloc_impl<_Tp, _Alloc, _Args...>
> __use_alloc(const _Alloc& __a)
> {
> __uses_alloc_impl<_Tp, _Alloc, _Args...> __ret;
> __ret._M_a = &__a;
> return __ret;
> }
>
>
>}
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/tuple" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Tp>
> struct __add_c_ref
> { typedef const _Tp& type; };
>
> template<typename _Tp>
> struct __add_c_ref<_Tp&>
> { typedef _Tp& type; };
>
>
> template<typename _Tp>
> struct __add_ref
> { typedef _Tp& type; };
>
> template<typename _Tp>
> struct __add_ref<_Tp&>
> { typedef _Tp& type; };
>
>
> template<typename _Tp>
> struct __add_r_ref
> { typedef _Tp&& type; };
>
> template<typename _Tp>
> struct __add_r_ref<_Tp&>
> { typedef _Tp& type; };
>
> template<std::size_t _Idx, typename _Head, bool _IsEmptyNotFinal>
> struct _Head_base;
>
> template<std::size_t _Idx, typename _Head>
> struct _Head_base<_Idx, _Head, true>
> : public _Head
> {
> constexpr _Head_base()
> : _Head() { }
>
> constexpr _Head_base(const _Head& __h)
> : _Head(__h) { }
>
> template<typename _UHead, typename = typename
> enable_if<!is_convertible<_UHead,
> __uses_alloc_base>::value>::type>
> constexpr _Head_base(_UHead&& __h)
> : _Head(std::forward<_UHead>(__h)) { }
>
> _Head_base(__uses_alloc0)
> : _Head() { }
>
> template<typename _Alloc>
> _Head_base(__uses_alloc1<_Alloc> __a)
> : _Head(allocator_arg, *__a._M_a) { }
>
> template<typename _Alloc>
> _Head_base(__uses_alloc2<_Alloc> __a)
> : _Head(*__a._M_a) { }
>
> template<typename _UHead>
> _Head_base(__uses_alloc0, _UHead&& __uhead)
> : _Head(std::forward<_UHead>(__uhead)) { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
> : _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
> : _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
>
> static constexpr _Head&
> _M_head(_Head_base& __b) noexcept { return __b; }
>
> static constexpr const _Head&
> _M_head(const _Head_base& __b) noexcept { return __b; }
> };
>
> template<std::size_t _Idx, typename _Head>
> struct _Head_base<_Idx, _Head, false>
> {
> constexpr _Head_base()
> : _M_head_impl() { }
>
> constexpr _Head_base(const _Head& __h)
> : _M_head_impl(__h) { }
>
> template<typename _UHead, typename = typename
> enable_if<!is_convertible<_UHead,
> __uses_alloc_base>::value>::type>
> constexpr _Head_base(_UHead&& __h)
> : _M_head_impl(std::forward<_UHead>(__h)) { }
>
> _Head_base(__uses_alloc0)
> : _M_head_impl() { }
>
> template<typename _Alloc>
> _Head_base(__uses_alloc1<_Alloc> __a)
> : _M_head_impl(allocator_arg, *__a._M_a) { }
>
> template<typename _Alloc>
> _Head_base(__uses_alloc2<_Alloc> __a)
> : _M_head_impl(*__a._M_a) { }
>
> template<typename _UHead>
> _Head_base(__uses_alloc0, _UHead&& __uhead)
> : _M_head_impl(std::forward<_UHead>(__uhead)) { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
> : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
> { }
>
> template<typename _Alloc, typename _UHead>
> _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
> : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
>
> static constexpr _Head&
> _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
>
> static constexpr const _Head&
> _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
>
> _Head _M_head_impl;
> };
># 177 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/tuple" 3
> template<std::size_t _Idx, typename... _Elements>
> struct _Tuple_impl;
>
>
>
>
>
> template<std::size_t _Idx>
> struct _Tuple_impl<_Idx>
> {
> template<std::size_t, typename...> friend class _Tuple_impl;
>
> _Tuple_impl() = default;
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t, const _Alloc&) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t, const _Alloc&, const _Tuple_impl&) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t, const _Alloc&, _Tuple_impl&&) { }
>
> protected:
> void _M_swap(_Tuple_impl&) noexcept { }
> };
>
>
> template<typename _Tp>
> using __empty_not_final
> = typename conditional<__is_final(_Tp), false_type, is_empty<_Tp>>::type;
>
>
>
>
>
>
> template<std::size_t _Idx, typename _Head, typename... _Tail>
> struct _Tuple_impl<_Idx, _Head, _Tail...>
> : public _Tuple_impl<_Idx + 1, _Tail...>,
> private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
> {
> template<std::size_t, typename...> friend class _Tuple_impl;
>
> typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
> typedef _Head_base<_Idx, _Head, __empty_not_final<_Head>::value> _Base;
>
> static constexpr _Head&
> _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
>
> static constexpr const _Head&
> _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
>
> static constexpr _Inherited&
> _M_tail(_Tuple_impl& __t) noexcept { return __t; }
>
> static constexpr const _Inherited&
> _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
>
> constexpr _Tuple_impl()
> : _Inherited(), _Base() { }
>
> explicit
> constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
> : _Inherited(__tail...), _Base(__head) { }
>
> template<typename _UHead, typename... _UTail, typename = typename
> enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
> explicit
> constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
> : _Inherited(std::forward<_UTail>(__tail)...),
> _Base(std::forward<_UHead>(__head)) { }
>
> constexpr _Tuple_impl(const _Tuple_impl&) = default;
>
> constexpr
> _Tuple_impl(_Tuple_impl&& __in)
> noexcept(__and_<is_nothrow_move_constructible<_Head>,
> is_nothrow_move_constructible<_Inherited>>::value)
> : _Inherited(std::move(_M_tail(__in))),
> _Base(std::forward<_Head>(_M_head(__in))) { }
>
> template<typename... _UElements>
> constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
> : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
> _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
>
> template<typename _UHead, typename... _UTails>
> constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
> : _Inherited(std::move
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
> _Base(std::forward<_UHead>
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
> : _Inherited(__tag, __a),
> _Base(__use_alloc<_Head>(__a)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Head& __head, const _Tail&... __tail)
> : _Inherited(__tag, __a, __tail...),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
>
> template<typename _Alloc, typename _UHead, typename... _UTail,
> typename = typename enable_if<sizeof...(_Tail)
> == sizeof...(_UTail)>::type>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _UHead&& __head, _UTail&&... __tail)
> : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
> _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
> std::forward<_UHead>(__head)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Tuple_impl& __in)
> : _Inherited(__tag, __a, _M_tail(__in)),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
>
> template<typename _Alloc>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _Tuple_impl&& __in)
> : _Inherited(__tag, __a, std::move(_M_tail(__in))),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
> std::forward<_Head>(_M_head(__in))) { }
>
> template<typename _Alloc, typename... _UElements>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> const _Tuple_impl<_Idx, _UElements...>& __in)
> : _Inherited(__tag, __a,
> _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
> _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
> _Tuple_impl<_Idx, _UElements...>::_M_head(__in)) { }
>
> template<typename _Alloc, typename _UHead, typename... _UTails>
> _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
> _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
> : _Inherited(__tag, __a, std::move
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
> _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
> std::forward<_UHead>
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) { }
>
> _Tuple_impl&
> operator=(const _Tuple_impl& __in)
> {
> _M_head(*this) = _M_head(__in);
> _M_tail(*this) = _M_tail(__in);
> return *this;
> }
>
> _Tuple_impl&
> operator=(_Tuple_impl&& __in)
> noexcept(__and_<is_nothrow_move_assignable<_Head>,
> is_nothrow_move_assignable<_Inherited>>::value)
> {
> _M_head(*this) = std::forward<_Head>(_M_head(__in));
> _M_tail(*this) = std::move(_M_tail(__in));
> return *this;
> }
>
> template<typename... _UElements>
> _Tuple_impl&
> operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
> {
> _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
> _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_M_tail(__in);
> return *this;
> }
>
> template<typename _UHead, typename... _UTails>
> _Tuple_impl&
> operator=(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
> {
> _M_head(*this) = std::forward<_UHead>
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
> _M_tail(*this) = std::move
> (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
> return *this;
> }
>
> protected:
> void
> _M_swap(_Tuple_impl& __in)
> noexcept(noexcept(swap(std::declval<_Head&>(),
> std::declval<_Head&>()))
> && noexcept(_M_tail(__in)._M_swap(_M_tail(__in))))
> {
> using std::swap;
> swap(_M_head(*this), _M_head(__in));
> _Inherited::_M_swap(_M_tail(__in));
> }
> };
>
>
> template<typename... _Elements>
> class tuple : public _Tuple_impl<0, _Elements...>
> {
> typedef _Tuple_impl<0, _Elements...> _Inherited;
>
> public:
> constexpr tuple()
> : _Inherited() { }
>
> explicit
> constexpr tuple(const _Elements&... __elements)
> : _Inherited(__elements...) { }
>
> template<typename... _UElements, typename = typename
> enable_if<__and_<is_convertible<_UElements,
> _Elements>...>::value>::type>
> explicit
> constexpr tuple(_UElements&&... __elements)
> : _Inherited(std::forward<_UElements>(__elements)...) { }
>
> constexpr tuple(const tuple&) = default;
>
> constexpr tuple(tuple&&) = default;
>
> template<typename... _UElements, typename = typename
> enable_if<__and_<is_convertible<const _UElements&,
> _Elements>...>::value>::type>
> constexpr tuple(const tuple<_UElements...>& __in)
> : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
> { }
>
> template<typename... _UElements, typename = typename
> enable_if<__and_<is_convertible<_UElements,
> _Elements>...>::value>::type>
> constexpr tuple(tuple<_UElements...>&& __in)
> : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
>
>
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a)
> : _Inherited(__tag, __a) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const _Elements&... __elements)
> : _Inherited(__tag, __a, __elements...) { }
>
> template<typename _Alloc, typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> _UElements&&... __elements)
> : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
> { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
> : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
> : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
>
> template<typename _Alloc, typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const tuple<_UElements...>& __in)
> : _Inherited(__tag, __a,
> static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
> { }
>
> template<typename _Alloc, typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> tuple<_UElements...>&& __in)
> : _Inherited(__tag, __a,
> static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
> { }
>
> tuple&
> operator=(const tuple& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> tuple&
> operator=(tuple&& __in)
> noexcept(is_nothrow_move_assignable<_Inherited>::value)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> template<typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple&
> operator=(const tuple<_UElements...>& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> template<typename... _UElements, typename = typename
> enable_if<sizeof...(_UElements)
> == sizeof...(_Elements)>::type>
> tuple&
> operator=(tuple<_UElements...>&& __in)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> void
> swap(tuple& __in)
> noexcept(noexcept(__in._M_swap(__in)))
> { _Inherited::_M_swap(__in); }
> };
>
>
> template<>
> class tuple<>
> {
> public:
> void swap(tuple&) noexcept { }
> };
>
>
>
> template<typename _T1, typename _T2>
> class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
> {
> typedef _Tuple_impl<0, _T1, _T2> _Inherited;
>
> public:
> constexpr tuple()
> : _Inherited() { }
>
> explicit
> constexpr tuple(const _T1& __a1, const _T2& __a2)
> : _Inherited(__a1, __a2) { }
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> explicit
> constexpr tuple(_U1&& __a1, _U2&& __a2)
> : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
>
> constexpr tuple(const tuple&) = default;
>
> constexpr tuple(tuple&&) = default;
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<const _U1&, _T1>,
> is_convertible<const _U2&, _T2>>::value>::type>
> constexpr tuple(const tuple<_U1, _U2>& __in)
> : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> constexpr tuple(tuple<_U1, _U2>&& __in)
> : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<const _U1&, _T1>,
> is_convertible<const _U2&, _T2>>::value>::type>
> constexpr tuple(const pair<_U1, _U2>& __in)
> : _Inherited(__in.first, __in.second) { }
>
> template<typename _U1, typename _U2, typename = typename
> enable_if<__and_<is_convertible<_U1, _T1>,
> is_convertible<_U2, _T2>>::value>::type>
> constexpr tuple(pair<_U1, _U2>&& __in)
> : _Inherited(std::forward<_U1>(__in.first),
> std::forward<_U2>(__in.second)) { }
>
>
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a)
> : _Inherited(__tag, __a) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const _T1& __a1, const _T2& __a2)
> : _Inherited(__tag, __a, __a1, __a2) { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
> : _Inherited(__tag, __a, std::forward<_U1>(__a1),
> std::forward<_U2>(__a2)) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
> : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
>
> template<typename _Alloc>
> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
> : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const tuple<_U1, _U2>& __in)
> : _Inherited(__tag, __a,
> static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
> { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
> : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
> { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a,
> const pair<_U1, _U2>& __in)
> : _Inherited(__tag, __a, __in.first, __in.second) { }
>
> template<typename _Alloc, typename _U1, typename _U2>
> tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
> : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
> std::forward<_U2>(__in.second)) { }
>
> tuple&
> operator=(const tuple& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> tuple&
> operator=(tuple&& __in)
> noexcept(is_nothrow_move_assignable<_Inherited>::value)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(const tuple<_U1, _U2>& __in)
> {
> static_cast<_Inherited&>(*this) = __in;
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(tuple<_U1, _U2>&& __in)
> {
> static_cast<_Inherited&>(*this) = std::move(__in);
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(const pair<_U1, _U2>& __in)
> {
> this->_M_head(*this) = __in.first;
> this->_M_tail(*this)._M_head(*this) = __in.second;
> return *this;
> }
>
> template<typename _U1, typename _U2>
> tuple&
> operator=(pair<_U1, _U2>&& __in)
> {
> this->_M_head(*this) = std::forward<_U1>(__in.first);
> this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
> return *this;
> }
>
> void
> swap(tuple& __in)
> noexcept(noexcept(__in._M_swap(__in)))
> { _Inherited::_M_swap(__in); }
> };
>
>
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element;
>
>
>
>
>
> template<std::size_t __i, typename _Head, typename... _Tail>
> struct tuple_element<__i, tuple<_Head, _Tail...> >
> : tuple_element<__i - 1, tuple<_Tail...> > { };
>
>
>
>
> template<typename _Head, typename... _Tail>
> struct tuple_element<0, tuple<_Head, _Tail...> >
> {
> typedef _Head type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, const _Tp>
> {
> typedef typename
> add_const<typename tuple_element<__i, _Tp>::type>::type type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, volatile _Tp>
> {
> typedef typename
> add_volatile<typename tuple_element<__i, _Tp>::type>::type type;
> };
>
> template<std::size_t __i, typename _Tp>
> struct tuple_element<__i, const volatile _Tp>
> {
> typedef typename
> add_cv<typename tuple_element<__i, _Tp>::type>::type type;
> };
>
>
> template<typename _Tp>
> struct tuple_size;
>
> template<typename _Tp>
> struct tuple_size<const _Tp>
> : public integral_constant<
> typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
> tuple_size<_Tp>::value> { };
>
> template<typename _Tp>
> struct tuple_size<volatile _Tp>
> : public integral_constant<
> typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
> tuple_size<_Tp>::value> { };
>
> template<typename _Tp>
> struct tuple_size<const volatile _Tp>
> : public integral_constant<
> typename remove_cv<decltype(tuple_size<_Tp>::value)>::type,
> tuple_size<_Tp>::value> { };
>
>
> template<typename... _Elements>
> struct tuple_size<tuple<_Elements...>>
> : public integral_constant<std::size_t, sizeof...(_Elements)> { };
>
> template<std::size_t __i, typename _Head, typename... _Tail>
> constexpr typename __add_ref<_Head>::type
> __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
> { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
>
> template<std::size_t __i, typename _Head, typename... _Tail>
> constexpr typename __add_c_ref<_Head>::type
> __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
> { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
>
>
>
>
> template<std::size_t __i, typename... _Elements>
> constexpr typename __add_ref<
> typename tuple_element<__i, tuple<_Elements...>>::type
> >::type
> get(tuple<_Elements...>& __t) noexcept
> { return __get_helper<__i>(__t); }
>
> template<std::size_t __i, typename... _Elements>
> constexpr typename __add_c_ref<
> typename tuple_element<__i, tuple<_Elements...>>::type
> >::type
> get(const tuple<_Elements...>& __t) noexcept
> { return __get_helper<__i>(__t); }
>
> template<std::size_t __i, typename... _Elements>
> constexpr typename __add_r_ref<
> typename tuple_element<__i, tuple<_Elements...>>::type
> >::type
> get(tuple<_Elements...>&& __t) noexcept
> { return std::forward<typename tuple_element<__i,
> tuple<_Elements...>>::type&&>(get<__i>(__t)); }
>
>
> template<std::size_t __check_equal_size, std::size_t __i, std::size_t __j,
> typename _Tp, typename _Up>
> struct __tuple_compare;
>
> template<std::size_t __i, std::size_t __j, typename _Tp, typename _Up>
> struct __tuple_compare<0, __i, __j, _Tp, _Up>
> {
> static bool
> __eq(const _Tp& __t, const _Up& __u)
> {
> return (get<__i>(__t) == get<__i>(__u) &&
> __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__eq(__t, __u));
> }
>
> static bool
> __less(const _Tp& __t, const _Up& __u)
> {
> return ((get<__i>(__t) < get<__i>(__u))
> || !(get<__i>(__u) < get<__i>(__t)) &&
> __tuple_compare<0, __i + 1, __j, _Tp, _Up>::__less(__t, __u));
> }
> };
>
> template<std::size_t __i, typename _Tp, typename _Up>
> struct __tuple_compare<0, __i, __i, _Tp, _Up>
> {
> static bool
> __eq(const _Tp&, const _Up&) { return true; }
>
> static bool
> __less(const _Tp&, const _Up&) { return false; }
> };
>
> template<typename... _TElements, typename... _UElements>
> bool
> operator==(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> {
> typedef tuple<_TElements...> _Tp;
> typedef tuple<_UElements...> _Up;
> return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
> 0, tuple_size<_Tp>::value, _Tp, _Up>::__eq(__t, __u));
> }
>
> template<typename... _TElements, typename... _UElements>
> bool
> operator<(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> {
> typedef tuple<_TElements...> _Tp;
> typedef tuple<_UElements...> _Up;
> return (__tuple_compare<tuple_size<_Tp>::value - tuple_size<_Up>::value,
> 0, tuple_size<_Tp>::value, _Tp, _Up>::__less(__t, __u));
> }
>
> template<typename... _TElements, typename... _UElements>
> inline bool
> operator!=(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return !(__t == __u); }
>
> template<typename... _TElements, typename... _UElements>
> inline bool
> operator>(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return __u < __t; }
>
> template<typename... _TElements, typename... _UElements>
> inline bool
> operator<=(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return !(__u < __t); }
>
> template<typename... _TElements, typename... _UElements>
> inline bool
> operator>=(const tuple<_TElements...>& __t,
> const tuple<_UElements...>& __u)
> { return !(__t < __u); }
>
>
> template<typename... _Elements>
> constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
> make_tuple(_Elements&&... __args)
> {
> typedef tuple<typename __decay_and_strip<_Elements>::__type...>
> __result_type;
> return __result_type(std::forward<_Elements>(__args)...);
> }
>
> template<typename... _Elements>
> constexpr tuple<_Elements&&...>
> forward_as_tuple(_Elements&&... __args) noexcept
> { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
>
>
> template<typename, std::size_t> struct array;
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr _Tp& get(array<_Tp, _Nm>&) noexcept;
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr _Tp&& get(array<_Tp, _Nm>&&) noexcept;
>
> template<std::size_t _Int, typename _Tp, std::size_t _Nm>
> constexpr const _Tp& get(const array<_Tp, _Nm>&) noexcept;
>
> template<typename>
> struct __is_tuple_like_impl : false_type
> { };
>
> template<typename... _Tps>
> struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
> { };
>
> template<typename _T1, typename _T2>
> struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
> { };
>
> template<typename _Tp, std::size_t _Nm>
> struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
> { };
>
>
> template<typename _Tp>
> struct __is_tuple_like
> : public __is_tuple_like_impl<typename std::remove_cv
> <typename std::remove_reference<_Tp>::type>::type>::type
> { };
>
>
>
> template<std::size_t... _Indexes>
> struct _Index_tuple
> {
> typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
> };
>
>
> template<std::size_t _Num>
> struct _Build_index_tuple
> {
> typedef typename _Build_index_tuple<_Num - 1>::__type::__next __type;
> };
>
> template<>
> struct _Build_index_tuple<0>
> {
> typedef _Index_tuple<> __type;
> };
>
> template<std::size_t, typename, typename, std::size_t>
> struct __make_tuple_impl;
>
> template<std::size_t _Idx, typename _Tuple, typename... _Tp,
> std::size_t _Nm>
> struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
> {
> typedef typename __make_tuple_impl<_Idx + 1, tuple<_Tp...,
> typename std::tuple_element<_Idx, _Tuple>::type>, _Tuple, _Nm>::__type
> __type;
> };
>
> template<std::size_t _Nm, typename _Tuple, typename... _Tp>
> struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
> {
> typedef tuple<_Tp...> __type;
> };
>
> template<typename _Tuple>
> struct __do_make_tuple
> : public __make_tuple_impl<0, tuple<>, _Tuple,
> std::tuple_size<_Tuple>::value>
> { };
>
>
> template<typename _Tuple>
> struct __make_tuple
> : public __do_make_tuple<typename std::remove_cv
> <typename std::remove_reference<_Tuple>::type>::type>
> { };
>
>
> template<typename...>
> struct __combine_tuples;
>
> template<>
> struct __combine_tuples<>
> {
> typedef tuple<> __type;
> };
>
> template<typename... _Ts>
> struct __combine_tuples<tuple<_Ts...>>
> {
> typedef tuple<_Ts...> __type;
> };
>
> template<typename... _T1s, typename... _T2s, typename... _Rem>
> struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
> {
> typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
> _Rem...>::__type __type;
> };
>
>
> template<typename... _Tpls>
> struct __tuple_cat_result
> {
> typedef typename __combine_tuples
> <typename __make_tuple<_Tpls>::__type...>::__type __type;
> };
>
>
>
> template<typename...>
> struct __make_1st_indices;
>
> template<>
> struct __make_1st_indices<>
> {
> typedef std::_Index_tuple<> __type;
> };
>
> template<typename _Tp, typename... _Tpls>
> struct __make_1st_indices<_Tp, _Tpls...>
> {
> typedef typename std::_Build_index_tuple<std::tuple_size<
> typename std::remove_reference<_Tp>::type>::value>::__type __type;
> };
>
>
>
>
> template<typename _Ret, typename _Indices, typename... _Tpls>
> struct __tuple_concater;
>
> template<typename _Ret, std::size_t... _Is, typename _Tp, typename... _Tpls>
> struct __tuple_concater<_Ret, std::_Index_tuple<_Is...>, _Tp, _Tpls...>
> {
> template<typename... _Us>
> static constexpr _Ret
> _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
> {
> typedef typename __make_1st_indices<_Tpls...>::__type __idx;
> typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
> return __next::_S_do(std::forward<_Tpls>(__tps)...,
> std::forward<_Us>(__us)...,
> std::get<_Is>(std::forward<_Tp>(__tp))...);
> }
> };
>
> template<typename _Ret>
> struct __tuple_concater<_Ret, std::_Index_tuple<>>
> {
> template<typename... _Us>
> static constexpr _Ret
> _S_do(_Us&&... __us)
> {
> return _Ret(std::forward<_Us>(__us)...);
> }
> };
>
> template<typename... _Tpls, typename = typename
> enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
> constexpr auto
> tuple_cat(_Tpls&&... __tpls)
> -> typename __tuple_cat_result<_Tpls...>::__type
> {
> typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
> typedef typename __make_1st_indices<_Tpls...>::__type __idx;
> typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
> return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
> }
>
> template<typename... _Elements>
> inline tuple<_Elements&...>
> tie(_Elements&... __args) noexcept
> { return tuple<_Elements&...>(__args...); }
>
> template<typename... _Elements>
> inline void
> swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
> noexcept(noexcept(__x.swap(__y)))
> { __x.swap(__y); }
>
>
>
> struct _Swallow_assign
> {
> template<class _Tp>
> const _Swallow_assign&
> operator=(const _Tp&) const
> { return *this; }
> };
>
> const _Swallow_assign ignore{};
>
>
> template<typename... _Types, typename _Alloc>
> struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
>
>
> template<class _T1, class _T2>
> template<typename... _Args1, typename... _Args2>
> inline
> pair<_T1, _T2>::
> pair(piecewise_construct_t,
> tuple<_Args1...> __first, tuple<_Args2...> __second)
> : pair(__first, __second,
> typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
> typename _Build_index_tuple<sizeof...(_Args2)>::__type())
> { }
>
> template<class _T1, class _T2>
> template<typename... _Args1, std::size_t... _Indexes1,
> typename... _Args2, std::size_t... _Indexes2>
> inline
> pair<_T1, _T2>::
> pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
> _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
> : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
> second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
> { }
>
>
>}
># 57 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _MemberPointer>
> class _Mem_fn;
> template<typename _Tp, typename _Class>
> _Mem_fn<_Tp _Class::*>
> mem_fn(_Tp _Class::*);
>
>template<typename _Tp> class __has_result_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::result_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_result_type : integral_constant<bool, __has_result_type_helper <typename remove_cv<_Tp>::type>::value> { };
>
>
> template<bool _Has_result_type, typename _Functor>
> struct _Maybe_get_result_type
> { };
>
> template<typename _Functor>
> struct _Maybe_get_result_type<true, _Functor>
> { typedef typename _Functor::result_type result_type; };
>
>
>
>
>
> template<typename _Functor>
> struct _Weak_result_type_impl
> : _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor>
> { };
>
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes...)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes......)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
> { typedef _Res result_type; };
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
> { typedef _Res result_type; };
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
> { typedef _Res result_type; };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
> const volatile>
> { typedef _Res result_type; };
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
> const volatile>
> { typedef _Res result_type; };
>
>
>
>
>
> template<typename _Functor>
> struct _Weak_result_type
> : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
> { };
>
>
> template<typename _Tp>
> struct _Derives_from_unary_function : __sfinae_types
> {
> private:
> template<typename _T1, typename _Res>
> static __one __test(const volatile unary_function<_T1, _Res>*);
>
>
>
> static __two __test(...);
>
> public:
> static const bool value = sizeof(__test((_Tp*)0)) == 1;
> };
>
>
> template<typename _Tp>
> struct _Derives_from_binary_function : __sfinae_types
> {
> private:
> template<typename _T1, typename _T2, typename _Res>
> static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
>
>
>
> static __two __test(...);
>
> public:
> static const bool value = sizeof(__test((_Tp*)0)) == 1;
> };
>
>
>
>
>
> template<typename _Functor, typename... _Args>
> inline
> typename enable_if<
> (!is_member_pointer<_Functor>::value
> && !is_function<_Functor>::value
> && !is_function<typename remove_pointer<_Functor>::type>::value),
> typename result_of<_Functor(_Args&&...)>::type
> >::type
> __invoke(_Functor& __f, _Args&&... __args)
> {
> return __f(std::forward<_Args>(__args)...);
> }
>
> template<typename _Functor, typename... _Args>
> inline
> typename enable_if<
> (is_member_pointer<_Functor>::value
> && !is_function<_Functor>::value
> && !is_function<typename remove_pointer<_Functor>::type>::value),
> typename result_of<_Functor(_Args&&...)>::type
> >::type
> __invoke(_Functor& __f, _Args&&... __args)
> {
> return mem_fn(__f)(std::forward<_Args>(__args)...);
> }
>
>
> template<typename _Functor, typename... _Args>
> inline
> typename enable_if<
> (is_pointer<_Functor>::value
> && is_function<typename remove_pointer<_Functor>::type>::value),
> typename result_of<_Functor(_Args&&...)>::type
> >::type
> __invoke(_Functor __f, _Args&&... __args)
> {
> return __f(std::forward<_Args>(__args)...);
> }
>
>
>
>
>
>
> template<bool _Unary, bool _Binary, typename _Tp>
> struct _Reference_wrapper_base_impl;
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base_impl<false, false, _Tp>
> : _Weak_result_type<_Tp>
> { };
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base_impl<true, false, _Tp>
> : _Weak_result_type<_Tp>
> {
> typedef typename _Tp::argument_type argument_type;
> };
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base_impl<false, true, _Tp>
> : _Weak_result_type<_Tp>
> {
> typedef typename _Tp::first_argument_type first_argument_type;
> typedef typename _Tp::second_argument_type second_argument_type;
> };
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base_impl<true, true, _Tp>
> : _Weak_result_type<_Tp>
> {
> typedef typename _Tp::argument_type argument_type;
> typedef typename _Tp::first_argument_type first_argument_type;
> typedef typename _Tp::second_argument_type second_argument_type;
> };
>
> template<typename _Tp> class __has_argument_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::argument_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_argument_type : integral_constant<bool, __has_argument_type_helper <typename remove_cv<_Tp>::type>::value> { };
> template<typename _Tp> class __has_first_argument_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::first_argument_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_first_argument_type : integral_constant<bool, __has_first_argument_type_helper <typename remove_cv<_Tp>::type>::value> { };
> template<typename _Tp> class __has_second_argument_type_helper : __sfinae_types { template<typename _Up> struct _Wrap_type { }; template<typename _Up> static __one __test(_Wrap_type<typename _Up::second_argument_type>*); template<typename _Up> static __two __test(...); public: static constexpr bool value = sizeof(__test<_Tp>(0)) == 1; }; template<typename _Tp> struct __has_second_argument_type : integral_constant<bool, __has_second_argument_type_helper <typename remove_cv<_Tp>::type>::value> { };
>
>
>
>
>
>
>
> template<typename _Tp>
> struct _Reference_wrapper_base
> : _Reference_wrapper_base_impl<
> __has_argument_type<_Tp>::value,
> __has_first_argument_type<_Tp>::value
> && __has_second_argument_type<_Tp>::value,
> _Tp>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1)>
> : unary_function<_T1, _Res>
> { };
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1) const>
> : unary_function<_T1, _Res>
> { };
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1) volatile>
> : unary_function<_T1, _Res>
> { };
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(_T1) const volatile>
> : unary_function<_T1, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2)>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2) const>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
> : binary_function<_T1, _T2, _Res>
> { };
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
> : binary_function<_T1, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res(*)(_T1)>
> : unary_function<_T1, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
> : binary_function<_T1, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res (_T1::*)()>
> : unary_function<_T1*, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
> : binary_function<_T1*, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res (_T1::*)() const>
> : unary_function<const _T1*, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
> : binary_function<const _T1*, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
> : unary_function<volatile _T1*, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
> : binary_function<volatile _T1*, _T2, _Res>
> { };
>
>
> template<typename _Res, typename _T1>
> struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
> : unary_function<const volatile _T1*, _Res>
> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
> : binary_function<const volatile _T1*, _T2, _Res>
> { };
>
>
>
>
>
>
> template<typename _Tp>
> class reference_wrapper
> : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
> {
> _Tp* _M_data;
>
> public:
> typedef _Tp type;
>
> reference_wrapper(_Tp& __indata) noexcept
> : _M_data(std::__addressof(__indata))
> { }
>
> reference_wrapper(_Tp&&) = delete;
>
> reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
> : _M_data(__inref._M_data)
> { }
>
> reference_wrapper&
> operator=(const reference_wrapper<_Tp>& __inref) noexcept
> {
> _M_data = __inref._M_data;
> return *this;
> }
>
> operator _Tp&() const noexcept
> { return this->get(); }
>
> _Tp&
> get() const noexcept
> { return *_M_data; }
>
> template<typename... _Args>
> typename result_of<_Tp&(_Args&&...)>::type
> operator()(_Args&&... __args) const
> {
> return __invoke(get(), std::forward<_Args>(__args)...);
> }
> };
>
>
>
> template<typename _Tp>
> inline reference_wrapper<_Tp>
> ref(_Tp& __t) noexcept
> { return reference_wrapper<_Tp>(__t); }
>
>
> template<typename _Tp>
> inline reference_wrapper<const _Tp>
> cref(const _Tp& __t) noexcept
> { return reference_wrapper<const _Tp>(__t); }
>
> template<typename _Tp>
> void ref(const _Tp&&) = delete;
>
> template<typename _Tp>
> void cref(const _Tp&&) = delete;
>
>
> template<typename _Tp>
> inline reference_wrapper<_Tp>
> ref(reference_wrapper<_Tp> __t) noexcept
> { return ref(__t.get()); }
>
>
> template<typename _Tp>
> inline reference_wrapper<const _Tp>
> cref(reference_wrapper<_Tp> __t) noexcept
> { return cref(__t.get()); }
># 510 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> template<typename _Res, typename... _ArgTypes>
> struct _Maybe_unary_or_binary_function { };
>
>
> template<typename _Res, typename _T1>
> struct _Maybe_unary_or_binary_function<_Res, _T1>
> : std::unary_function<_T1, _Res> { };
>
>
> template<typename _Res, typename _T1, typename _T2>
> struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
> : std::binary_function<_T1, _T2, _Res> { };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
> : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
> {
> typedef _Res (_Class::*_Functor)(_ArgTypes...);
>
> template<typename _Tp>
> _Res
> _M_call(_Tp& __object, const volatile _Class *,
> _ArgTypes... __args) const
> { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
> template<typename _Tp>
> _Res
> _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
> { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
> public:
> typedef _Res result_type;
>
> explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
>
>
> _Res
> operator()(_Class& __object, _ArgTypes... __args) const
> { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
>
> _Res
> operator()(_Class* __object, _ArgTypes... __args) const
> { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
>
> template<typename _Tp>
> _Res
> operator()(_Tp& __object, _ArgTypes... __args) const
> {
> return _M_call(__object, &__object,
> std::forward<_ArgTypes>(__args)...);
> }
>
> private:
> _Functor __pmf;
> };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
> : public _Maybe_unary_or_binary_function<_Res, const _Class*,
> _ArgTypes...>
> {
> typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
>
> template<typename _Tp>
> _Res
> _M_call(_Tp& __object, const volatile _Class *,
> _ArgTypes... __args) const
> { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
> template<typename _Tp>
> _Res
> _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
> { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
> public:
> typedef _Res result_type;
>
> explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
>
>
> _Res
> operator()(const _Class& __object, _ArgTypes... __args) const
> { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
>
> _Res
> operator()(const _Class* __object, _ArgTypes... __args) const
> { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
>
> template<typename _Tp>
> _Res operator()(_Tp& __object, _ArgTypes... __args) const
> {
> return _M_call(__object, &__object,
> std::forward<_ArgTypes>(__args)...);
> }
>
> private:
> _Functor __pmf;
> };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
> : public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
> _ArgTypes...>
> {
> typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
>
> template<typename _Tp>
> _Res
> _M_call(_Tp& __object, const volatile _Class *,
> _ArgTypes... __args) const
> { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
> template<typename _Tp>
> _Res
> _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
> { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
> public:
> typedef _Res result_type;
>
> explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
>
>
> _Res
> operator()(volatile _Class& __object, _ArgTypes... __args) const
> { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
>
> _Res
> operator()(volatile _Class* __object, _ArgTypes... __args) const
> { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
>
> template<typename _Tp>
> _Res
> operator()(_Tp& __object, _ArgTypes... __args) const
> {
> return _M_call(__object, &__object,
> std::forward<_ArgTypes>(__args)...);
> }
>
> private:
> _Functor __pmf;
> };
>
>
> template<typename _Res, typename _Class, typename... _ArgTypes>
> class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
> : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
> _ArgTypes...>
> {
> typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
>
> template<typename _Tp>
> _Res
> _M_call(_Tp& __object, const volatile _Class *,
> _ArgTypes... __args) const
> { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
> template<typename _Tp>
> _Res
> _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
> { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
> public:
> typedef _Res result_type;
>
> explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
>
>
> _Res
> operator()(const volatile _Class& __object, _ArgTypes... __args) const
> { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
>
> _Res
> operator()(const volatile _Class* __object, _ArgTypes... __args) const
> { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); }
>
>
> template<typename _Tp>
> _Res operator()(_Tp& __object, _ArgTypes... __args) const
> {
> return _M_call(__object, &__object,
> std::forward<_ArgTypes>(__args)...);
> }
>
> private:
> _Functor __pmf;
> };
>
>
> template<typename _Tp, bool>
> struct _Mem_fn_const_or_non
> {
> typedef const _Tp& type;
> };
>
> template<typename _Tp>
> struct _Mem_fn_const_or_non<_Tp, false>
> {
> typedef _Tp& type;
> };
>
> template<typename _Res, typename _Class>
> class _Mem_fn<_Res _Class::*>
> {
>
>
> template<typename _Tp>
> _Res&
> _M_call(_Tp& __object, _Class *) const
> { return __object.*__pm; }
>
> template<typename _Tp, typename _Up>
> _Res&
> _M_call(_Tp& __object, _Up * const *) const
> { return (*__object).*__pm; }
>
> template<typename _Tp, typename _Up>
> const _Res&
> _M_call(_Tp& __object, const _Up * const *) const
> { return (*__object).*__pm; }
>
> template<typename _Tp>
> const _Res&
> _M_call(_Tp& __object, const _Class *) const
> { return __object.*__pm; }
>
> template<typename _Tp>
> const _Res&
> _M_call(_Tp& __ptr, const volatile void*) const
> { return (*__ptr).*__pm; }
>
> template<typename _Tp> static _Tp& __get_ref();
>
> template<typename _Tp>
> static __sfinae_types::__one __check_const(_Tp&, _Class*);
> template<typename _Tp, typename _Up>
> static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
> template<typename _Tp, typename _Up>
> static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
> template<typename _Tp>
> static __sfinae_types::__two __check_const(_Tp&, const _Class*);
> template<typename _Tp>
> static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
>
> public:
> template<typename _Tp>
> struct _Result_type
> : _Mem_fn_const_or_non<_Res,
> (sizeof(__sfinae_types::__two)
> == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
> { };
>
> template<typename _Signature>
> struct result;
>
> template<typename _CVMem, typename _Tp>
> struct result<_CVMem(_Tp)>
> : public _Result_type<_Tp> { };
>
> template<typename _CVMem, typename _Tp>
> struct result<_CVMem(_Tp&)>
> : public _Result_type<_Tp> { };
>
> explicit
> _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
>
>
> _Res&
> operator()(_Class& __object) const
> { return __object.*__pm; }
>
> const _Res&
> operator()(const _Class& __object) const
> { return __object.*__pm; }
>
>
> _Res&
> operator()(_Class* __object) const
> { return __object->*__pm; }
>
> const _Res&
> operator()(const _Class* __object) const
> { return __object->*__pm; }
>
>
> template<typename _Tp>
> typename _Result_type<_Tp>::type
> operator()(_Tp& __unknown) const
> { return _M_call(__unknown, &__unknown); }
>
> private:
> _Res _Class::*__pm;
> };
>
>
>
>
>
>
> template<typename _Tp, typename _Class>
> inline _Mem_fn<_Tp _Class::*>
> mem_fn(_Tp _Class::* __pm)
> {
> return _Mem_fn<_Tp _Class::*>(__pm);
> }
>
>
>
>
>
>
>
> template<typename _Tp>
> struct is_bind_expression
> : public false_type { };
>
>
>
>
>
>
> template<typename _Tp>
> struct is_placeholder
> : public integral_constant<int, 0>
> { };
>
>
>
>
> template<int _Num> struct _Placeholder { };
>
> 
>
>
>
>
>
> namespace placeholders
> {
> 
>
>
>
>
> extern const _Placeholder<1> _1;
> extern const _Placeholder<2> _2;
> extern const _Placeholder<3> _3;
> extern const _Placeholder<4> _4;
> extern const _Placeholder<5> _5;
> extern const _Placeholder<6> _6;
> extern const _Placeholder<7> _7;
> extern const _Placeholder<8> _8;
> extern const _Placeholder<9> _9;
> extern const _Placeholder<10> _10;
> extern const _Placeholder<11> _11;
> extern const _Placeholder<12> _12;
> extern const _Placeholder<13> _13;
> extern const _Placeholder<14> _14;
> extern const _Placeholder<15> _15;
> extern const _Placeholder<16> _16;
> extern const _Placeholder<17> _17;
> extern const _Placeholder<18> _18;
> extern const _Placeholder<19> _19;
> extern const _Placeholder<20> _20;
> extern const _Placeholder<21> _21;
> extern const _Placeholder<22> _22;
> extern const _Placeholder<23> _23;
> extern const _Placeholder<24> _24;
> extern const _Placeholder<25> _25;
> extern const _Placeholder<26> _26;
> extern const _Placeholder<27> _27;
> extern const _Placeholder<28> _28;
> extern const _Placeholder<29> _29;
> 
> }
>
> 
>
>
>
>
>
>
> template<int _Num>
> struct is_placeholder<_Placeholder<_Num> >
> : public integral_constant<int, _Num>
> { };
>
> template<int _Num>
> struct is_placeholder<const _Placeholder<_Num> >
> : public integral_constant<int, _Num>
> { };
>
>
>
>
>
> struct _No_tuple_element;
>
>
>
>
>
>
> template<std::size_t __i, typename _Tuple, bool _IsSafe>
> struct _Safe_tuple_element_impl
> : tuple_element<__i, _Tuple> { };
>
>
>
>
>
>
> template<std::size_t __i, typename _Tuple>
> struct _Safe_tuple_element_impl<__i, _Tuple, false>
> {
> typedef _No_tuple_element type;
> };
>
>
>
>
>
> template<std::size_t __i, typename _Tuple>
> struct _Safe_tuple_element
> : _Safe_tuple_element_impl<__i, _Tuple,
> (__i < tuple_size<_Tuple>::value)>
> { };
># 960 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> template<typename _Arg,
> bool _IsBindExp = is_bind_expression<_Arg>::value,
> bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
> class _Mu;
>
>
>
>
>
> template<typename _Tp>
> class _Mu<reference_wrapper<_Tp>, false, false>
> {
> public:
> typedef _Tp& result_type;
>
>
>
>
>
> template<typename _CVRef, typename _Tuple>
> result_type
> operator()(_CVRef& __arg, _Tuple&) const volatile
> { return __arg.get(); }
> };
>
>
>
>
>
>
> template<typename _Arg>
> class _Mu<_Arg, true, false>
> {
> public:
> template<typename _CVArg, typename... _Args>
> auto
> operator()(_CVArg& __arg,
> tuple<_Args...>& __tuple) const volatile
> -> decltype(__arg(declval<_Args>()...))
> {
>
> typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
> _Indexes;
> return this->__call(__arg, __tuple, _Indexes());
> }
>
> private:
>
>
> template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
> auto
> __call(_CVArg& __arg, tuple<_Args...>& __tuple,
> const _Index_tuple<_Indexes...>&) const volatile
> -> decltype(__arg(declval<_Args>()...))
> {
> return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...);
> }
> };
>
>
>
>
>
>
> template<typename _Arg>
> class _Mu<_Arg, false, true>
> {
> public:
> template<typename _Signature> class result;
>
> template<typename _CVMu, typename _CVArg, typename _Tuple>
> class result<_CVMu(_CVArg, _Tuple)>
> {
>
>
>
> typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
> - 1), _Tuple>::type
> __base_type;
>
> public:
> typedef typename add_rvalue_reference<__base_type>::type type;
> };
>
> template<typename _Tuple>
> typename result<_Mu(_Arg, _Tuple)>::type
> operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
> {
> return std::forward<typename result<_Mu(_Arg, _Tuple)>::type>(
> ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
> }
> };
>
>
>
>
>
>
> template<typename _Arg>
> class _Mu<_Arg, false, false>
> {
> public:
> template<typename _Signature> struct result;
>
> template<typename _CVMu, typename _CVArg, typename _Tuple>
> struct result<_CVMu(_CVArg, _Tuple)>
> {
> typedef typename add_lvalue_reference<_CVArg>::type type;
> };
>
>
> template<typename _CVArg, typename _Tuple>
> _CVArg&&
> operator()(_CVArg&& __arg, _Tuple&) const volatile
> { return std::forward<_CVArg>(__arg); }
> };
>
>
>
>
>
>
> template<typename _Tp>
> struct _Maybe_wrap_member_pointer
> {
> typedef _Tp type;
>
> static const _Tp&
> __do_wrap(const _Tp& __x)
> { return __x; }
>
> static _Tp&&
> __do_wrap(_Tp&& __x)
> { return static_cast<_Tp&&>(__x); }
> };
>
>
>
>
>
>
> template<typename _Tp, typename _Class>
> struct _Maybe_wrap_member_pointer<_Tp _Class::*>
> {
> typedef _Mem_fn<_Tp _Class::*> type;
>
> static type
> __do_wrap(_Tp _Class::* __pm)
> { return type(__pm); }
> };
>
>
>
>
>
> template<>
> struct _Maybe_wrap_member_pointer<void>
> {
> typedef void type;
> };
>
>
> template<std::size_t _Ind, typename... _Tp>
> inline auto
> __volget(volatile tuple<_Tp...>& __tuple)
> -> typename tuple_element<_Ind, tuple<_Tp...>>::type volatile&
> { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
>
>
> template<std::size_t _Ind, typename... _Tp>
> inline auto
> __volget(const volatile tuple<_Tp...>& __tuple)
> -> typename tuple_element<_Ind, tuple<_Tp...>>::type const volatile&
> { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
>
>
> template<typename _Signature>
> struct _Bind;
>
> template<typename _Functor, typename... _Bound_args>
> class _Bind<_Functor(_Bound_args...)>
> : public _Weak_result_type<_Functor>
> {
> typedef _Bind __self_type;
> typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
> _Bound_indexes;
>
> _Functor _M_f;
> tuple<_Bound_args...> _M_bound_args;
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
> {
> return _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
> {
> return _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call_v(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>) volatile
> {
> return _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Result, typename... _Args, std::size_t... _Indexes>
> _Result
> __call_c_v(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>) const volatile
> {
> return _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
> public:
> template<typename... _Args>
> explicit _Bind(const _Functor& __f, _Args&&... __args)
> : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> template<typename... _Args>
> explicit _Bind(_Functor&& __f, _Args&&... __args)
> : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> _Bind(const _Bind&) = default;
>
> _Bind(_Bind&& __b)
> : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
> { }
>
>
> template<typename... _Args, typename _Result
> = decltype( std::declval<_Functor>()(
> _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
> std::declval<tuple<_Args...>&>() )... ) )>
> _Result
> operator()(_Args&&... __args)
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args, typename _Result
> = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
> typename add_const<_Functor>::type>::type>()(
> _Mu<_Bound_args>()( std::declval<const _Bound_args&>(),
> std::declval<tuple<_Args...>&>() )... ) )>
> _Result
> operator()(_Args&&... __args) const
> {
> return this->__call_c<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args, typename _Result
> = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
> typename add_volatile<_Functor>::type>::type>()(
> _Mu<_Bound_args>()( std::declval<volatile _Bound_args&>(),
> std::declval<tuple<_Args...>&>() )... ) )>
> _Result
> operator()(_Args&&... __args) volatile
> {
> return this->__call_v<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args, typename _Result
> = decltype( std::declval<typename enable_if<(sizeof...(_Args) >= 0),
> typename add_cv<_Functor>::type>::type>()(
> _Mu<_Bound_args>()( std::declval<const volatile _Bound_args&>(),
> std::declval<tuple<_Args...>&>() )... ) )>
> _Result
> operator()(_Args&&... __args) const volatile
> {
> return this->__call_c_v<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
> };
>
>
> template<typename _Result, typename _Signature>
> struct _Bind_result;
>
> template<typename _Result, typename _Functor, typename... _Bound_args>
> class _Bind_result<_Result, _Functor(_Bound_args...)>
> {
> typedef _Bind_result __self_type;
> typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
> _Bound_indexes;
>
> _Functor _M_f;
> tuple<_Bound_args...> _M_bound_args;
>
>
> template<typename _Res>
> struct __enable_if_void : enable_if<is_void<_Res>::value, int> { };
> template<typename _Res>
> struct __disable_if_void : enable_if<!is_void<_Res>::value, int> { };
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __disable_if_void<_Res>::type = 0)
> {
> return _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> void
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __enable_if_void<_Res>::type = 0)
> {
> _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __disable_if_void<_Res>::type = 0) const
> {
> return _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> void
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __enable_if_void<_Res>::type = 0) const
> {
> _M_f(_Mu<_Bound_args>()
> (get<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __disable_if_void<_Res>::type = 0) volatile
> {
> return _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> void
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __enable_if_void<_Res>::type = 0) volatile
> {
> _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> _Result
> __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
> typename __disable_if_void<_Res>::type = 0) const volatile
> {
> return _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
>
> template<typename _Res, typename... _Args, std::size_t... _Indexes>
> void
> __call(tuple<_Args...>&& __args,
> _Index_tuple<_Indexes...>,
> typename __enable_if_void<_Res>::type = 0) const volatile
> {
> _M_f(_Mu<_Bound_args>()
> (__volget<_Indexes>(_M_bound_args), __args)...);
> }
>
> public:
> typedef _Result result_type;
>
> template<typename... _Args>
> explicit _Bind_result(const _Functor& __f, _Args&&... __args)
> : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> template<typename... _Args>
> explicit _Bind_result(_Functor&& __f, _Args&&... __args)
> : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
> { }
>
> _Bind_result(const _Bind_result&) = default;
>
> _Bind_result(_Bind_result&& __b)
> : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
> { }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args)
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args) const
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args) volatile
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
>
>
> template<typename... _Args>
> result_type
> operator()(_Args&&... __args) const volatile
> {
> return this->__call<_Result>(
> std::forward_as_tuple(std::forward<_Args>(__args)...),
> _Bound_indexes());
> }
> };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<_Bind<_Signature> >
> : public true_type { };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<const _Bind<_Signature> >
> : public true_type { };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<volatile _Bind<_Signature> >
> : public true_type { };
>
>
>
>
>
> template<typename _Signature>
> struct is_bind_expression<const volatile _Bind<_Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<_Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<const _Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
>
> template<typename _Result, typename _Signature>
> struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
> : public true_type { };
>
>
>
>
> template<typename _Tp>
> class __is_socketlike
> {
> typedef typename decay<_Tp>::type _Tp2;
> public:
> static const bool value =
> is_integral<_Tp2>::value || is_enum<_Tp2>::value;
> };
>
> template<bool _SocketLike, typename _Func, typename... _BoundArgs>
> struct _Bind_helper
> {
> typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
> __maybe_type;
> typedef typename __maybe_type::type __func_type;
> typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
> };
>
>
>
>
> template<typename _Func, typename... _BoundArgs>
> struct _Bind_helper<true, _Func, _BoundArgs...>
> { };
>
>
>
>
>
> template<typename _Func, typename... _BoundArgs>
> inline typename
> _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
> bind(_Func&& __f, _BoundArgs&&... __args)
> {
> typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
> typedef typename __helper_type::__maybe_type __maybe_type;
> typedef typename __helper_type::type __result_type;
> return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
> std::forward<_BoundArgs>(__args)...);
> }
>
> template<typename _Result, typename _Func, typename... _BoundArgs>
> struct _Bindres_helper
> {
> typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
> __maybe_type;
> typedef typename __maybe_type::type __functor_type;
> typedef _Bind_result<_Result,
> __functor_type(typename decay<_BoundArgs>::type...)>
> type;
> };
>
>
>
>
>
> template<typename _Result, typename _Func, typename... _BoundArgs>
> inline
> typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
> bind(_Func&& __f, _BoundArgs&&... __args)
> {
> typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
> typedef typename __helper_type::__maybe_type __maybe_type;
> typedef typename __helper_type::type __result_type;
> return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
> std::forward<_BoundArgs>(__args)...);
> }
>
> template<typename _Signature>
> struct _Bind_simple;
>
> template<typename _Callable, typename... _Args>
> struct _Bind_simple<_Callable(_Args...)>
> {
> typedef typename result_of<_Callable(_Args...)>::type result_type;
>
> template<typename... _Args2, typename = typename
> enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
> explicit
> _Bind_simple(const _Callable& __callable, _Args2&&... __args)
> : _M_bound(__callable, std::forward<_Args2>(__args)...)
> { }
>
> template<typename... _Args2, typename = typename
> enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
> explicit
> _Bind_simple(_Callable&& __callable, _Args2&&... __args)
> : _M_bound(std::move(__callable), std::forward<_Args2>(__args)...)
> { }
>
> _Bind_simple(const _Bind_simple&) = default;
> _Bind_simple(_Bind_simple&&) = default;
>
> result_type
> operator()()
> {
> typedef typename _Build_index_tuple<sizeof...(_Args)>::__type _Indices;
> return _M_invoke(_Indices());
> }
>
> private:
>
> template<std::size_t... _Indices>
> typename result_of<_Callable(_Args...)>::type
> _M_invoke(_Index_tuple<_Indices...>)
> {
>
>
> return std::forward<_Callable>(std::get<0>(_M_bound))(
> std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
> }
>
> std::tuple<_Callable, _Args...> _M_bound;
> };
>
> template<typename _Func, typename... _BoundArgs>
> struct _Bind_simple_helper
> {
> typedef _Maybe_wrap_member_pointer<typename decay<_Func>::type>
> __maybe_type;
> typedef typename __maybe_type::type __func_type;
> typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
> __type;
> };
>
>
>
> template<typename _Callable, typename... _Args>
> typename _Bind_simple_helper<_Callable, _Args...>::__type
> __bind_simple(_Callable&& __callable, _Args&&... __args)
> {
> typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
> typedef typename __helper_type::__maybe_type __maybe_type;
> typedef typename __helper_type::__type __result_type;
> return __result_type(
> __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
> std::forward<_Args>(__args)...);
> }
>
>
>
>
>
>
> class bad_function_call : public std::exception
> {
> public:
> virtual ~bad_function_call() noexcept;
> };
>
>
>
>
>
>
> template<typename _Tp>
> struct __is_location_invariant
> : integral_constant<bool, (is_pointer<_Tp>::value
> || is_member_pointer<_Tp>::value)>
> { };
>
> class _Undefined_class;
>
> union _Nocopy_types
> {
> void* _M_object;
> const void* _M_const_object;
> void (*_M_function_pointer)();
> void (_Undefined_class::*_M_member_pointer)();
> };
>
> union _Any_data
> {
> void* _M_access() { return &_M_pod_data[0]; }
> const void* _M_access() const { return &_M_pod_data[0]; }
>
> template<typename _Tp>
> _Tp&
> _M_access()
> { return *static_cast<_Tp*>(_M_access()); }
>
> template<typename _Tp>
> const _Tp&
> _M_access() const
> { return *static_cast<const _Tp*>(_M_access()); }
>
> _Nocopy_types _M_unused;
> char _M_pod_data[sizeof(_Nocopy_types)];
> };
>
> enum _Manager_operation
> {
> __get_type_info,
> __get_functor_ptr,
> __clone_functor,
> __destroy_functor
> };
>
>
>
> template<typename _Tp>
> struct _Simple_type_wrapper
> {
> _Simple_type_wrapper(_Tp __value) : __value(__value) { }
>
> _Tp __value;
> };
>
> template<typename _Tp>
> struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
> : __is_location_invariant<_Tp>
> { };
>
>
>
> template<typename _Functor>
> inline _Functor&
> __callable_functor(_Functor& __f)
> { return __f; }
>
> template<typename _Member, typename _Class>
> inline _Mem_fn<_Member _Class::*>
> __callable_functor(_Member _Class::* &__p)
> { return mem_fn(__p); }
>
> template<typename _Member, typename _Class>
> inline _Mem_fn<_Member _Class::*>
> __callable_functor(_Member _Class::* const &__p)
> { return mem_fn(__p); }
>
> template<typename _Signature>
> class function;
>
>
> class _Function_base
> {
> public:
> static const std::size_t _M_max_size = sizeof(_Nocopy_types);
> static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
>
> template<typename _Functor>
> class _Base_manager
> {
> protected:
> static const bool __stored_locally =
> (__is_location_invariant<_Functor>::value
> && sizeof(_Functor) <= _M_max_size
> && __alignof__(_Functor) <= _M_max_align
> && (_M_max_align % __alignof__(_Functor) == 0));
>
> typedef integral_constant<bool, __stored_locally> _Local_storage;
>
>
> static _Functor*
> _M_get_pointer(const _Any_data& __source)
> {
> const _Functor* __ptr =
> __stored_locally? std::__addressof(__source._M_access<_Functor>())
> : __source._M_access<_Functor*>();
> return const_cast<_Functor*>(__ptr);
> }
>
>
>
> static void
> _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
> {
> new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
> }
>
>
>
> static void
> _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
> {
> __dest._M_access<_Functor*>() =
> new _Functor(*__source._M_access<_Functor*>());
> }
>
>
>
> static void
> _M_destroy(_Any_data& __victim, true_type)
> {
> __victim._M_access<_Functor>().~_Functor();
> }
>
>
> static void
> _M_destroy(_Any_data& __victim, false_type)
> {
> delete __victim._M_access<_Functor*>();
> }
>
> public:
> static bool
> _M_manager(_Any_data& __dest, const _Any_data& __source,
> _Manager_operation __op)
> {
> switch (__op)
> {
>
> case __get_type_info:
> __dest._M_access<const type_info*>() = &typeid(_Functor);
> break;
>
> case __get_functor_ptr:
> __dest._M_access<_Functor*>() = _M_get_pointer(__source);
> break;
>
> case __clone_functor:
> _M_clone(__dest, __source, _Local_storage());
> break;
>
> case __destroy_functor:
> _M_destroy(__dest, _Local_storage());
> break;
> }
> return false;
> }
>
> static void
> _M_init_functor(_Any_data& __functor, _Functor&& __f)
> { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
>
> template<typename _Signature>
> static bool
> _M_not_empty_function(const function<_Signature>& __f)
> { return static_cast<bool>(__f); }
>
> template<typename _Tp>
> static bool
> _M_not_empty_function(const _Tp*& __fp)
> { return __fp; }
>
> template<typename _Class, typename _Tp>
> static bool
> _M_not_empty_function(_Tp _Class::* const& __mp)
> { return __mp; }
>
> template<typename _Tp>
> static bool
> _M_not_empty_function(const _Tp&)
> { return true; }
>
> private:
> static void
> _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
> { new (__functor._M_access()) _Functor(std::move(__f)); }
>
> static void
> _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
> { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
> };
>
> template<typename _Functor>
> class _Ref_manager : public _Base_manager<_Functor*>
> {
> typedef _Function_base::_Base_manager<_Functor*> _Base;
>
> public:
> static bool
> _M_manager(_Any_data& __dest, const _Any_data& __source,
> _Manager_operation __op)
> {
> switch (__op)
> {
>
> case __get_type_info:
> __dest._M_access<const type_info*>() = &typeid(_Functor);
> break;
>
> case __get_functor_ptr:
> __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
> return is_const<_Functor>::value;
> break;
>
> default:
> _Base::_M_manager(__dest, __source, __op);
> }
> return false;
> }
>
> static void
> _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
> {
>
> _Base::_M_init_functor(__functor, &__f.get());
> }
> };
>
> _Function_base() : _M_manager(0) { }
>
> ~_Function_base()
> {
> if (_M_manager)
> _M_manager(_M_functor, _M_functor, __destroy_functor);
> }
>
>
> bool _M_empty() const { return !_M_manager; }
>
> typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
> _Manager_operation);
>
> _Any_data _M_functor;
> _Manager_type _M_manager;
> };
>
> template<typename _Signature, typename _Functor>
> class _Function_handler;
>
> template<typename _Res, typename _Functor, typename... _ArgTypes>
> class _Function_handler<_Res(_ArgTypes...), _Functor>
> : public _Function_base::_Base_manager<_Functor>
> {
> typedef _Function_base::_Base_manager<_Functor> _Base;
>
> public:
> static _Res
> _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
> {
> return (*_Base::_M_get_pointer(__functor))(
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _Functor, typename... _ArgTypes>
> class _Function_handler<void(_ArgTypes...), _Functor>
> : public _Function_base::_Base_manager<_Functor>
> {
> typedef _Function_base::_Base_manager<_Functor> _Base;
>
> public:
> static void
> _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
> {
> (*_Base::_M_get_pointer(__functor))(
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _Res, typename _Functor, typename... _ArgTypes>
> class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
> : public _Function_base::_Ref_manager<_Functor>
> {
> typedef _Function_base::_Ref_manager<_Functor> _Base;
>
> public:
> static _Res
> _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
> {
> return __callable_functor(**_Base::_M_get_pointer(__functor))(
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _Functor, typename... _ArgTypes>
> class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
> : public _Function_base::_Ref_manager<_Functor>
> {
> typedef _Function_base::_Ref_manager<_Functor> _Base;
>
> public:
> static void
> _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
> {
> __callable_functor(**_Base::_M_get_pointer(__functor))(
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _Class, typename _Member, typename _Res,
> typename... _ArgTypes>
> class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
> : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
> {
> typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
> _Base;
>
> public:
> static _Res
> _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
> {
> return mem_fn(_Base::_M_get_pointer(__functor)->__value)(
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
> template<typename _Class, typename _Member, typename... _ArgTypes>
> class _Function_handler<void(_ArgTypes...), _Member _Class::*>
> : public _Function_base::_Base_manager<
> _Simple_type_wrapper< _Member _Class::* > >
> {
> typedef _Member _Class::* _Functor;
> typedef _Simple_type_wrapper<_Functor> _Wrapper;
> typedef _Function_base::_Base_manager<_Wrapper> _Base;
>
> public:
> static bool
> _M_manager(_Any_data& __dest, const _Any_data& __source,
> _Manager_operation __op)
> {
> switch (__op)
> {
>
> case __get_type_info:
> __dest._M_access<const type_info*>() = &typeid(_Functor);
> break;
>
> case __get_functor_ptr:
> __dest._M_access<_Functor*>() =
> &_Base::_M_get_pointer(__source)->__value;
> break;
>
> default:
> _Base::_M_manager(__dest, __source, __op);
> }
> return false;
> }
>
> static void
> _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
> {
> mem_fn(_Base::_M_get_pointer(__functor)->__value)(
> std::forward<_ArgTypes>(__args)...);
> }
> };
>
>
>
>
>
>
>
> template<typename _Res, typename... _ArgTypes>
> class function<_Res(_ArgTypes...)>
> : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
> private _Function_base
> {
> typedef _Res _Signature_type(_ArgTypes...);
>
> struct _Useless { };
>
> public:
> typedef _Res result_type;
>
>
>
>
>
>
>
> function() noexcept
> : _Function_base() { }
>
>
>
>
>
> function(nullptr_t) noexcept
> : _Function_base() { }
># 2060 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> function(const function& __x);
># 2069 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> function(function&& __x) : _Function_base()
> {
> __x.swap(*this);
> }
># 2092 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> template<typename _Functor>
> function(_Functor __f,
> typename enable_if<
> !is_integral<_Functor>::value, _Useless>::type
> = _Useless());
># 2110 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> function&
> operator=(const function& __x)
> {
> function(__x).swap(*this);
> return *this;
> }
># 2128 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> function&
> operator=(function&& __x)
> {
> function(std::move(__x)).swap(*this);
> return *this;
> }
># 2142 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> function&
> operator=(nullptr_t)
> {
> if (_M_manager)
> {
> _M_manager(_M_functor, _M_functor, __destroy_functor);
> _M_manager = 0;
> _M_invoker = 0;
> }
> return *this;
> }
># 2170 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> template<typename _Functor>
> typename enable_if<!is_integral<_Functor>::value, function&>::type
> operator=(_Functor&& __f)
> {
> function(std::forward<_Functor>(__f)).swap(*this);
> return *this;
> }
>
>
> template<typename _Functor>
> typename enable_if<!is_integral<_Functor>::value, function&>::type
> operator=(reference_wrapper<_Functor> __f) noexcept
> {
> function(__f).swap(*this);
> return *this;
> }
># 2196 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> void swap(function& __x)
> {
> std::swap(_M_functor, __x._M_functor);
> std::swap(_M_manager, __x._M_manager);
> std::swap(_M_invoker, __x._M_invoker);
> }
># 2224 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> explicit operator bool() const noexcept
> { return !_M_empty(); }
># 2237 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> _Res operator()(_ArgTypes... __args) const;
># 2250 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> const type_info& target_type() const noexcept;
># 2261 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> template<typename _Functor> _Functor* target() noexcept;
>
>
> template<typename _Functor> const _Functor* target() const noexcept;
>
>
> private:
> typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
> _Invoker_type _M_invoker;
> };
>
>
> template<typename _Res, typename... _ArgTypes>
> function<_Res(_ArgTypes...)>::
> function(const function& __x)
> : _Function_base()
> {
> if (static_cast<bool>(__x))
> {
> _M_invoker = __x._M_invoker;
> _M_manager = __x._M_manager;
> __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
> }
> }
>
> template<typename _Res, typename... _ArgTypes>
> template<typename _Functor>
> function<_Res(_ArgTypes...)>::
> function(_Functor __f,
> typename enable_if<
> !is_integral<_Functor>::value, _Useless>::type)
> : _Function_base()
> {
> typedef _Function_handler<_Signature_type, _Functor> _My_handler;
>
> if (_My_handler::_M_not_empty_function(__f))
> {
> _M_invoker = &_My_handler::_M_invoke;
> _M_manager = &_My_handler::_M_manager;
> _My_handler::_M_init_functor(_M_functor, std::move(__f));
> }
> }
>
> template<typename _Res, typename... _ArgTypes>
> _Res
> function<_Res(_ArgTypes...)>::
> operator()(_ArgTypes... __args) const
> {
> if (_M_empty())
> __throw_bad_function_call();
> return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
> }
>
>
> template<typename _Res, typename... _ArgTypes>
> const type_info&
> function<_Res(_ArgTypes...)>::
> target_type() const noexcept
> {
> if (_M_manager)
> {
> _Any_data __typeinfo_result;
> _M_manager(__typeinfo_result, _M_functor, __get_type_info);
> return *__typeinfo_result._M_access<const type_info*>();
> }
> else
> return typeid(void);
> }
>
> template<typename _Res, typename... _ArgTypes>
> template<typename _Functor>
> _Functor*
> function<_Res(_ArgTypes...)>::
> target() noexcept
> {
> if (typeid(_Functor) == target_type() && _M_manager)
> {
> _Any_data __ptr;
> if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
> && !is_const<_Functor>::value)
> return 0;
> else
> return __ptr._M_access<_Functor*>();
> }
> else
> return 0;
> }
>
> template<typename _Res, typename... _ArgTypes>
> template<typename _Functor>
> const _Functor*
> function<_Res(_ArgTypes...)>::
> target() const noexcept
> {
> if (typeid(_Functor) == target_type() && _M_manager)
> {
> _Any_data __ptr;
> _M_manager(__ptr, _M_functor, __get_functor_ptr);
> return __ptr._M_access<const _Functor*>();
> }
> else
> return 0;
> }
># 2375 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> template<typename _Res, typename... _Args>
> inline bool
> operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
> { return !static_cast<bool>(__f); }
>
>
> template<typename _Res, typename... _Args>
> inline bool
> operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
> { return !static_cast<bool>(__f); }
># 2393 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> template<typename _Res, typename... _Args>
> inline bool
> operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
> { return static_cast<bool>(__f); }
>
>
> template<typename _Res, typename... _Args>
> inline bool
> operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
> { return static_cast<bool>(__f); }
># 2411 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/functional" 3
> template<typename _Res, typename... _Args>
> inline void
> swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
> { __x.swap(__y); }
>
>
>}
># 69 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 2 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
> template<typename _Iterator>
> void
> __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c)
> {
>
> 
>
>
> if (*__a < *__b)
> {
> if (*__b < *__c)
> std::iter_swap(__a, __b);
> else if (*__a < *__c)
> std::iter_swap(__a, __c);
> }
> else if (*__a < *__c)
> return;
> else if (*__b < *__c)
> std::iter_swap(__a, __c);
> else
> std::iter_swap(__a, __b);
> }
>
>
> template<typename _Iterator, typename _Compare>
> void
> __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c,
> _Compare __comp)
> {
>
> 
>
>
>
> if (__comp(*__a, *__b))
> {
> if (__comp(*__b, *__c))
> std::iter_swap(__a, __b);
> else if (__comp(*__a, *__c))
> std::iter_swap(__a, __c);
> }
> else if (__comp(*__a, *__c))
> return;
> else if (__comp(*__b, *__c))
> std::iter_swap(__a, __c);
> else
> std::iter_swap(__a, __b);
> }
>
>
>
>
> template<typename _InputIterator, typename _Tp>
> inline _InputIterator
> __find(_InputIterator __first, _InputIterator __last,
> const _Tp& __val, input_iterator_tag)
> {
> while (__first != __last && !(*__first == __val))
> ++__first;
> return __first;
> }
>
>
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> __find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred, input_iterator_tag)
> {
> while (__first != __last && !bool(__pred(*__first)))
> ++__first;
> return __first;
> }
>
>
> template<typename _RandomAccessIterator, typename _Tp>
> _RandomAccessIterator
> __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
> const _Tp& __val, random_access_iterator_tag)
> {
> typename iterator_traits<_RandomAccessIterator>::difference_type
> __trip_count = (__last - __first) >> 2;
>
> for (; __trip_count > 0; --__trip_count)
> {
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
>
> if (*__first == __val)
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (*__first == __val)
> return __first;
> ++__first;
> case 2:
> if (*__first == __val)
> return __first;
> ++__first;
> case 1:
> if (*__first == __val)
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Predicate>
> _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<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> __find_if_not(_InputIterator __first, _InputIterator __last,
> _Predicate __pred, input_iterator_tag)
> {
> while (__first != __last && bool(__pred(*__first)))
> ++__first;
> return __first;
> }
>
>
> template<typename _RandomAccessIterator, typename _Predicate>
> _RandomAccessIterator
> __find_if_not(_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 (!bool(__pred(*__first)))
> return __first;
> ++__first;
>
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
>
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
>
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
> }
>
> switch (__last - __first)
> {
> case 3:
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
> case 2:
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
> case 1:
> if (!bool(__pred(*__first)))
> return __first;
> ++__first;
> case 0:
> default:
> return __last;
> }
> }
>
>
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> __find_if_not(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
> return std::__find_if_not(__first, __last, __pred,
> std::__iterator_category(__first));
> }
>
>
>
>
> template<typename _InputIterator, typename _Predicate, typename _Distance>
> _InputIterator
> __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
> {
> for (; __len; --__len, ++__first)
> if (!bool(__pred(*__first)))
> break;
> return __first;
> }
># 347 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp>
> _ForwardIterator
> __search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> std::forward_iterator_tag)
> {
> __first = std::find(__first, __last, __val);
> while (__first != __last)
> {
> typename iterator_traits<_ForwardIterator>::difference_type
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> while (__i != __last && __n != 1 && *__i == __val)
> {
> ++__i;
> --__n;
> }
> if (__n == 1)
> return __first;
> if (__i == __last)
> return __last;
> __first = std::find(++__i, __last, __val);
> }
> return __last;
> }
>
>
>
>
>
>
> template<typename _RandomAccessIter, typename _Integer, typename _Tp>
> _RandomAccessIter
> __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
> _Integer __count, const _Tp& __val,
> std::random_access_iterator_tag)
> {
>
> typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
> _DistanceType;
>
> _DistanceType __tailSize = __last - __first;
> const _DistanceType __pattSize = __count;
>
> if (__tailSize < __pattSize)
> return __last;
>
> const _DistanceType __skipOffset = __pattSize - 1;
> _RandomAccessIter __lookAhead = __first + __skipOffset;
> __tailSize -= __pattSize;
>
> while (1)
> {
>
>
> while (!(*__lookAhead == __val))
> {
> if (__tailSize < __pattSize)
> return __last;
> __lookAhead += __pattSize;
> __tailSize -= __pattSize;
> }
> _DistanceType __remainder = __skipOffset;
> for (_RandomAccessIter __backTrack = __lookAhead - 1;
> *__backTrack == __val; --__backTrack)
> {
> if (--__remainder == 0)
> return (__lookAhead - __skipOffset);
> }
> if (__remainder > __tailSize)
> return __last;
> __lookAhead += __remainder;
> __tailSize -= __remainder;
> }
> }
># 432 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _ForwardIterator
> __search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred, std::forward_iterator_tag)
> {
> while (__first != __last && !bool(__binary_pred(*__first, __val)))
> ++__first;
>
> while (__first != __last)
> {
> typename iterator_traits<_ForwardIterator>::difference_type
> __n = __count;
> _ForwardIterator __i = __first;
> ++__i;
> while (__i != __last && __n != 1 && bool(__binary_pred(*__i, __val)))
> {
> ++__i;
> --__n;
> }
> if (__n == 1)
> return __first;
> if (__i == __last)
> return __last;
> __first = ++__i;
> while (__first != __last
> && !bool(__binary_pred(*__first, __val)))
> ++__first;
> }
> return __last;
> }
>
>
>
>
>
>
>
> template<typename _RandomAccessIter, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _RandomAccessIter
> __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
> {
>
> typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
> _DistanceType;
>
> _DistanceType __tailSize = __last - __first;
> const _DistanceType __pattSize = __count;
>
> if (__tailSize < __pattSize)
> return __last;
>
> const _DistanceType __skipOffset = __pattSize - 1;
> _RandomAccessIter __lookAhead = __first + __skipOffset;
> __tailSize -= __pattSize;
>
> while (1)
> {
>
>
> while (!bool(__binary_pred(*__lookAhead, __val)))
> {
> if (__tailSize < __pattSize)
> return __last;
> __lookAhead += __pattSize;
> __tailSize -= __pattSize;
> }
> _DistanceType __remainder = __skipOffset;
> for (_RandomAccessIter __backTrack = __lookAhead - 1;
> __binary_pred(*__backTrack, __val); --__backTrack)
> {
> if (--__remainder == 0)
> return (__lookAhead - __skipOffset);
> }
> if (__remainder > __tailSize)
> return __last;
> __lookAhead += __remainder;
> __tailSize -= __remainder;
> }
> }
>
>
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator1
> __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> forward_iterator_tag, forward_iterator_tag)
> {
> if (__first2 == __last2)
> return __last1;
> else
> {
> _ForwardIterator1 __result = __last1;
> while (1)
> {
> _ForwardIterator1 __new_result
> = std::search(__first1, __last1, __first2, __last2);
> if (__new_result == __last1)
> return __result;
> else
> {
> __result = __new_result;
> __first1 = __new_result;
> ++__first1;
> }
> }
> }
> }
>
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _ForwardIterator1
> __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2,
> forward_iterator_tag, forward_iterator_tag,
> _BinaryPredicate __comp)
> {
> if (__first2 == __last2)
> return __last1;
> else
> {
> _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<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
> _BidirectionalIterator1
> __find_end(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> bidirectional_iterator_tag, bidirectional_iterator_tag)
> {
>
> 
>
> 
>
>
> 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);
>
> if (__rresult == __rlast1)
> return __last1;
> else
> {
> _BidirectionalIterator1 __result = __rresult.base();
> std::advance(__result, -std::distance(__first2, __last2));
> return __result;
> }
> }
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BinaryPredicate>
> _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;
> }
> }
># 671 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> 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));
> }
># 718 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> 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),
> __comp);
> }
># 753 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> { return __last == std::find_if_not(__first, __last, __pred); }
># 770 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> { return __last == std::find_if(__first, __last, __pred); }
># 788 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
> { return !std::none_of(__first, __last, __pred); }
># 803 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> find_if_not(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
> ;
> return std::__find_if_not(__first, __last, __pred);
> }
># 826 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline bool
> is_partitioned(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
> __first = std::find_if_not(__first, __last, __pred);
> return std::none_of(__first, __last, __pred);
> }
># 844 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> partition_point(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
>
>
> ;
>
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _DistanceType __len = std::distance(__first, __last);
> _DistanceType __half;
> _ForwardIterator __middle;
>
> while (__len > 0)
> {
> __half = __len >> 1;
> __middle = __first;
> std::advance(__middle, __half);
> if (__pred(*__middle))
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else
> __len = __half;
> }
> return __first;
> }
># 897 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> _OutputIterator
> remove_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, const _Tp& __value)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (!(*__first == __value))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
># 934 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate>
> _OutputIterator
> remove_copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _Predicate __pred)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (!bool(__pred(*__first)))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
># 973 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate>
> _OutputIterator
> copy_if(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _Predicate __pred)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> {
> *__result = *__first;
> ++__result;
> }
> return __result;
> }
>
>
> template<typename _InputIterator, typename _Size, typename _OutputIterator>
> _OutputIterator
> __copy_n(_InputIterator __first, _Size __n,
> _OutputIterator __result, input_iterator_tag)
> {
> if (__n > 0)
> {
> while (true)
> {
> *__result = *__first;
> ++__result;
> if (--__n > 0)
> ++__first;
> else
> break;
> }
> }
> return __result;
> }
>
> template<typename _RandomAccessIterator, typename _Size,
> typename _OutputIterator>
> inline _OutputIterator
> __copy_n(_RandomAccessIterator __first, _Size __n,
> _OutputIterator __result, random_access_iterator_tag)
> { return std::copy(__first, __first + __n, __result); }
># 1037 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Size, typename _OutputIterator>
> inline _OutputIterator
> copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
> {
>
> 
> 
>
>
> return std::__copy_n(__first, __n, __result,
> std::__iterator_category(__first));
> }
># 1065 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator1,
> typename _OutputIterator2, typename _Predicate>
> pair<_OutputIterator1, _OutputIterator2>
> partition_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator1 __out_true, _OutputIterator2 __out_false,
> _Predicate __pred)
> {
>
> 
> 
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> {
> *__out_true = *__first;
> ++__out_true;
> }
> else
> {
> *__out_false = *__first;
> ++__out_false;
> }
>
> return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
> }
># 1115 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> remove(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __value)
> {
>
> 
>
> 
>
> ;
>
> __first = std::find(__first, __last, __value);
> if(__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> ++__first;
> for(; __first != __last; ++__first)
> if(!(*__first == __value))
> {
> *__result = std::move(*__first);
> ++__result;
> }
> return __result;
> }
># 1158 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _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(!bool(__pred(*__first)))
> {
> *__result = std::move(*__first);
> ++__result;
> }
> return __result;
> }
># 1198 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> unique(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
>
> 
>
> ;
>
>
> __first = std::adjacent_find(__first, __last);
> if (__first == __last)
> return __last;
>
>
> _ForwardIterator __dest = __first;
> ++__first;
> while (++__first != __last)
> if (!(*__dest == *__first))
> *++__dest = std::move(*__first);
> return ++__dest;
> }
># 1238 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _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 (!bool(__binary_pred(*__dest, *__first)))
> *++__dest = std::move(*__first);
> return ++__dest;
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _OutputIterator>
> _OutputIterator
> __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
> _OutputIterator __result,
> forward_iterator_tag, output_iterator_tag)
> {
>
> _ForwardIterator __next = __first;
> *__result = *__first;
> while (++__next != __last)
> if (!(*__first == *__next))
> {
> __first = __next;
> *++__result = *__first;
> }
> return ++__result;
> }
>
>
>
>
>
>
> template<typename _InputIterator, typename _OutputIterator>
> _OutputIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> input_iterator_tag, output_iterator_tag)
> {
>
> typename iterator_traits<_InputIterator>::value_type __value = *__first;
> *__result = __value;
> while (++__first != __last)
> if (!(__value == *__first))
> {
> __value = *__first;
> *++__result = __value;
> }
> return ++__result;
> }
>
>
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator>
> _ForwardIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result,
> input_iterator_tag, forward_iterator_tag)
> {
>
> *__result = *__first;
> while (++__first != __last)
> if (!(*__result == *__first))
> *++__result = *__first;
> return ++__result;
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> _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 (!bool(__binary_pred(*__first, *__next)))
> {
> __first = __next;
> *++__result = *__first;
> }
> return ++__result;
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> _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;
> *__result = __value;
> while (++__first != __last)
> if (!bool(__binary_pred(__value, *__first)))
> {
> __value = *__first;
> *++__result = __value;
> }
> return ++__result;
> }
>
>
>
>
>
>
>
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _ForwardIterator
> __unique_copy(_InputIterator __first, _InputIterator __last,
> _ForwardIterator __result, _BinaryPredicate __binary_pred,
> input_iterator_tag, forward_iterator_tag)
> {
>
> 
>
>
>
> *__result = *__first;
> while (++__first != __last)
> if (!bool(__binary_pred(*__result, *__first)))
> *++__result = *__first;
> return ++__result;
> }
>
>
>
>
>
>
> template<typename _BidirectionalIterator>
> 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<typename _RandomAccessIterator>
> 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;
> }
> }
># 1466 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> inline void
> reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
> {
>
> 
>
> ;
> std::__reverse(__first, __last, std::__iterator_category(__first));
> }
># 1493 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _OutputIterator>
> _OutputIterator
> reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
> _OutputIterator __result)
> {
>
> 
>
> 
>
> ;
>
> while (__first != __last)
> {
> --__last;
> *__result = *__last;
> ++__result;
> }
> return __result;
> }
>
>
>
>
>
> template<typename _EuclideanRingElement>
> _EuclideanRingElement
> __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
> {
> while (__n != 0)
> {
> _EuclideanRingElement __t = __m % __n;
> __m = __n;
> __n = __t;
> }
> return __m;
> }
>
>
> template<typename _ForwardIterator>
> void
> __rotate(_ForwardIterator __first,
> _ForwardIterator __middle,
> _ForwardIterator __last,
> forward_iterator_tag)
> {
> if (__first == __middle || __last == __middle)
> return;
>
> _ForwardIterator __first2 = __middle;
> do
> {
> std::iter_swap(__first, __first2);
> ++__first;
> ++__first2;
> if (__first == __middle)
> __middle = __first2;
> }
> while (__first2 != __last);
>
> __first2 = __middle;
>
> while (__first2 != __last)
> {
> std::iter_swap(__first, __first2);
> ++__first;
> ++__first2;
> if (__first == __middle)
> __middle = __first2;
> else if (__first2 == __last)
> __first2 = __middle;
> }
> }
>
>
> template<typename _BidirectionalIterator>
> void
> __rotate(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> bidirectional_iterator_tag)
> {
>
> 
>
>
> if (__first == __middle || __last == __middle)
> return;
>
> 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());
> else
> std::__reverse(__first, __middle, bidirectional_iterator_tag());
> }
>
>
> template<typename _RandomAccessIterator>
> void
> __rotate(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> random_access_iterator_tag)
> {
>
> 
>
>
> if (__first == __middle || __last == __middle)
> return;
>
> 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;
> }
>
> _RandomAccessIterator __p = __first;
>
> for (;;)
> {
> if (__k < __n - __k)
> {
> if (__is_pod(_ValueType) && __k == 1)
> {
> _ValueType __t = std::move(*__p);
> std::move(__p + 1, __p + __n, __p);
> *(__p + __n - 1) = std::move(__t);
> return;
> }
> _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;
> std::swap(__n, __k);
> __k = __n - __k;
> }
> else
> {
> __k = __n - __k;
> if (__is_pod(_ValueType) && __k == 1)
> {
> _ValueType __t = std::move(*(__p + __n - 1));
> std::move_backward(__p, __p + __n - 1, __p + __n);
> *__p = std::move(__t);
> return;
> }
> _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;
> std::swap(__n, __k);
> }
> }
> }
># 1699 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline void
> rotate(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last)
> {
>
> 
>
> ;
> ;
>
> typedef typename iterator_traits<_ForwardIterator>::iterator_category
> _IterType;
> std::__rotate(__first, __middle, __last, _IterType());
> }
># 1735 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _OutputIterator>
> _OutputIterator
> rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
> _ForwardIterator __last, _OutputIterator __result)
> {
>
> 
> 
>
> ;
> ;
>
> return std::copy(__first, __middle,
> std::copy(__middle, __last, __result));
> }
>
>
> template<typename _ForwardIterator, typename _Predicate>
> _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<typename _BidirectionalIterator, typename _Predicate>
> _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;
> }
> }
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Predicate, typename _Distance>
> _ForwardIterator
> __inplace_stable_partition(_ForwardIterator __first,
> _Predicate __pred, _Distance __len)
> {
> if (__len == 1)
> return __first;
> _ForwardIterator __middle = __first;
> std::advance(__middle, __len / 2);
> _ForwardIterator __left_split =
> std::__inplace_stable_partition(__first, __pred, __len / 2);
>
>
> _Distance __right_len = __len - __len / 2;
> _ForwardIterator __right_split =
> std::__find_if_not_n(__middle, __right_len, __pred);
> if (__right_len)
> __right_split = std::__inplace_stable_partition(__middle,
> __pred,
> __right_len);
> std::rotate(__left_split, __middle, __right_split);
> std::advance(__left_split, std::distance(__middle, __right_split));
> return __left_split;
> }
>
>
>
>
>
>
>
> template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
> typename _Distance>
> _ForwardIterator
> __stable_partition_adaptive(_ForwardIterator __first,
> _ForwardIterator __last,
> _Predicate __pred, _Distance __len,
> _Pointer __buffer,
> _Distance __buffer_size)
> {
> if (__len <= __buffer_size)
> {
> _ForwardIterator __result1 = __first;
> _Pointer __result2 = __buffer;
>
>
>
> *__result2 = std::move(*__first);
> ++__result2;
> ++__first;
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> {
> *__result1 = std::move(*__first);
> ++__result1;
> }
> else
> {
> *__result2 = std::move(*__first);
> ++__result2;
> }
> std::move(__buffer, __result2, __result1);
> return __result1;
> }
> else
> {
> _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;
> }
> }
># 1914 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> _ForwardIterator
> stable_partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> __first = std::__find_if_not(__first, __last, __pred);
>
> if (__first == __last)
> return __first;
> else
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_ForwardIterator>::difference_type
> _DistanceType;
>
> _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.size() > 0)
> return
> std::__stable_partition_adaptive(__first, __last, __pred,
> _DistanceType(__buf.requested_size()),
> __buf.begin(),
> _DistanceType(__buf.size()));
> else
> return
> std::__inplace_stable_partition(__first, __pred,
> _DistanceType(__buf.requested_size()));
> }
> }
>
>
> template<typename _RandomAccessIterator>
> void
> __heap_select(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last)
> {
> std::make_heap(__first, __middle);
> for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
> if (*__i < *__first)
> std::__pop_heap(__first, __middle, __i);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> 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);
> }
># 1998 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator>
> _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;
>
>
> 
> 
>
> 
>
> 
> ;
> ;
>
> 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);
> while (__first != __last)
> {
> if (*__first < *__result_first)
> std::__adjust_heap(__result_first, _DistanceType(0),
> _DistanceType(__result_real_last
> - __result_first),
> _InputValueType(*__first));
> ++__first;
> }
> std::sort_heap(__result_first, __result_real_last);
> return __result_real_last;
> }
># 2064 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
> _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;
>
>
> 
> 
>
> 
>
> 
>
> 
>
> ;
> ;
>
> 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;
> }
>
>
> template<typename _RandomAccessIterator>
> void
> __unguarded_linear_insert(_RandomAccessIterator __last)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = std::move(*__last);
> _RandomAccessIterator __next = __last;
> --__next;
> while (__val < *__next)
> {
> *__last = std::move(*__next);
> __last = __next;
> --__next;
> }
> *__last = std::move(__val);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> void
> __unguarded_linear_insert(_RandomAccessIterator __last,
> _Compare __comp)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = std::move(*__last);
> _RandomAccessIterator __next = __last;
> --__next;
> while (__comp(__val, *__next))
> {
> *__last = std::move(*__next);
> __last = __next;
> --__next;
> }
> *__last = std::move(__val);
> }
>
>
> template<typename _RandomAccessIterator>
> void
> __insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__first == __last)
> return;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> {
> if (*__i < *__first)
> {
> typename iterator_traits<_RandomAccessIterator>::value_type
> __val = std::move(*__i);
> std::move_backward(__first, __i, __i + 1);
> *__first = std::move(__val);
> }
> else
> std::__unguarded_linear_insert(__i);
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> 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 = std::move(*__i);
> std::move_backward(__first, __i, __i + 1);
> *__first = std::move(__val);
> }
> else
> std::__unguarded_linear_insert(__i, __comp);
> }
> }
>
>
> template<typename _RandomAccessIterator>
> inline void
> __unguarded_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> __unguarded_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
> std::__unguarded_linear_insert(__i, __comp);
> }
>
>
>
>
>
> enum { _S_threshold = 16 };
>
>
> template<typename _RandomAccessIterator>
> void
> __final_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__last - __first > int(_S_threshold))
> {
> std::__insertion_sort(__first, __first + int(_S_threshold));
> std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
> }
> else
> std::__insertion_sort(__first, __last);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> 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<typename _RandomAccessIterator, typename _Tp>
> _RandomAccessIterator
> __unguarded_partition(_RandomAccessIterator __first,
> _RandomAccessIterator __last, const _Tp& __pivot)
> {
> while (true)
> {
> while (*__first < __pivot)
> ++__first;
> --__last;
> while (__pivot < *__last)
> --__last;
> if (!(__first < __last))
> return __first;
> std::iter_swap(__first, __last);
> ++__first;
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
> _RandomAccessIterator
> __unguarded_partition(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> const _Tp& __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<typename _RandomAccessIterator>
> inline _RandomAccessIterator
> __unguarded_partition_pivot(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> _RandomAccessIterator __mid = __first + (__last - __first) / 2;
> std::__move_median_first(__first, __mid, (__last - 1));
> return std::__unguarded_partition(__first + 1, __last, *__first);
> }
>
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> inline _RandomAccessIterator
> __unguarded_partition_pivot(_RandomAccessIterator __first,
> _RandomAccessIterator __last, _Compare __comp)
> {
> _RandomAccessIterator __mid = __first + (__last - __first) / 2;
> std::__move_median_first(__first, __mid, (__last - 1), __comp);
> return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
> }
>
>
> template<typename _RandomAccessIterator, typename _Size>
> void
> __introsort_loop(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Size __depth_limit)
> {
> while (__last - __first > int(_S_threshold))
> {
> if (__depth_limit == 0)
> {
> std::partial_sort(__first, __last, __last);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition_pivot(__first, __last);
> std::__introsort_loop(__cut, __last, __depth_limit);
> __last = __cut;
> }
> }
>
>
> template<typename _RandomAccessIterator, typename _Size, typename _Compare>
> 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<typename _RandomAccessIterator, typename _Size>
> void
> __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last, _Size __depth_limit)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> while (__last - __first > 3)
> {
> if (__depth_limit == 0)
> {
> std::__heap_select(__first, __nth + 1, __last);
>
>
> std::iter_swap(__first, __nth);
> return;
> }
> --__depth_limit;
> _RandomAccessIterator __cut =
> std::__unguarded_partition_pivot(__first, __last);
> if (__cut <= __nth)
> __first = __cut;
> else
> __last = __cut;
> }
> std::__insertion_sort(__first, __last);
> }
>
> template<typename _RandomAccessIterator, typename _Size, typename _Compare>
> void
> __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last, _Size __depth_limit,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
> 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);
> }
># 2448 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> lower_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> 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;
> }
># 2495 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> 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 (__val < *__middle)
> __len = __half;
> else
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> }
> return __first;
> }
># 2544 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> _ForwardIterator
> upper_bound(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> 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;
> }
># 2597 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> 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 (*__middle < __val)
> {
> __first = __middle;
> ++__first;
> __len = __len - __half - 1;
> }
> else if (__val < *__middle)
> __len = __half;
> else
> {
> _ForwardIterator __left = std::lower_bound(__first, __middle,
> __val);
> std::advance(__first, __len);
> _ForwardIterator __right = std::upper_bound(++__middle, __first,
> __val);
> return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
> }
> }
> return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
> }
># 2659 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> pair<_ForwardIterator, _ForwardIterator>
> equal_range(_ForwardIterator __first, _ForwardIterator __last,
> const _Tp& __val, _Compare __comp)
> {
> typedef typename iterator_traits<_ForwardIterator>::value_type
> _ValueType;
> 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 if (__comp(__val, *__middle))
> __len = __half;
> else
> {
> _ForwardIterator __left = std::lower_bound(__first, __middle,
> __val, __comp);
> std::advance(__first, __len);
> _ForwardIterator __right = std::upper_bound(++__middle, __first,
> __val, __comp);
> return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
> }
> }
> return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
> }
># 2720 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> 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);
> return __i != __last && !(__val < *__i);
> }
># 2753 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp, typename _Compare>
> 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, __comp);
> return __i != __last && !bool(__comp(__val, *__i));
> }
>
>
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> void
> __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first2 < *__first1)
> {
> *__result = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> if (__first1 != __last1)
> std::move(__first1, __last1, __result);
> }
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> 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 = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> if (__first1 != __last1)
> std::move(__first1, __last1, __result);
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BidirectionalIterator3>
> void
> __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> _BidirectionalIterator3 __result)
> {
> if (__first1 == __last1)
> {
> std::move_backward(__first2, __last2, __result);
> return;
> }
> else if (__first2 == __last2)
> return;
>
> --__last1;
> --__last2;
> while (true)
> {
> if (*__last2 < *__last1)
> {
> *--__result = std::move(*__last1);
> if (__first1 == __last1)
> {
> std::move_backward(__first2, ++__last2, __result);
> return;
> }
> --__last1;
> }
> else
> {
> *--__result = std::move(*__last2);
> if (__first2 == __last2)
> return;
> --__last2;
> }
> }
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _BidirectionalIterator3, typename _Compare>
> void
> __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
> _BidirectionalIterator1 __last1,
> _BidirectionalIterator2 __first2,
> _BidirectionalIterator2 __last2,
> _BidirectionalIterator3 __result,
> _Compare __comp)
> {
> if (__first1 == __last1)
> {
> std::move_backward(__first2, __last2, __result);
> return;
> }
> else if (__first2 == __last2)
> return;
>
> --__last1;
> --__last2;
> while (true)
> {
> if (__comp(*__last2, *__last1))
> {
> *--__result = std::move(*__last1);
> if (__first1 == __last1)
> {
> std::move_backward(__first2, ++__last2, __result);
> return;
> }
> --__last1;
> }
> else
> {
> *--__result = std::move(*__last2);
> if (__first2 == __last2)
> return;
> --__last2;
> }
> }
> }
>
>
> template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
> typename _Distance>
> _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::move(__middle, __last, __buffer);
> std::move_backward(__first, __middle, __last);
> return std::move(__buffer, __buffer_end, __first);
> }
> else
> return __first;
> }
> else if (__len1 <= __buffer_size)
> {
> if (__len1)
> {
> __buffer_end = std::move(__first, __middle, __buffer);
> std::move(__middle, __last, __first);
> return std::move_backward(__buffer, __buffer_end, __last);
> }
> else
> return __last;
> }
> else
> {
> std::rotate(__first, __middle, __last);
> std::advance(__first, std::distance(__middle, __last));
> return __first;
> }
> }
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Pointer>
> void
> __merge_adaptive(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2,
> _Pointer __buffer, _Distance __buffer_size)
> {
> if (__len1 <= __len2 && __len1 <= __buffer_size)
> {
> _Pointer __buffer_end = std::move(__first, __middle, __buffer);
> std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
> __first);
> }
> else if (__len2 <= __buffer_size)
> {
> _Pointer __buffer_end = std::move(__middle, __last, __buffer);
> std::__move_merge_adaptive_backward(__first, __middle, __buffer,
> __buffer_end, __last);
> }
> 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);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle,
> *__second_cut);
> __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);
> std::__merge_adaptive(__new_middle, __second_cut, __last,
> __len1 - __len11,
> __len2 - __len22, __buffer, __buffer_size);
> }
> }
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Pointer, typename _Compare>
> 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::move(__first, __middle, __buffer);
> std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
> __first, __comp);
> }
> else if (__len2 <= __buffer_size)
> {
> _Pointer __buffer_end = std::move(__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,
> __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,
> __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<typename _BidirectionalIterator, typename _Distance>
> void
> __merge_without_buffer(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last,
> _Distance __len1, _Distance __len2)
> {
> if (__len1 == 0 || __len2 == 0)
> return;
> if (__len1 + __len2 == 2)
> {
> if (*__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);
> __len22 = std::distance(__middle, __second_cut);
> }
> else
> {
> __len22 = __len2 / 2;
> std::advance(__second_cut, __len22);
> __first_cut = std::upper_bound(__first, __middle, *__second_cut);
> __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);
> std::__merge_without_buffer(__new_middle, __second_cut, __last,
> __len1 - __len11, __len2 - __len22);
> }
>
>
> template<typename _BidirectionalIterator, typename _Distance,
> typename _Compare>
> 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,
> __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,
> __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);
> }
># 3177 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> void
> inplace_merge(_BidirectionalIterator __first,
> _BidirectionalIterator __middle,
> _BidirectionalIterator __last)
> {
> typedef typename iterator_traits<_BidirectionalIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_BidirectionalIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
> ;
>
> if (__first == __middle || __middle == __last)
> return;
>
> _DistanceType __len1 = std::distance(__first, __middle);
> _DistanceType __len2 = std::distance(__middle, __last);
>
> _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
> else
> std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
> __buf.begin(), _DistanceType(__buf.size()));
> }
># 3232 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> 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);
>
> _Temporary_buffer<_BidirectionalIterator, _ValueType> __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);
> }
>
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first2 < *__first1)
> {
> *__result = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> return std::move(__first2, __last2, std::move(__first1, __last1, __result))
>
> ;
> }
>
>
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> __move_merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (__comp(*__first2, *__first1))
> {
> *__result = std::move(*__first2);
> ++__first2;
> }
> else
> {
> *__result = std::move(*__first1);
> ++__first1;
> }
> ++__result;
> }
> return std::move(__first2, __last2, std::move(__first1, __last1, __result))
>
> ;
> }
>
> template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
> typename _Distance>
> void
> __merge_sort_loop(_RandomAccessIterator1 __first,
> _RandomAccessIterator1 __last,
> _RandomAccessIterator2 __result,
> _Distance __step_size)
> {
> 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);
> __first += __two_step;
> }
>
> __step_size = std::min(_Distance(__last - __first), __step_size);
> std::__move_merge(__first, __first + __step_size,
> __first + __step_size, __last, __result);
> }
>
> template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
> typename _Distance, typename _Compare>
> 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<typename _RandomAccessIterator, typename _Distance>
> void
> __chunk_insertion_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Distance __chunk_size)
> {
> while (__last - __first >= __chunk_size)
> {
> std::__insertion_sort(__first, __first + __chunk_size);
> __first += __chunk_size;
> }
> std::__insertion_sort(__first, __last);
> }
>
> template<typename _RandomAccessIterator, typename _Distance,
> typename _Compare>
> 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<typename _RandomAccessIterator, typename _Pointer>
> void
> __merge_sort_with_buffer(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer)
> {
> 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);
>
> while (__step_size < __len)
> {
> std::__merge_sort_loop(__first, __last, __buffer, __step_size);
> __step_size *= 2;
> std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
> __step_size *= 2;
> }
> }
>
> template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
> 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<typename _RandomAccessIterator, typename _Pointer,
> typename _Distance>
> void
> __stable_sort_adaptive(_RandomAccessIterator __first,
> _RandomAccessIterator __last,
> _Pointer __buffer, _Distance __buffer_size)
> {
> 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);
> std::__stable_sort_adaptive(__middle, __last,
> __buffer, __buffer_size);
> }
> else
> {
> std::__merge_sort_with_buffer(__first, __middle, __buffer);
> std::__merge_sort_with_buffer(__middle, __last, __buffer);
> }
> std::__merge_adaptive(__first, __middle, __last,
> _Distance(__middle - __first),
> _Distance(__last - __middle),
> __buffer, __buffer_size);
> }
>
> template<typename _RandomAccessIterator, typename _Pointer,
> typename _Distance, typename _Compare>
> 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<typename _RandomAccessIterator>
> void
> __inplace_stable_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __last)
> {
> if (__last - __first < 15)
> {
> std::__insertion_sort(__first, __last);
> return;
> }
> _RandomAccessIterator __middle = __first + (__last - __first) / 2;
> std::__inplace_stable_sort(__first, __middle);
> std::__inplace_stable_sort(__middle, __last);
> std::__merge_without_buffer(__first, __middle, __last,
> __middle - __first,
> __last - __middle);
> }
>
>
> template<typename _RandomAccessIterator, typename _Compare>
> 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);
> }
># 3572 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2>
> bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first2 < *__first1)
> return false;
> else if(*__first1 < *__first2)
> ++__first1;
> else
> ++__first1, ++__first2;
>
> return __first2 == __last2;
> }
># 3622 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _Compare>
> bool
> includes(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first2, *__first1))
> return false;
> else if(__comp(*__first1, *__first2))
> ++__first1;
> else
> ++__first1, ++__first2;
>
> return __first2 == __last2;
> }
># 3677 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> bool
> next_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (*__i < *__ii)
> {
> _BidirectionalIterator __j = __last;
> while (!(*__i < *--__j))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 3734 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> 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 (!bool(__comp(*__i, *--__j)))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 3790 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator>
> bool
> prev_permutation(_BidirectionalIterator __first,
> _BidirectionalIterator __last)
> {
>
> 
>
> 
>
> ;
>
> if (__first == __last)
> return false;
> _BidirectionalIterator __i = __first;
> ++__i;
> if (__i == __last)
> return false;
> __i = __last;
> --__i;
>
> for(;;)
> {
> _BidirectionalIterator __ii = __i;
> --__i;
> if (*__ii < *__i)
> {
> _BidirectionalIterator __j = __last;
> while (!(*--__j < *__i))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 3847 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _BidirectionalIterator, typename _Compare>
> 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 (!bool(__comp(*--__j, *__i)))
> {}
> std::iter_swap(__i, __j);
> std::reverse(__ii, __last);
> return true;
> }
> if (__i == __first)
> {
> std::reverse(__first, __last);
> return false;
> }
> }
> }
># 3907 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator, typename _Tp>
> _OutputIterator
> replace_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result,
> const _Tp& __old_value, const _Tp& __new_value)
> {
>
> 
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first, ++__result)
> if (*__first == __old_value)
> *__result = __new_value;
> else
> *__result = *__first;
> return __result;
> }
># 3944 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _Predicate, typename _Tp>
> _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;
> }
># 3975 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> inline bool
> is_sorted(_ForwardIterator __first, _ForwardIterator __last)
> { return std::is_sorted_until(__first, __last) == __last; }
># 3989 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> inline bool
> is_sorted(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> { return std::is_sorted_until(__first, __last, __comp) == __last; }
># 4003 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __last;
>
> _ForwardIterator __next = __first;
> for (++__next; __next != __last; __first = __next, ++__next)
> if (*__next < *__first)
> return __next;
> return __next;
> }
># 4032 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _ForwardIterator
> is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> if (__first == __last)
> return __last;
>
> _ForwardIterator __next = __first;
> for (++__next; __next != __last; __first = __next, ++__next)
> if (__comp(*__next, *__first))
> return __next;
> return __next;
> }
># 4062 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _Tp>
> inline pair<const _Tp&, const _Tp&>
> minmax(const _Tp& __a, const _Tp& __b)
> {
>
> 
>
> return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
> : pair<const _Tp&, const _Tp&>(__a, __b);
> }
># 4082 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _Tp, typename _Compare>
> inline pair<const _Tp&, const _Tp&>
> minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
> {
> return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
> : pair<const _Tp&, const _Tp&>(__a, __b);
> }
># 4101 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> pair<_ForwardIterator, _ForwardIterator>
> minmax_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> _ForwardIterator __next = __first;
> if (__first == __last
> || ++__next == __last)
> return std::make_pair(__first, __first);
>
> _ForwardIterator __min, __max;
> if (*__next < *__first)
> {
> __min = __next;
> __max = __first;
> }
> else
> {
> __min = __first;
> __max = __next;
> }
>
> __first = __next;
> ++__first;
>
> while (__first != __last)
> {
> __next = __first;
> if (++__next == __last)
> {
> if (*__first < *__min)
> __min = __first;
> else if (!(*__first < *__max))
> __max = __first;
> break;
> }
>
> if (*__next < *__first)
> {
> if (*__next < *__min)
> __min = __next;
> if (!(*__first < *__max))
> __max = __first;
> }
> else
> {
> if (*__first < *__min)
> __min = __first;
> if (!(*__next < *__max))
> __max = __next;
> }
>
> __first = __next;
> ++__first;
> }
>
> return std::make_pair(__min, __max);
> }
># 4177 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> pair<_ForwardIterator, _ForwardIterator>
> minmax_element(_ForwardIterator __first, _ForwardIterator __last,
> _Compare __comp)
> {
>
> 
> 
>
>
> ;
>
> _ForwardIterator __next = __first;
> if (__first == __last
> || ++__next == __last)
> return std::make_pair(__first, __first);
>
> _ForwardIterator __min, __max;
> if (__comp(*__next, *__first))
> {
> __min = __next;
> __max = __first;
> }
> else
> {
> __min = __first;
> __max = __next;
> }
>
> __first = __next;
> ++__first;
>
> while (__first != __last)
> {
> __next = __first;
> if (++__next == __last)
> {
> if (__comp(*__first, *__min))
> __min = __first;
> else if (!__comp(*__first, *__max))
> __max = __first;
> break;
> }
>
> if (__comp(*__next, *__first))
> {
> if (__comp(*__next, *__min))
> __min = __next;
> if (!__comp(*__first, *__max))
> __max = __first;
> }
> else
> {
> if (__comp(*__first, *__min))
> __min = __first;
> if (!__comp(*__next, *__max))
> __max = __next;
> }
>
> __first = __next;
> ++__first;
> }
>
> return std::make_pair(__min, __max);
> }
>
>
> template<typename _Tp>
> inline _Tp
> min(initializer_list<_Tp> __l)
> { return *std::min_element(__l.begin(), __l.end()); }
>
> template<typename _Tp, typename _Compare>
> inline _Tp
> min(initializer_list<_Tp> __l, _Compare __comp)
> { return *std::min_element(__l.begin(), __l.end(), __comp); }
>
> template<typename _Tp>
> inline _Tp
> max(initializer_list<_Tp> __l)
> { return *std::max_element(__l.begin(), __l.end()); }
>
> template<typename _Tp, typename _Compare>
> inline _Tp
> max(initializer_list<_Tp> __l, _Compare __comp)
> { return *std::max_element(__l.begin(), __l.end(), __comp); }
>
> template<typename _Tp>
> inline pair<_Tp, _Tp>
> minmax(initializer_list<_Tp> __l)
> {
> pair<const _Tp*, const _Tp*> __p =
> std::minmax_element(__l.begin(), __l.end());
> return std::make_pair(*__p.first, *__p.second);
> }
>
> template<typename _Tp, typename _Compare>
> inline pair<_Tp, _Tp>
> minmax(initializer_list<_Tp> __l, _Compare __comp)
> {
> pair<const _Tp*, const _Tp*> __p =
> std::minmax_element(__l.begin(), __l.end(), __comp);
> return std::make_pair(*__p.first, *__p.second);
> }
># 4294 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> bool
> is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2)
> {
>
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!(*__first1 == *__first2))
> break;
>
> if (__first1 == __last1)
> return true;
>
>
>
> _ForwardIterator2 __last2 = __first2;
> std::advance(__last2, std::distance(__first1, __last1));
> for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
> {
> if (__scan != std::find(__first1, __scan, *__scan))
> continue;
>
> auto __matches = std::count(__first2, __last2, *__scan);
> if (0 == __matches
> || std::count(__scan, __last1, *__scan) != __matches)
> return false;
> }
> return true;
> }
># 4339 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> bool
> is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _BinaryPredicate __pred)
> {
>
>
> for (; __first1 != __last1; ++__first1, ++__first2)
> if (!bool(__pred(*__first1, *__first2)))
> break;
>
> if (__first1 == __last1)
> return true;
>
>
>
> _ForwardIterator2 __last2 = __first2;
> std::advance(__last2, std::distance(__first1, __last1));
> for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
> {
> using std::placeholders::_1;
>
> if (__scan != std::find_if(__first1, __scan,
> std::bind(__pred, _1, *__scan)))
> continue;
>
> auto __matches = std::count_if(__first2, __last2,
> std::bind(__pred, _1, *__scan));
> if (0 == __matches
> || std::count_if(__scan, __last1,
> std::bind(__pred, _1, *__scan)) != __matches)
> return false;
> }
> return true;
> }
># 4389 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator,
> typename _UniformRandomNumberGenerator>
> void
> shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _UniformRandomNumberGenerator&& __g)
> {
>
> 
>
> ;
>
> if (__first == __last)
> return;
>
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
> typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
> typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
> typedef typename __distr_type::param_type __p_type;
> __distr_type __d;
>
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
> }
>
>
>
>
>
>
>
># 4434 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Function>
> _Function
> for_each(_InputIterator __first, _InputIterator __last, _Function __f)
> {
>
> 
> ;
> for (; __first != __last; ++__first)
> __f(*__first);
> return std::move(__f);
> }
># 4455 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> inline _InputIterator
> find(_InputIterator __first, _InputIterator __last,
> const _Tp& __val)
> {
>
> 
> 
>
> ;
> return std::__find(__first, __last, __val,
> std::__iterator_category(__first));
> }
># 4479 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> inline _InputIterator
> find_if(_InputIterator __first, _InputIterator __last,
> _Predicate __pred)
> {
>
> 
> 
>
> ;
> return std::__find_if(__first, __last, __pred,
> std::__iterator_category(__first));
> }
># 4509 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator>
> _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;
> }
># 4549 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _ForwardIterator,
> typename _BinaryPredicate>
> _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;
> }
># 4581 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
> if (__first == __last)
> return __last;
> _ForwardIterator __next = __first;
> while(++__next != __last)
> {
> if (*__first == *__next)
> return __first;
> __first = __next;
> }
> return __last;
> }
># 4613 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _BinaryPredicate>
> _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;
> }
># 4645 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Tp>
> typename iterator_traits<_InputIterator>::difference_type
> count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
> {
>
> 
> 
>
> ;
> typename iterator_traits<_InputIterator>::difference_type __n = 0;
> for (; __first != __last; ++__first)
> if (*__first == __value)
> ++__n;
> return __n;
> }
># 4670 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _Predicate>
> 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;
> }
># 4712 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2>
> _ForwardIterator1
> search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
> _ForwardIterator2 __first2, _ForwardIterator2 __last2)
> {
>
> 
> 
> 
>
>
> ;
> ;
>
>
> if (__first1 == __last1 || __first2 == __last2)
> return __first1;
>
>
> _ForwardIterator2 __p1(__first2);
> if (++__p1 == __last2)
> return std::find(__first1, __last1, *__first2);
>
>
> _ForwardIterator2 __p;
> _ForwardIterator1 __current = __first1;
>
> for (;;)
> {
> __first1 = std::find(__first1, __last1, *__first2);
> if (__first1 == __last1)
> return __last1;
>
> __p = __p1;
> __current = __first1;
> if (++__current == __last1)
> return __last1;
>
> while (*__current == *__p)
> {
> if (++__p == __last2)
> return __first1;
> if (++__current == __last1)
> return __last1;
> }
> ++__first1;
> }
> return __first1;
> }
># 4783 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator1, typename _ForwardIterator2,
> typename _BinaryPredicate>
> _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)
> {
> while (__first1 != __last1
> && !bool(__predicate(*__first1, *__first2)))
> ++__first1;
> return __first1;
> }
>
>
> _ForwardIterator2 __p;
> _ForwardIterator1 __current = __first1;
>
> for (;;)
> {
> while (__first1 != __last1
> && !bool(__predicate(*__first1, *__first2)))
> ++__first1;
> 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;
> }
># 4858 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp>
> _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val)
> {
>
> 
> 
>
> ;
>
> if (__count <= 0)
> return __first;
> if (__count == 1)
> return std::find(__first, __last, __val);
> return std::__search_n(__first, __last, __count, __val,
> std::__iterator_category(__first));
> }
># 4895 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Integer, typename _Tp,
> typename _BinaryPredicate>
> _ForwardIterator
> search_n(_ForwardIterator __first, _ForwardIterator __last,
> _Integer __count, const _Tp& __val,
> _BinaryPredicate __binary_pred)
> {
>
> 
> 
>
> ;
>
> if (__count <= 0)
> return __first;
> if (__count == 1)
> {
> while (__first != __last && !bool(__binary_pred(*__first, __val)))
> ++__first;
> return __first;
> }
> return std::__search_n(__first, __last, __count, __val, __binary_pred,
> std::__iterator_category(__first));
> }
># 4937 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _UnaryOperation>
> _OutputIterator
> transform(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result, _UnaryOperation __unary_op)
> {
>
> 
> 
>
>
> ;
>
> for (; __first != __last; ++__first, ++__result)
> *__result = __unary_op(*__first);
> return __result;
> }
># 4974 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _BinaryOperation>
> _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;
> }
># 5007 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Tp>
> 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;
> }
># 5039 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate, typename _Tp>
> void
> replace_if(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred, const _Tp& __new_value)
> {
>
> 
>
> 
>
> 
>
> ;
>
> for (; __first != __last; ++__first)
> if (__pred(*__first))
> *__first = __new_value;
> }
># 5071 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Generator>
> void
> generate(_ForwardIterator __first, _ForwardIterator __last,
> _Generator __gen)
> {
>
> 
> 
>
> ;
>
> for (; __first != __last; ++__first)
> *__first = __gen();
> }
># 5102 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _OutputIterator, typename _Size, typename _Generator>
> _OutputIterator
> generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
> {
>
> 
>
>
>
> for (__decltype(__n + 0) __niter = __n;
> __niter > 0; --__niter, ++__first)
> *__first = __gen();
> return __first;
> }
># 5139 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator>
> inline _OutputIterator
> unique_copy(_InputIterator __first, _InputIterator __last,
> _OutputIterator __result)
> {
>
> 
> 
>
> 
>
> ;
>
> if (__first == __last)
> return __result;
> return std::__unique_copy(__first, __last, __result,
> std::__iterator_category(__first),
> std::__iterator_category(__result));
> }
># 5178 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator, typename _OutputIterator,
> typename _BinaryPredicate>
> 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, __binary_pred,
> std::__iterator_category(__first),
> std::__iterator_category(__result));
> }
># 5210 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
>
> 
>
> ;
>
> if (__first != __last)
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
> }
># 5238 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
> void
> random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
>
> _RandomNumberGenerator&& __rand)
>
>
>
> {
>
> 
>
> ;
>
> if (__first == __last)
> return;
> for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
> std::iter_swap(__i, __first + __rand((__i - __first) + 1));
> }
># 5274 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Predicate>
> inline _ForwardIterator
> partition(_ForwardIterator __first, _ForwardIterator __last,
> _Predicate __pred)
> {
>
> 
>
> 
>
> ;
>
> return std::__partition(__first, __last, __pred,
> std::__iterator_category(__first));
> }
># 5308 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> std::__heap_select(__first, __middle, __last);
> std::sort_heap(__first, __middle);
> }
># 5347 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> partial_sort(_RandomAccessIterator __first,
> _RandomAccessIterator __middle,
> _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
> ;
>
> std::__heap_select(__first, __middle, __last, __comp);
> std::sort_heap(__first, __middle, __comp);
> }
># 5384 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
> ;
>
> if (__first == __last || __nth == __last)
> return;
>
> std::__introselect(__first, __nth, __last,
> std::__lg(__last - __first) * 2);
> }
># 5423 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
> _RandomAccessIterator __last, _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
> ;
>
> if (__first == __last || __nth == __last)
> return;
>
> std::__introselect(__first, __nth, __last,
> std::__lg(__last - __first) * 2, __comp);
> }
># 5461 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
> ;
>
> if (__first != __last)
> {
> std::__introsort_loop(__first, __last,
> std::__lg(__last - __first) * 2);
> std::__final_insertion_sort(__first, __last);
> }
> }
># 5497 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> inline void
> sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
> _Compare __comp)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
>
>
> 
>
> 
>
> ;
>
> if (__first != __last)
> {
> std::__introsort_loop(__first, __last,
> std::__lg(__last - __first) * 2, __comp);
> std::__final_insertion_sort(__first, __last, __comp);
> }
> }
># 5539 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 5603 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> merge(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> ;
> ;
>
> 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));
> }
># 5663 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator>
> inline void
> stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
> {
> typedef typename iterator_traits<_RandomAccessIterator>::value_type
> _ValueType;
> typedef typename iterator_traits<_RandomAccessIterator>::difference_type
> _DistanceType;
>
>
> 
>
> 
> ;
>
> _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
> __last);
> if (__buf.begin() == 0)
> std::__inplace_stable_sort(__first, __last);
> else
> std::__stable_sort_adaptive(__first, __last, __buf.begin(),
> _DistanceType(__buf.size()));
> }
># 5705 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _RandomAccessIterator, typename _Compare>
> 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;
>
>
> 
>
> 
>
>
> ;
>
> _Temporary_buffer<_RandomAccessIterator, _ValueType> __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);
> }
># 5751 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> {
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> }
> else if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> }
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> }
> ++__result;
> }
> return std::copy(__first2, __last2, std::copy(__first1, __last1,
> __result));
> }
># 5818 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_union(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> 
>
> ;
> ;
>
> 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));
> }
># 5885 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> ++__first1;
> else if (*__first2 < *__first1)
> ++__first2;
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> ++__result;
> }
> return __result;
> }
># 5942 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (__comp(*__first1, *__first2))
> ++__first1;
> else if (__comp(*__first2, *__first1))
> ++__first2;
> else
> {
> *__result = *__first1;
> ++__first1;
> ++__first2;
> ++__result;
> }
> return __result;
> }
># 6000 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (*__first2 < *__first1)
> ++__first2;
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first1, __last1, __result);
> }
># 6061 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result, _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> ;
> ;
>
> 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);
> }
># 6119 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator>
> _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
> 
> ;
> ;
>
> while (__first1 != __last1 && __first2 != __last2)
> if (*__first1 < *__first2)
> {
> *__result = *__first1;
> ++__first1;
> ++__result;
> }
> else if (*__first2 < *__first1)
> {
> *__result = *__first2;
> ++__first2;
> ++__result;
> }
> else
> {
> ++__first1;
> ++__first2;
> }
> return std::copy(__first2, __last2, std::copy(__first1,
> __last1, __result));
> }
># 6185 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _InputIterator1, typename _InputIterator2,
> typename _OutputIterator, typename _Compare>
> _OutputIterator
> set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
> _InputIterator2 __first2, _InputIterator2 __last2,
> _OutputIterator __result,
> _Compare __comp)
> {
> typedef typename iterator_traits<_InputIterator1>::value_type
> _ValueType1;
> typedef typename iterator_traits<_InputIterator2>::value_type
> _ValueType2;
>
>
> 
> 
> 
>
> 
>
> 
>
> 
>
> ;
> ;
>
> 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));
> }
># 6242 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> min_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (*__first < *__result)
> __result = __first;
> return __result;
> }
># 6270 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _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;
> }
># 6298 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator>
> _ForwardIterator
> max_element(_ForwardIterator __first, _ForwardIterator __last)
> {
>
> 
> 
>
> ;
>
> if (__first == __last)
> return __first;
> _ForwardIterator __result = __first;
> while (++__first != __last)
> if (*__result < *__first)
> __result = __first;
> return __result;
> }
># 6326 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_algo.h" 3
> template<typename _ForwardIterator, typename _Compare>
> _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;
> }
>
>
>}
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/algorithm" 2 3
># 77 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
># 179 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>
>
>
>
>
>
>
>
>
>typedef signed char qint8;
>typedef unsigned char quint8;
>typedef short qint16;
>typedef unsigned short quint16;
>typedef int qint32;
>typedef unsigned int quint32;
># 202 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>typedef long long qint64;
>typedef unsigned long long quint64;
>
>
>typedef qint64 qlonglong;
>typedef quint64 qulonglong;
># 229 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>namespace QtPrivate {
> template <class T>
> struct AlignOfHelper
> {
> char c;
> T type;
>
> AlignOfHelper();
> ~AlignOfHelper();
> };
>
> template <class T>
> struct AlignOf_Default
> {
> enum { Value = sizeof(AlignOfHelper<T>) - sizeof(T) };
> };
>
> template <class T> struct AlignOf : AlignOf_Default<T> { };
> template <class T> struct AlignOf<T &> : AlignOf<T> {};
> template <size_t N, class T> struct AlignOf<T[N]> : AlignOf<T> {};
>
>
> template <class T> struct AlignOf<T &&> : AlignOf<T> {};
># 269 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>}
># 285 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>template <int> 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 <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
>typedef QIntegerForSizeof<void*>::Unsigned quintptr;
>typedef QIntegerForSizeof<void*>::Signed qptrdiff;
>typedef qptrdiff qintptr;
>
>
>
>
>
>
>typedef unsigned char uchar;
>typedef unsigned short ushort;
>typedef unsigned int uint;
>typedef unsigned long ulong;
>
># 396 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>typedef int QNoImplicitBoolCast;
>
>
>
>
>
>
>
>typedef double qreal;
>
>
>
>
>
>
>template <typename T>
>constexpr inline T qAbs(const T &t) { return t >= 0 ? t : -t; }
>
>constexpr inline int qRound(double d)
>{ return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); }
>constexpr inline int qRound(float d)
>{ return d >= 0.0f ? int(d + 0.5f) : int(d - int(d-1) + 0.5f) + int(d-1); }
>
>
>
>
>
>
>
>constexpr inline qint64 qRound64(double d)
>{ return d >= 0.0 ? qint64(d + 0.5) : qint64(d - double(qint64(d-1)) + 0.5) + qint64(d-1); }
>constexpr inline qint64 qRound64(float d)
>{ return d >= 0.0f ? qint64(d + 0.5f) : qint64(d - float(qint64(d-1)) + 0.5f) + qint64(d-1); }
>
>
>
>
>
>
>
>template <typename T>
>constexpr inline const T &qMin(const T &a, const T &b) { return (a < b) ? a : b; }
>template <typename T>
>constexpr inline const T &qMax(const T &a, const T &b) { return (a < b) ? b : a; }
>template <typename T>
>constexpr inline const T &qBound(const T &min, const T &val, const T &max)
>{ return qMax(min, qMin(max, val)); }
>
>
>
>
>
>class QDataStream;
># 457 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qfeatures.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qfeatures.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qfeatures.h" 2
># 458 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
># 612 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>inline void qt_noop(void) {}
># 640 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>__attribute__((visibility("default"))) const char *qVersion();
>__attribute__((visibility("default"))) bool qSharedBuild();
># 674 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>class QString;
>__attribute__((visibility("default"))) QString qt_error_string(int errorCode = -1);
>
>
>__attribute__((__noreturn__))
>
>__attribute__((visibility("default"))) void qt_assert(const char *assertion, const char *file, int line);
># 695 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>__attribute__((__noreturn__))
>
>__attribute__((visibility("default"))) void qt_assert_x(const char *where, const char *what, const char *file, int line);
># 723 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>__attribute__((visibility("default"))) void qt_check_pointer(const char *, int);
>__attribute__((visibility("default"))) void qBadAlloc();
># 736 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>template <typename T>
>inline T *q_check_ptr(T *p) { do { if (!(p)) qBadAlloc(); } while (0); return p; }
>
>typedef void (*QFunctionPointer)();
>
>
>
>
>
>constexpr static inline bool qFuzzyCompare(double p1, double p2)
>{
> return (qAbs(p1 - p2) <= 0.000000000001 * qMin(qAbs(p1), qAbs(p2)));
>}
>
>constexpr static inline bool qFuzzyCompare(float p1, float p2)
>{
> return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
>}
>
>
>
>
>constexpr static inline bool qFuzzyIsNull(double d)
>{
> return qAbs(d) <= 0.000000000001;
>}
>
>
>
>
>constexpr 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;
>}
># 823 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>template <typename T>
>inline void qSwap(T &value1, T &value2)
>{
> using std::swap;
> swap(value1, value2);
>}
>
>
>__attribute__((visibility("default"))) void *qMalloc(size_t size) __attribute__((alloc_size(1)));
>__attribute__((visibility("default"))) void qFree(void *ptr);
>__attribute__((visibility("default"))) void *qRealloc(void *ptr, size_t size) __attribute__((alloc_size(2)));
>__attribute__((visibility("default"))) void *qMemCopy(void *dest, const void *src, size_t n);
>__attribute__((visibility("default"))) void *qMemSet(void *dest, int c, size_t n);
>
>__attribute__((visibility("default"))) void *qMallocAligned(size_t size, size_t alignment) __attribute__((alloc_size(1)));
>__attribute__((visibility("default"))) void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment) __attribute__((alloc_size(2)));
>__attribute__((visibility("default"))) void qFreeAligned(void *ptr);
># 878 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>template <typename T>
>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;
>};
># 949 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>template <typename T> static inline T *qGetPtrHelper(T *ptr) { return ptr; }
>template <typename Wrapper> static inline typename Wrapper::pointer qGetPtrHelper(const Wrapper &p) { return p.data(); }
># 982 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>__attribute__((visibility("default"))) QString qtTrId(const char *id, int n = -1);
># 1012 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>class QByteArray;
>__attribute__((visibility("default"))) QByteArray qgetenv(const char *varName);
>__attribute__((visibility("default"))) bool qputenv(const char *varName, const QByteArray& value);
>
>inline int qIntCast(double f) { return int(f); }
>inline int qIntCast(float f) { return int(f); }
>
>
>
>
>__attribute__((visibility("default"))) void qsrand(uint seed);
>__attribute__((visibility("default"))) int qrand();
># 1043 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h"
>namespace QtPrivate {
>
>template <bool B, typename T = void> struct QEnableIf;
>template <typename T> struct QEnableIf<true, T> { typedef T Type; };
>}
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobalstatic.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobalstatic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 1
># 42 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 2
># 43 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 2
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qbasicatomic.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qbasicatomic.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qbasicatomic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qbasicatomic.h" 2
># 84 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qbasicatomic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic_x86.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/arch/qatomic_x86.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/arch/qatomic_x86.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qgenericatomic.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qgenericatomic.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qgenericatomic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qgenericatomic.h" 2
>
>
>
># 65 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qgenericatomic.h"
>template<typename T> struct QAtomicIntegerTraits { enum { IsInteger = 0 }; };
>
>template <typename T> struct QAtomicAdditiveType
>{
> typedef T AdditiveT;
> static const int AddScale = 1;
>};
>template <typename T> struct QAtomicAdditiveType<T *>
>{
> typedef qptrdiff AdditiveT;
> static const int AddScale = sizeof(T);
>};
>
>
>template <typename BaseClass> struct QGenericAtomicOps
>{
> template <typename T> struct AtomicType { typedef T Type; typedef T *PointerType; };
>
> static void acquireMemoryFence() { BaseClass::orderedMemoryFence(); }
> static void releaseMemoryFence() { BaseClass::orderedMemoryFence(); }
> static void orderedMemoryFence() { }
>
> template <typename T> static inline __attribute__((always_inline, gnu_inline))
> T load(const T &_q_value)
> {
> return _q_value;
> }
>
> template <typename T, typename X> static inline __attribute__((always_inline, gnu_inline))
> void store(T &_q_value, X newValue)
> {
> _q_value = newValue;
> }
>
> template <typename T> static inline __attribute__((always_inline, gnu_inline))
> T loadAcquire(const T &_q_value)
> {
> T tmp = *static_cast<const volatile T *>(&_q_value);
> BaseClass::acquireMemoryFence();
> return tmp;
> }
>
> template <typename T, typename X> static inline __attribute__((always_inline, gnu_inline))
> void storeRelease(T &_q_value, X newValue)
> {
> BaseClass::releaseMemoryFence();
> *static_cast<volatile T *>(&_q_value) = newValue;
> }
>
> static inline bool isReferenceCountingNative()
> { return BaseClass::isFetchAndAddNative(); }
> static inline bool isReferenceCountingWaitFree()
> { return BaseClass::isFetchAndAddWaitFree(); }
> template <typename T> static inline __attribute__((always_inline, gnu_inline))
> bool ref(T &_q_value)
> {
> return BaseClass::fetchAndAddRelaxed(_q_value, 1) != T(-1);
> }
>
> template <typename T> static inline __attribute__((always_inline, gnu_inline))
> bool deref(T &_q_value)
> {
> return BaseClass::fetchAndAddRelaxed(_q_value, -1) != 1;
> }
># 139 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qgenericatomic.h"
> template <typename T, typename X> static inline __attribute__((always_inline, gnu_inline))
> bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue)
> {
> bool tmp = BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
> BaseClass::acquireMemoryFence();
> return tmp;
> }
>
> template <typename T, typename X> static inline __attribute__((always_inline, gnu_inline))
> bool testAndSetRelease(T &_q_value, X expectedValue, X newValue)
> {
> BaseClass::releaseMemoryFence();
> return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
> }
>
> template <typename T, typename X> static inline __attribute__((always_inline, gnu_inline))
> bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue)
> {
> BaseClass::orderedMemoryFence();
> return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
> }
>
> static inline bool isFetchAndStoreNative() { return false; }
> static inline bool isFetchAndStoreWaitFree() { return false; }
>
> template <typename T, typename X> static inline __attribute__((always_inline, gnu_inline))
> T fetchAndStoreRelaxed(T &_q_value, X newValue)
> {
>
> for(;;) {
> register T tmp = load(_q_value);
> if (BaseClass::testAndSetRelaxed(_q_value, tmp, newValue))
> return tmp;
> }
> }
>
> template <typename T, typename X> static inline __attribute__((always_inline, gnu_inline))
> T fetchAndStoreAcquire(T &_q_value, X newValue)
> {
> T tmp = BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
> BaseClass::acquireMemoryFence();
> return tmp;
> }
>
> template <typename T, typename X> static inline __attribute__((always_inline, gnu_inline))
> T fetchAndStoreRelease(T &_q_value, X newValue)
> {
> BaseClass::releaseMemoryFence();
> return BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
> }
>
> template <typename T, typename X> static inline __attribute__((always_inline, gnu_inline))
> T fetchAndStoreOrdered(T &_q_value, X newValue)
> {
> BaseClass::orderedMemoryFence();
> return BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
> }
>
> static inline bool isFetchAndAddNative() { return false; }
> static inline bool isFetchAndAddWaitFree() { return false; }
> template <typename T> static inline __attribute__((always_inline, gnu_inline))
> T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd)
> {
>
> for(;;) {
> register T tmp = BaseClass::load(_q_value);
> if (BaseClass::testAndSetRelaxed(_q_value, tmp, T(tmp + valueToAdd)))
> return tmp;
> }
> }
>
> template <typename T> static inline __attribute__((always_inline, gnu_inline))
> T fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd)
> {
> T tmp = BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
> BaseClass::acquireMemoryFence();
> return tmp;
> }
>
> template <typename T> static inline __attribute__((always_inline, gnu_inline))
> T fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd)
> {
> BaseClass::releaseMemoryFence();
> return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
> }
>
> template <typename T> static inline __attribute__((always_inline, gnu_inline))
> T fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd)
> {
> BaseClass::orderedMemoryFence();
> return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
> }
>};
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qgenericatomic.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/arch/qatomic_x86.h" 2
>
>
>
>
># 95 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/arch/qatomic_x86.h"
>template<> struct QAtomicIntegerTraits<int> { enum { IsInteger = 1 }; };
>template<> struct QAtomicIntegerTraits<unsigned int> { enum { IsInteger = 1 }; };
>
>template <int size> struct QBasicAtomicOps: QGenericAtomicOps<QBasicAtomicOps<size> >
>{
> static inline bool isReferenceCountingNative() { return true; }
> static inline bool isReferenceCountingWaitFree() { return true; }
> template <typename T> static bool ref(T &_q_value);
> template <typename T> static bool deref(T &_q_value);
>
> static inline bool isTestAndSetNative() { return true; }
> static inline bool isTestAndSetWaitFree() { return true; }
> template <typename T> static bool testAndSetRelaxed(T &_q_value, T expectedValue, T newValue);
>
> static inline bool isFetchAndStoreNative() { return true; }
> static inline bool isFetchAndStoreWaitFree() { return true; }
> template <typename T> static T fetchAndStoreRelaxed(T &_q_value, T newValue);
>
> static inline bool isFetchAndAddNative() { return true; }
> static inline bool isFetchAndAddWaitFree() { return true; }
> template <typename T> static
> T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd);
>};
>
>template <typename T> struct QAtomicOps : QBasicAtomicOps<sizeof(T)>
>{
> typedef T Type;
>};
>
>
>
>template<> struct QAtomicIntegerTraits<char> { enum { IsInteger = 1 }; };
>template<> struct QAtomicIntegerTraits<signed char> { enum { IsInteger = 1 }; };
>template<> struct QAtomicIntegerTraits<unsigned char> { enum { IsInteger = 1 }; };
>template<> struct QAtomicIntegerTraits<short> { enum { IsInteger = 1 }; };
>template<> struct QAtomicIntegerTraits<unsigned short> { enum { IsInteger = 1 }; };
>template<> struct QAtomicIntegerTraits<long> { enum { IsInteger = 1 }; };
>template<> struct QAtomicIntegerTraits<unsigned long> { enum { IsInteger = 1 }; };
>template<> struct QAtomicIntegerTraits<long long> { enum { IsInteger = 1 }; };
>template<> struct QAtomicIntegerTraits<unsigned long long> { enum { IsInteger = 1 }; };
># 164 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/arch/qatomic_x86.h"
>template<> template<typename T> inline
>bool QBasicAtomicOps<1>::ref(T &_q_value)
>{
> unsigned char ret;
> asm volatile("lock\n"
> "addb $1, %0\n"
> "setne %1"
> : "=m" (_q_value), "=qm" (ret)
> : "m" (_q_value)
> : "memory");
> return ret != 0;
>}
>
>template<> template<typename T> inline
>bool QBasicAtomicOps<2>::ref(T &_q_value)
>{
> unsigned char ret;
> asm volatile("lock\n"
> "incw %0\n"
> "setne %1"
> : "=m" (_q_value), "=qm" (ret)
> : "m" (_q_value)
> : "memory");
> return ret != 0;
>}
>
>template<> template<typename T> inline
>bool QBasicAtomicOps<4>::ref(T &_q_value)
>{
>
>
> asm volatile("lock; addl $1, %0" : "+m" (_q_value) : : "memory");
> asm goto("jz %l[zero]" : : : : zero);
> return true;
>zero:
> return false;
># 210 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/arch/qatomic_x86.h"
>}
>
>template<> template <typename T> inline
>bool QBasicAtomicOps<1>::deref(T &_q_value)
>{
> unsigned char ret;
> asm volatile("lock\n"
> "subb $1, %0\n"
> "setne %1"
> : "=m" (_q_value), "=qm" (ret)
> : "m" (_q_value)
> : "memory");
> return ret != 0;
>}
>
>template<> template <typename T> inline
>bool QBasicAtomicOps<2>::deref(T &_q_value)
>{
> unsigned char ret;
> asm volatile("lock\n"
> "decw %0\n"
> "setne %1"
> : "=m" (_q_value), "=qm" (ret)
> : "m" (_q_value)
> : "memory");
> return ret != 0;
>}
>
>template<> template <typename T> inline
>bool QBasicAtomicOps<4>::deref(T &_q_value)
>{
>
>
> asm volatile("lock; subl $1, %0" : "+m" (_q_value) : : "memory");
> asm goto("jz %l[zero]" : : : : zero);
> return true;
>zero:
> return false;
># 258 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/arch/qatomic_x86.h"
>}
>
>template<int size> template <typename T> inline
>bool QBasicAtomicOps<size>::testAndSetRelaxed(T &_q_value, 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<> template <typename T> inline
>bool QBasicAtomicOps<1>::testAndSetRelaxed(T &_q_value, 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)
> : "q" (newValue), "0" (expectedValue)
> : "memory");
> return ret != 0;
>}
>
>template<int size> template <typename T> inline
>T QBasicAtomicOps<size>::fetchAndStoreRelaxed(T &_q_value, T newValue)
>{
> asm volatile("xchg %0,%1"
> : "=r" (newValue), "+m" (_q_value)
> : "0" (newValue)
> : "memory");
> return newValue;
>}
>
>template<> template <typename T> inline
>T QBasicAtomicOps<1>::fetchAndStoreRelaxed(T &_q_value, T newValue)
>{
> asm volatile("xchg %0,%1"
> : "=q" (newValue), "+m" (_q_value)
> : "0" (newValue)
> : "memory");
> return newValue;
>}
>
>template<int size> template <typename T> inline
>T QBasicAtomicOps<size>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd)
>{
> T result;
> asm volatile("lock\n"
> "xadd %0,%1"
> : "=r" (result), "+m" (_q_value)
> : "0" (T(valueToAdd * QAtomicAdditiveType<T>::AddScale))
> : "memory");
> return result;
>}
>
>template<> template <typename T> inline
>T QBasicAtomicOps<1>::fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd)
>{
> T result;
> asm volatile("lock\n"
> "xadd %0,%1"
> : "=q" (result), "+m" (_q_value)
> : "0" (T(valueToAdd * QAtomicAdditiveType<T>::AddScale))
> : "memory");
> return result;
>}
># 374 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/arch/qatomic_x86.h"
>template<> template<typename T> inline
>bool QBasicAtomicOps<8>::ref(T &_q_value)
>{
> unsigned char ret;
> asm volatile("lock\n"
> "addq $1, %0\n"
> "setne %1"
> : "=m" (_q_value), "=qm" (ret)
> : "m" (_q_value)
> : "memory");
> return ret != 0;
>}
>
>template<> template <typename T> inline
>bool QBasicAtomicOps<8>::deref(T &_q_value)
>{
> unsigned char ret;
> asm volatile("lock\n"
> "subq $1, %0\n"
> "setne %1"
> : "=m" (_q_value), "=qm" (ret)
> : "m" (_q_value)
> : "memory");
> return ret != 0;
>}
># 437 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/arch/qatomic_x86.h"
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic_x86.h" 2
># 85 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qbasicatomic.h" 2
># 104 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qbasicatomic.h"
>
>
>
>
>
>
>
>
>template <typename T>
>class QBasicAtomicInteger
>{
>public:
> typedef QAtomicOps<T> Ops;
>
> typedef char PermittedIntegerType[QAtomicIntegerTraits<T>::IsInteger ? 1 : -1];
>
> typename Ops::Type _q_value;
>
>
> T load() const { return Ops::load(_q_value); }
> void store(T newValue) { Ops::store(_q_value, newValue); }
>
>
>
> T loadAcquire() const { return Ops::loadAcquire(_q_value); }
> void storeRelease(T newValue) { Ops::storeRelease(_q_value, newValue); }
>
> static bool isReferenceCountingNative() { return Ops::isReferenceCountingNative(); }
> static bool isReferenceCountingWaitFree() { return Ops::isReferenceCountingWaitFree(); }
>
> bool ref() { return Ops::ref(_q_value); }
> bool deref() { return Ops::deref(_q_value); }
>
> static bool isTestAndSetNative() { return Ops::isTestAndSetNative(); }
> static bool isTestAndSetWaitFree() { return Ops::isTestAndSetWaitFree(); }
>
> bool testAndSetRelaxed(T expectedValue, T newValue)
> { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue); }
> bool testAndSetAcquire(T expectedValue, T newValue)
> { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue); }
> bool testAndSetRelease(T expectedValue, T newValue)
> { return Ops::testAndSetRelease(_q_value, expectedValue, newValue); }
> bool testAndSetOrdered(T expectedValue, T newValue)
> { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue); }
>
> static bool isFetchAndStoreNative() { return Ops::isFetchAndStoreNative(); }
> static bool isFetchAndStoreWaitFree() { return Ops::isFetchAndStoreWaitFree(); }
>
> T fetchAndStoreRelaxed(T newValue)
> { return Ops::fetchAndStoreRelaxed(_q_value, newValue); }
> T fetchAndStoreAcquire(T newValue)
> { return Ops::fetchAndStoreAcquire(_q_value, newValue); }
> T fetchAndStoreRelease(T newValue)
> { return Ops::fetchAndStoreRelease(_q_value, newValue); }
> T fetchAndStoreOrdered(T newValue)
> { return Ops::fetchAndStoreOrdered(_q_value, newValue); }
>
> static bool isFetchAndAddNative() { return Ops::isFetchAndAddNative(); }
> static bool isFetchAndAddWaitFree() { return Ops::isFetchAndAddWaitFree(); }
>
> T fetchAndAddRelaxed(T valueToAdd)
> { return Ops::fetchAndAddRelaxed(_q_value, valueToAdd); }
> T fetchAndAddAcquire(T valueToAdd)
> { return Ops::fetchAndAddAcquire(_q_value, valueToAdd); }
> T fetchAndAddRelease(T valueToAdd)
> { return Ops::fetchAndAddRelease(_q_value, valueToAdd); }
> T fetchAndAddOrdered(T valueToAdd)
> { return Ops::fetchAndAddOrdered(_q_value, valueToAdd); }
>
>
> QBasicAtomicInteger() = default;
> constexpr QBasicAtomicInteger(T value) : _q_value(value) {}
> QBasicAtomicInteger(const QBasicAtomicInteger &) = delete;
> QBasicAtomicInteger &operator=(const QBasicAtomicInteger &) = delete;
> QBasicAtomicInteger &operator=(const QBasicAtomicInteger &) volatile = delete;
>
>};
>typedef QBasicAtomicInteger<int> QBasicAtomicInt;
>
>template <typename X>
>class QBasicAtomicPointer
>{
>public:
> typedef X *Type;
> typedef QAtomicOps<Type> Ops;
> typedef typename Ops::Type AtomicType;
>
> AtomicType _q_value;
>
>
> Type load() const { return _q_value; }
> void store(Type newValue) { _q_value = newValue; }
>
>
> Type loadAcquire() const { return Ops::loadAcquire(_q_value); }
> void storeRelease(Type newValue) { Ops::storeRelease(_q_value, newValue); }
>
> static bool isTestAndSetNative() { return Ops::isTestAndSetNative(); }
> static bool isTestAndSetWaitFree() { return Ops::isTestAndSetWaitFree(); }
>
> bool testAndSetRelaxed(Type expectedValue, Type newValue)
> { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue); }
> bool testAndSetAcquire(Type expectedValue, Type newValue)
> { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue); }
> bool testAndSetRelease(Type expectedValue, Type newValue)
> { return Ops::testAndSetRelease(_q_value, expectedValue, newValue); }
> bool testAndSetOrdered(Type expectedValue, Type newValue)
> { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue); }
>
> static bool isFetchAndStoreNative() { return Ops::isFetchAndStoreNative(); }
> static bool isFetchAndStoreWaitFree() { return Ops::isFetchAndStoreWaitFree(); }
>
> Type fetchAndStoreRelaxed(Type newValue)
> { return Ops::fetchAndStoreRelaxed(_q_value, newValue); }
> Type fetchAndStoreAcquire(Type newValue)
> { return Ops::fetchAndStoreAcquire(_q_value, newValue); }
> Type fetchAndStoreRelease(Type newValue)
> { return Ops::fetchAndStoreRelease(_q_value, newValue); }
> Type fetchAndStoreOrdered(Type newValue)
> { return Ops::fetchAndStoreOrdered(_q_value, newValue); }
>
> static bool isFetchAndAddNative() { return Ops::isFetchAndAddNative(); }
> static bool isFetchAndAddWaitFree() { return Ops::isFetchAndAddWaitFree(); }
>
> Type fetchAndAddRelaxed(qptrdiff valueToAdd)
> { return Ops::fetchAndAddRelaxed(_q_value, valueToAdd); }
> Type fetchAndAddAcquire(qptrdiff valueToAdd)
> { return Ops::fetchAndAddAcquire(_q_value, valueToAdd); }
> Type fetchAndAddRelease(qptrdiff valueToAdd)
> { return Ops::fetchAndAddRelease(_q_value, valueToAdd); }
> Type fetchAndAddOrdered(qptrdiff valueToAdd)
> { return Ops::fetchAndAddOrdered(_q_value, valueToAdd); }
>
>
> QBasicAtomicPointer() = default;
> constexpr QBasicAtomicPointer(Type value) : _q_value(value) {}
> QBasicAtomicPointer(const QBasicAtomicPointer &) = delete;
> QBasicAtomicPointer &operator=(const QBasicAtomicPointer &) = delete;
> QBasicAtomicPointer &operator=(const QBasicAtomicPointer &) volatile = delete;
>
>};
>
>
>
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qbasicatomic.h" 2
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 2
>
>
>
>
>
>
>
>#pragma GCC diagnostic push
>#pragma GCC diagnostic ignored "-Wextra"
>
>
>
>class __attribute__((visibility("default"))) QAtomicInt : public QBasicAtomicInt
>{
>public:
>
> inline QAtomicInt(int value = 0)
> {
> _q_value = value;
> }
>
> inline QAtomicInt(const QAtomicInt &other)
> {
> store(other.load());
> }
>
> inline QAtomicInt &operator=(const QAtomicInt &other)
> {
> this->store(other.load());
> return *this;
> }
># 111 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
>};
>
>
>template <typename T>
>class QAtomicPointer : public QBasicAtomicPointer<T>
>{
>public:
> inline QAtomicPointer(T *value = 0)
> {
> this->store(value);
> }
> inline QAtomicPointer(const QAtomicPointer<T> &other)
> {
> this->store(other.load());
> }
>
> inline QAtomicPointer<T> &operator=(const QAtomicPointer<T> &other)
> {
> this->store(other.load());
> return *this;
> }
># 158 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
>};
>
>
>#pragma GCC diagnostic pop
># 170 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
>template <typename T>
>inline void qAtomicAssign(T *&d, T *x)
>{
> if (d == x)
> return;
> x->ref.ref();
> if (!d->ref.deref())
> delete d;
> d = x;
>}
># 189 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
>template <typename T>
>inline void qAtomicDetach(T *&d)
>{
> if (d->ref.load() == 1)
> return;
> T *x = d;
> d = new T(*d);
> if (!x->ref.deref())
> delete x;
>}
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobalstatic.h" 2
>
>
>
>
>class QGlobalStaticControl
>{
> QBasicAtomicInt *guard;
> static __attribute__((visibility("default"))) bool startInternal(QBasicAtomicInt *guard);
> static __attribute__((visibility("default"))) void abandonInternal(QBasicAtomicInt *guard);
> static __attribute__((visibility("default"))) void completedInternal(QBasicAtomicInt *guard);
>
>public:
> QGlobalStaticControl(QBasicAtomicInt *g) : guard(g) {}
> ~QGlobalStaticControl() { if (guard) abandonInternal(guard); }
> bool start()
> {
> if (startInternal(guard))
> return true;
>
>
> guard = 0;
> return false;
> }
> void completed()
> {
> completedInternal(guard);
> guard = 0;
> }
>};
># 119 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobalstatic.h"
>template <typename T, T *(&innerFunction)(), QBasicAtomicInt &guard>
>struct QGlobalStatic
>{
> typedef T Type;
>
> bool isDestroyed() const { return guard.load() < -1; }
> bool exists() const { return guard.load() == -1; }
> operator Type *() { if (isDestroyed()) return 0; return innerFunction(); }
> Type *operator()() { if (isDestroyed()) return 0; return innerFunction(); }
> Type *operator->() { return innerFunction(); }
> Type &operator*() { return *innerFunction(); }
>};
># 145 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobalstatic.h"
>
>
># 1054 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qlogging.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qlogging.h" 1
># 42 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qlogging.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 43 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qlogging.h" 2
># 52 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qlogging.h"
>
>
>
>
>
>
>
>
>class QDebug;
>class QNoDebug;
>
>enum QtMsgType { QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg = QtCriticalMsg };
>
>class QMessageLogContext
>{
> QMessageLogContext(const QMessageLogContext &) = delete; QMessageLogContext &operator=(const QMessageLogContext &) = delete;
>public:
> QMessageLogContext() : version(1), line(0), file(0), function(0), category(0) {}
> constexpr QMessageLogContext(const char *fileName, int lineNumber, const char *functionName, const char *categoryName)
> : version(1), line(lineNumber), file(fileName), function(functionName), category(categoryName) {}
>
> void copy(const QMessageLogContext &logContext);
>
> int version;
> int line;
> const char *file;
> const char *function;
> const char *category;
>
>private:
> friend class QMessageLogger;
> friend class QDebug;
>};
>
>class __attribute__((visibility("default"))) QMessageLogger
>{
> QMessageLogger(const QMessageLogger &) = delete; QMessageLogger &operator=(const QMessageLogger &) = delete;
>public:
> QMessageLogger() : context() {}
> constexpr QMessageLogger(const char *file, int line, const char *function)
> : context(file, line, function, "default") {}
> constexpr QMessageLogger(const char *file, int line, const char *function, const char *category)
> : context(file, line, function, category) {}
>
> void debug(const char *msg, ...)
>
> __attribute__ ((format (printf, 2, 3)))
>
> ;
> void noDebug(const char *, ...)
>
> __attribute__ ((format (printf, 2, 3)))
>
> {}
> void warning(const char *msg, ...)
>
> __attribute__ ((format (printf, 2, 3)))
>
> ;
> void critical(const char *msg, ...)
>
> __attribute__ ((format (printf, 2, 3)))
>
> ;
>
>
> __attribute__((__noreturn__))
>
> void fatal(const char *msg, ...)
>
> __attribute__ ((format (printf, 2, 3)))
>
> ;
>
>
> QDebug debug();
> QDebug warning();
> QDebug critical();
>
> QNoDebug noDebug();
>
>
>private:
> QMessageLogContext context;
>};
># 158 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qlogging.h"
>__attribute__((visibility("default"))) void qt_message_output(QtMsgType, const QMessageLogContext &context,
> const QString &message);
>
>__attribute__((visibility("default"))) void qErrnoWarning(int code, const char *msg, ...);
>__attribute__((visibility("default"))) void qErrnoWarning(const char *msg, ...);
>
>
>typedef void (*QtMsgHandler)(QtMsgType, const char *);
>__attribute__((visibility("default"))) QtMsgHandler qInstallMsgHandler(QtMsgHandler);
>
>typedef void (*QtMessageHandler)(QtMsgType, const QMessageLogContext &, const QString &);
>__attribute__((visibility("default"))) QtMessageHandler qInstallMessageHandler(QtMessageHandler);
>
>
>typedef void (*QMessageHandler)(QtMsgType, const QMessageLogContext &, const char *);
>__attribute__((visibility("default"))) QMessageHandler qInstallMessageHandler(QMessageHandler);
>
>__attribute__((visibility("default"))) void qSetMessagePattern(const QString &messagePattern);
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qlogging.h" 2
># 1057 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qflags.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qflags.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qflags.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qflags.h" 2
>
>
>
>
>
>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<typename Enum>
>class QFlags
>{
> typedef void **Zero;
> int i;
>public:
> typedef Enum enum_type;
>
>
>
>
>
> constexpr inline QFlags(Enum f) : i(f) {}
> constexpr inline QFlags(Zero = 0) : i(0) {}
> inline QFlags(QFlag f) : i(f) {}
>
> 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; }
>
> constexpr inline operator int() const { return i; }
>
> constexpr inline QFlags operator|(QFlags f) const { return QFlags(Enum(i | f.i)); }
> constexpr inline QFlags operator|(Enum f) const { return QFlags(Enum(i | f)); }
> constexpr inline QFlags operator^(QFlags f) const { return QFlags(Enum(i ^ f.i)); }
> constexpr inline QFlags operator^(Enum f) const { return QFlags(Enum(i ^ f)); }
> constexpr inline QFlags operator&(int mask) const { return QFlags(Enum(i & mask)); }
> constexpr inline QFlags operator&(uint mask) const { return QFlags(Enum(i & mask)); }
> constexpr inline QFlags operator&(Enum f) const { return QFlags(Enum(i & f)); }
> constexpr inline QFlags operator~() const { return QFlags(Enum(~i)); }
>
> constexpr inline bool operator!() const { return !i; }
>
> inline bool testFlag(Enum f) const { return (i & f) == f && (f != 0 || i == int(f) ); }
>};
># 135 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qflags.h"
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qflags.h" 2
># 1058 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qsysinfo.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qsysinfo.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qsysinfo.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qsysinfo.h" 2
>
>
>
>
>
>
>
>
>class QString;
>class __attribute__((visibility("default"))) QSysInfo {
>public:
> enum Sizes {
> WordSize = (sizeof(void *)<<3)
> };
># 69 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qsysinfo.h"
> enum Endian {
> BigEndian,
> LittleEndian
>
>
>
>
>
>
> , ByteOrder = LittleEndian
>
>
>
> };
># 151 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qsysinfo.h"
>};
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qsysinfo.h" 2
># 1059 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qtypeinfo.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qtypeinfo.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qtypeinfo.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qtypeinfo.h" 2
>
>
>
># 58 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qtypeinfo.h"
>template <typename T>
>class QTypeInfo
>{
>public:
> enum {
> isPointer = false,
> isComplex = true,
> isStatic = true,
> isLarge = (sizeof(T)>sizeof(void*)),
> isDummy = false,
> sizeOf = sizeof(T)
> };
>};
>
>template<>
>class QTypeInfo<void>
>{
>public:
> enum {
> isPointer = false,
> isComplex = false,
> isStatic = false,
> isLarge = false,
> isDummy = false,
> sizeOf = 0
> };
>};
>
>template <typename T>
>class QTypeInfo<T*>
>{
>public:
> enum {
> isPointer = true,
> isComplex = false,
> isStatic = false,
> isLarge = false,
> isDummy = false,
> sizeOf = sizeof(T*)
> };
>};
># 117 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qtypeinfo.h"
>template <typename T> class QList; template <typename T> class QTypeInfo< QList<T> > { public: enum { isPointer = false, isComplex = true, isStatic = false, isLarge = (sizeof(QList<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QList<T>) }; };
>template <typename T> class QVector; template <typename T> class QTypeInfo< QVector<T> > { public: enum { isPointer = false, isComplex = true, isStatic = false, isLarge = (sizeof(QVector<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QVector<T>) }; };
>template <typename T> class QQueue; template <typename T> class QTypeInfo< QQueue<T> > { public: enum { isPointer = false, isComplex = true, isStatic = false, isLarge = (sizeof(QQueue<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QQueue<T>) }; };
>template <typename T> class QStack; template <typename T> class QTypeInfo< QStack<T> > { public: enum { isPointer = false, isComplex = true, isStatic = false, isLarge = (sizeof(QStack<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QStack<T>) }; };
>template <typename T> class QLinkedList; template <typename T> class QTypeInfo< QLinkedList<T> > { public: enum { isPointer = false, isComplex = true, isStatic = false, isLarge = (sizeof(QLinkedList<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QLinkedList<T>) }; };
>template <typename T> class QSet; template <typename T> class QTypeInfo< QSet<T> > { public: enum { isPointer = false, isComplex = true, isStatic = false, isLarge = (sizeof(QSet<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QSet<T>) }; };
># 134 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qtypeinfo.h"
>enum {
> Q_COMPLEX_TYPE = 0,
> Q_PRIMITIVE_TYPE = 0x1,
> Q_STATIC_TYPE = 0,
> Q_MOVABLE_TYPE = 0x2,
> Q_DUMMY_TYPE = 0x4
>};
># 162 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qtypeinfo.h"
>template<typename T> class QFlags;
>template<typename T>
>class QTypeInfo<QFlags<T> > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QFlags<T>)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QFlags<T>) }; static inline const char *name() { return "QFlags<T>"; } };
># 191 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qtypeinfo.h"
>template<> class QTypeInfo<bool > { 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), sizeOf = sizeof(bool) }; static inline const char *name() { return "bool"; } };
>template<> class QTypeInfo<char > { 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), sizeOf = sizeof(char) }; static inline const char *name() { return "char"; } };
>template<> class QTypeInfo<signed char > { 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), sizeOf = sizeof(signed char) }; static inline const char *name() { return "signed char"; } };
>template<> class QTypeInfo<uchar > { 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), sizeOf = sizeof(uchar) }; static inline const char *name() { return "uchar"; } };
>template<> class QTypeInfo<short > { 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), sizeOf = sizeof(short) }; static inline const char *name() { return "short"; } };
>template<> class QTypeInfo<ushort > { 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), sizeOf = sizeof(ushort) }; static inline const char *name() { return "ushort"; } };
>template<> class QTypeInfo<int > { 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), sizeOf = sizeof(int) }; static inline const char *name() { return "int"; } };
>template<> class QTypeInfo<uint > { 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), sizeOf = sizeof(uint) }; static inline const char *name() { return "uint"; } };
>template<> class QTypeInfo<long > { 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), sizeOf = sizeof(long) }; static inline const char *name() { return "long"; } };
>template<> class QTypeInfo<ulong > { 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), sizeOf = sizeof(ulong) }; static inline const char *name() { return "ulong"; } };
>template<> class QTypeInfo<qint64 > { 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), sizeOf = sizeof(qint64) }; static inline const char *name() { return "qint64"; } };
>template<> class QTypeInfo<quint64 > { 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), sizeOf = sizeof(quint64) }; static inline const char *name() { return "quint64"; } };
>template<> class QTypeInfo<float > { 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), sizeOf = sizeof(float) }; static inline const char *name() { return "float"; } };
>template<> class QTypeInfo<double > { 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), sizeOf = sizeof(double) }; static inline const char *name() { return "double"; } };
>
>template<> class QTypeInfo<long double > { 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), sizeOf = sizeof(long double) }; static inline const char *name() { return "long double"; } };
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qtypeinfo.h" 2
># 1060 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qglobal.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 2
># 37 "../../../../../../src/qt/creator/src/libs/languageutils/languageutils_global.h" 2
># 37 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.h" 2
># 1 "../../../../../../src/qt/creator/src/libs/languageutils/componentversion.h" 1
># 38 "../../../../../../src/qt/creator/src/libs/languageutils/componentversion.h"
>namespace LanguageUtils {
>
>class __attribute__((visibility("protected"))) ComponentVersion
>{
> int _major;
> int _minor;
>
>public:
> static const int NoVersion;
> static const int MaxVersion;
>
> ComponentVersion();
> ComponentVersion(int major, int minor);
> explicit ComponentVersion(const QString &versionString);
> ~ComponentVersion();
>
> int majorVersion() const
> { return _major; }
> int minorVersion() const
> { return _minor; }
>
> bool isValid() const;
> QString toString() const;
>};
>
>bool __attribute__((visibility("protected"))) operator<(const ComponentVersion &lhs, const ComponentVersion &rhs);
>bool __attribute__((visibility("protected"))) operator<=(const ComponentVersion &lhs, const ComponentVersion &rhs);
>bool __attribute__((visibility("protected"))) operator>(const ComponentVersion &lhs, const ComponentVersion &rhs);
>bool __attribute__((visibility("protected"))) operator>=(const ComponentVersion &lhs, const ComponentVersion &rhs);
>bool __attribute__((visibility("protected"))) operator==(const ComponentVersion &lhs, const ComponentVersion &rhs);
>bool __attribute__((visibility("protected"))) operator!=(const ComponentVersion &lhs, const ComponentVersion &rhs);
>
>}
># 38 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.h" 2
>
># 1 "../../../../qt5/qtbase/include/QtCore/QString" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qstring.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qchar.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qchar.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qchar.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qchar.h" 2
>
>
>
>
>
>
>class QString;
>
>struct QLatin1Char
>{
>public:
> constexpr inline explicit QLatin1Char(char c) : ch(c) {}
> constexpr inline char toLatin1() const { return ch; }
> constexpr inline ushort unicode() const { return ushort(uchar(ch)); }
>
>private:
> char ch;
>};
>
>
>class __attribute__((visibility("default"))) QChar {
>public:
> enum SpecialCharacter {
> Null = 0x0000,
> Tabulation = 0x0009,
> LineFeed = 0x000a,
> CarriageReturn = 0x000d,
> Space = 0x0020,
> Nbsp = 0x00a0,
> ReplacementCharacter = 0xfffd,
> ObjectReplacementCharacter = 0xfffc,
> ByteOrderMark = 0xfeff,
> ByteOrderSwapped = 0xfffe,
> ParagraphSeparator = 0x2029,
> LineSeparator = 0x2028,
> LastValidCodePoint = 0x10ffff
> };
>
> constexpr QChar() : ucs(0) {}
> constexpr QChar(ushort rc) : ucs(rc){}
> constexpr QChar(uchar c, uchar r) : ucs(ushort((r << 8) | c)){}
> constexpr QChar(short rc) : ucs(ushort(rc)){}
> constexpr QChar(uint rc) : ucs(ushort(rc & 0xffff)){}
> constexpr QChar(int rc) : ucs(ushort(rc & 0xffff)){}
> constexpr QChar(SpecialCharacter s) : ucs(ushort(s)) {}
> constexpr QChar(QLatin1Char ch) : ucs(ch.unicode()) {}
>
>
> constexpr explicit QChar(char c) : ucs(uchar(c)) { }
> constexpr explicit QChar(uchar c) : ucs(c) { }
>
>
>
> enum Category
> {
> 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
> };
>
> 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
> };
>
>
> inline Category category() const { return QChar::category(ucs); }
> inline Direction direction() const { return QChar::direction(ucs); }
> inline Joining joining() const { return QChar::joining(ucs); }
> inline unsigned char combiningClass() const { return QChar::combiningClass(ucs); }
>
> inline QChar mirroredChar() const { return QChar::mirroredChar(ucs); }
> inline bool hasMirrored() const { return QChar::hasMirrored(ucs); }
>
> QString decomposition() const;
> inline Decomposition decompositionTag() const { return QChar::decompositionTag(ucs); }
>
> inline int digitValue() const { return QChar::digitValue(ucs); }
> inline QChar toLower() const { return QChar::toLower(ucs); }
> inline QChar toUpper() const { return QChar::toUpper(ucs); }
> inline QChar toTitleCase() const { return QChar::toTitleCase(ucs); }
> inline QChar toCaseFolded() const { return QChar::toCaseFolded(ucs); }
>
> inline UnicodeVersion unicodeVersion() const { return QChar::unicodeVersion(ucs); }
>
>
> inline char toAscii() const { return toLatin1(); }
>
> inline char toLatin1() const;
> inline ushort unicode() const { return ucs; }
> inline ushort &unicode() { return ucs; }
>
>
> static inline QChar fromAscii(char c)
> { return fromLatin1(c); }
>
> static inline QChar fromLatin1(char c);
>
> inline bool isNull() const { return ucs == 0; }
>
> inline bool isPrint() const { return QChar::isPrint(ucs); }
> inline bool isSpace() const { return QChar::isSpace(ucs); }
> inline bool isMark() const { return QChar::isMark(ucs); }
> inline bool isPunct() const { return QChar::isPunct(ucs); }
> inline bool isSymbol() const { return QChar::isSymbol(ucs); }
> inline bool isLetter() const { return QChar::isLetter(ucs); }
> inline bool isNumber() const { return QChar::isNumber(ucs); }
> inline bool isLetterOrNumber() const { return QChar::isLetterOrNumber(ucs); }
> inline bool isDigit() const { return QChar::isDigit(ucs); }
> inline bool isLower() const { return QChar::isLower(ucs); }
> inline bool isUpper() const { return QChar::isUpper(ucs); }
> inline bool isTitleCase() const { return QChar::isTitleCase(ucs); }
>
> inline bool isNonCharacter() const { return QChar::isNonCharacter(ucs); }
> inline bool isHighSurrogate() const { return QChar::isHighSurrogate(ucs); }
> inline bool isLowSurrogate() const { return QChar::isLowSurrogate(ucs); }
> inline bool isSurrogate() const { return QChar::isSurrogate(ucs); }
>
> 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 isNonCharacter(uint ucs4) {
> return ucs4 >= 0xfdd0 && (ucs4 <= 0xfdef || (ucs4 & 0xfffe) == 0xfffe);
> }
> static inline bool isHighSurrogate(uint ucs4) {
> return ((ucs4 & 0xfffffc00) == 0xd800);
> }
> static inline bool isLowSurrogate(uint ucs4) {
> return ((ucs4 & 0xfffffc00) == 0xdc00);
> }
> static inline bool isSurrogate(uint ucs4) {
> return (ucs4 - 0xd800u < 2048u);
> }
> 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 surrogateToUcs4(high.unicode(), low.unicode());
> }
> 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 Direction direction(uint ucs4);
> static Joining joining(uint ucs4);
> static unsigned char combiningClass(uint ucs4);
>
> static uint mirroredChar(uint ucs4);
> static bool hasMirrored(uint ucs4);
>
> static QString decomposition(uint ucs4);
> static Decomposition decompositionTag(uint ucs4);
>
> static int digitValue(uint ucs4);
> static uint toLower(uint ucs4);
> static uint toUpper(uint ucs4);
> static uint toTitleCase(uint ucs4);
> static uint toCaseFolded(uint ucs4);
>
> static UnicodeVersion unicodeVersion(uint ucs4);
>
> static UnicodeVersion currentUnicodeVersion();
>
> static bool isPrint(uint ucs4);
> static inline bool isSpace(uint ucs4);
> static bool isMark(uint ucs4);
> static bool isPunct(uint ucs4);
> static bool isSymbol(uint ucs4);
> static inline bool isLetter(uint ucs4);
> static inline bool isNumber(uint ucs4);
> static inline bool isLetterOrNumber(uint ucs4);
> static inline bool isDigit(uint ucs4);
> static inline bool isLower(uint ucs4);
> static inline bool isUpper(uint ucs4);
> static inline bool isTitleCase(uint ucs4);
>
>private:
> static bool isSpace_helper(uint ucs4);
> static bool isLetter_helper(uint ucs4);
> static bool isNumber_helper(uint ucs4);
> static bool isLetterOrNumber_helper(uint ucs4);
>
>
>
>
>
> ushort ucs;
>};
>
>template<> class QTypeInfo<QChar > { 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), sizeOf = sizeof(QChar) }; static inline const char *name() { return "QChar"; } };
>
>inline char QChar::toLatin1() const { return ucs > 0xff ? '\0' : char(ucs); }
>inline QChar QChar::fromLatin1(char c) { return QChar(ushort(uchar(c))); }
>
>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 QChar::isSpace(uint ucs4)
>{
>
> return ucs4 == 0x20 || (ucs4 <= 0x0d && ucs4 >= 0x09)
> || (ucs4 > 127 && (ucs4 == 0x85 || ucs4 == 0xa0 || QChar::isSpace_helper(ucs4)));
>}
>inline bool QChar::isLetter(uint ucs4)
>{
> return (ucs4 >= 'A' && ucs4 <= 'z' && (ucs4 >= 'a' || ucs4 <= 'Z'))
> || (ucs4 > 127 && QChar::isLetter_helper(ucs4));
>}
>inline bool QChar::isNumber(uint ucs4)
>{ return (ucs4 <= '9' && ucs4 >= '0') || (ucs4 > 127 && QChar::isNumber_helper(ucs4)); }
>inline bool QChar::isLetterOrNumber(uint ucs4)
>{
> return (ucs4 >= 'A' && ucs4 <= 'z' && (ucs4 >= 'a' || ucs4 <= 'Z'))
> || (ucs4 >= '0' && ucs4 <= '9')
> || (ucs4 > 127 && QChar::isLetterOrNumber_helper(ucs4));
>}
>inline bool QChar::isDigit(uint ucs4)
>{ return (ucs4 <= '9' && ucs4 >= '0') || (ucs4 > 127 && QChar::category(ucs4) == Number_DecimalDigit); }
>inline bool QChar::isLower(uint ucs4)
>{ return (ucs4 <= 'z' && ucs4 >= 'a') || (ucs4 > 127 && QChar::category(ucs4) == Letter_Lowercase); }
>inline bool QChar::isUpper(uint ucs4)
>{ return (ucs4 <= 'Z' && ucs4 >= 'A') || (ucs4 > 127 && QChar::category(ucs4) == Letter_Uppercase); }
>inline bool QChar::isTitleCase(uint ucs4)
>{ return ucs4 > 127 && QChar::category(ucs4) == Letter_Titlecase; }
>
>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(); }
>
>
>__attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, QChar);
>__attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QChar &);
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qchar.h" 2
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qbytearray.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qrefcount.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qrefcount.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qrefcount.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 1
># 42 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 43 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 2
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qrefcount.h" 2
>
>
>
>
>
>
>namespace QtPrivate
>{
>
>class RefCount
>{
>public:
> inline bool ref() {
> int count = atomic.load();
> if (count == 0)
> return false;
> if (count != -1)
> atomic.ref();
> return true;
> }
>
> inline bool deref() {
> int count = atomic.load();
> if (count == 0)
> return false;
> if (count == -1)
> return true;
> return atomic.deref();
> }
>
> bool setSharable(bool sharable)
> {
> ((!(!isShared())) ? qt_assert("!isShared()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qrefcount.h",78) : qt_noop());
> if (sharable)
> return atomic.testAndSetRelaxed(0, 1);
> else
> return atomic.testAndSetRelaxed(1, 0);
> }
>
> bool isStatic() const
> {
>
> return atomic.load() == -1;
> }
>
> bool isSharable() const
> {
>
> return atomic.load() != 0;
> }
>
> bool isShared() const
> {
> int count = atomic.load();
> return (count != 1) && (count != 0);
> }
>
> void initializeOwned() { atomic.store(1); }
> void initializeUnsharable() { atomic.store(0); }
>
> QBasicAtomicInt atomic;
>};
>
>}
>
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qrefcount.h" 2
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qnamespace.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qnamespace.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qnamespace.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qnamespace.h" 2
>
>
>
>
>
>
>
>namespace
>
>
>
>Qt {
># 106 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qnamespace.h"
> 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<KeyboardModifier> 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,
> BackButton = 0x00000008,
> XButton1 = BackButton,
> ExtraButton1 = XButton1,
> ForwardButton = 0x00000010,
> XButton2 = ForwardButton,
> ExtraButton2 = ForwardButton,
> TaskButton = 0x00000020,
> ExtraButton3 = TaskButton,
> ExtraButton4 = 0x00000040,
> ExtraButton5 = 0x00000080,
> ExtraButton6 = 0x00000100,
> ExtraButton7 = 0x00000200,
> ExtraButton8 = 0x00000400,
> ExtraButton9 = 0x00000800,
> ExtraButton10 = 0x00001000,
> ExtraButton11 = 0x00002000,
> ExtraButton12 = 0x00004000,
> ExtraButton13 = 0x00008000,
> ExtraButton14 = 0x00010000,
> ExtraButton15 = 0x00020000,
> ExtraButton16 = 0x00040000,
> ExtraButton17 = 0x00080000,
> ExtraButton18 = 0x00100000,
> ExtraButton19 = 0x00200000,
> ExtraButton20 = 0x00400000,
> ExtraButton21 = 0x00800000,
> ExtraButton22 = 0x01000000,
> ExtraButton23 = 0x02000000,
> ExtraButton24 = 0x04000000,
> AllButtons = 0x07ffffff,
> MaxMouseButton = ExtraButton24,
>
> MouseButtonMask = 0xffffffff
> };
> typedef QFlags<MouseButton> MouseButtons;
>
> enum Orientation {
> Horizontal = 0x1,
> Vertical = 0x2
> };
>
> typedef QFlags<Orientation> 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<AlignmentFlag> 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
> };
>
> enum TextElideMode {
> ElideLeft,
> ElideRight,
> ElideMiddle,
> ElideNone
> };
>
> enum WindowType {
> Widget = 0x00000000,
> Window = 0x00000001,
> Dialog = 0x00000002 | Window,
> Sheet = 0x00000004 | Window,
> Drawer = Sheet | Dialog,
> Popup = 0x00000008 | Window,
> Tool = Popup | Dialog,
> ToolTip = Popup | Sheet,
> SplashScreen = ToolTip | Dialog,
> 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,
> WindowTransparentForInput = 0x00080000,
> WindowOverridesSystemGestures = 0x00100000,
> WindowDoesNotAcceptFocus = 0x00200000,
>
> CustomizeWindowHint = 0x02000000,
> WindowStaysOnBottomHint = 0x04000000,
> WindowCloseButtonHint = 0x08000000,
> MacWindowToolBarButtonHint = 0x10000000,
> BypassGraphicsProxyWidget = 0x20000000,
> WindowOkButtonHint = 0x00080000,
> WindowCancelButtonHint = 0x00100000,
> WindowSoftkeysVisibleHint = 0x40000000,
> WindowSoftkeysRespondHint = 0x80000000
> };
>
> typedef QFlags<WindowType> WindowFlags;
>
> enum WindowState {
> WindowNoState = 0x00000000,
> WindowMinimized = 0x00000001,
> WindowMaximized = 0x00000002,
> WindowFullScreen = 0x00000004,
> WindowActive = 0x00000008
> };
>
> typedef QFlags<WindowState> WindowStates;
>
> enum ScreenOrientation {
> PrimaryOrientation = 0x00000000,
> PortraitOrientation = 0x00000001,
> LandscapeOrientation = 0x00000002,
> InvertedPortraitOrientation = 0x00000004,
> InvertedLandscapeOrientation = 0x00000008
> };
>
> typedef QFlags<ScreenOrientation> ScreenOrientations;
>
> 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_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_X11DoNotAcceptFocus = 126,
> WA_MacNoShadow = 127,
>
>
> 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_Use96Dpi = 8,
> AA_X11InitThreads = 10,
> AA_SynthesizeTouchForUnhandledMouseEvents = 11,
> AA_SynthesizeMouseForUnhandledTouchEvents = 12,
>
>
> 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<ImageConversionFlag> ImageConversionFlags;
>
> enum BGMode {
> TransparentMode,
> OpaqueMode
> };
>
> 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,
> Key_division = 0x0f7,
> 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,
># 782 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qnamespace.h"
> 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_TouchpadToggle = 0x01000110,
> Key_TouchpadOn = 0x01000111,
> Key_TouchpadOff = 0x01000112,
>
> 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
> };
>
> 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
> };
>
> enum TextFormat {
> PlainText,
> RichText,
> AutoText
> };
>
> enum AspectRatioMode {
> IgnoreAspectRatio,
> KeepAspectRatio,
> KeepAspectRatioByExpanding
> };
>
> enum DockWidgetArea {
> LeftDockWidgetArea = 0x1,
> RightDockWidgetArea = 0x2,
> TopDockWidgetArea = 0x4,
> BottomDockWidgetArea = 0x8,
>
> DockWidgetArea_Mask = 0xf,
> AllDockWidgetAreas = DockWidgetArea_Mask,
> NoDockWidgetArea = 0
> };
> enum DockWidgetAreaSizes {
> NDockWidgetAreas = 4
> };
>
> typedef QFlags<DockWidgetArea> 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<ToolBarArea> ToolBarAreas;
>
> 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
> };
>
> enum CaseSensitivity {
> CaseInsensitive,
> CaseSensitive
> };
>
> enum Corner {
> TopLeftCorner = 0x00000,
> TopRightCorner = 0x00001,
> BottomLeftCorner = 0x00002,
> BottomRightCorner = 0x00003
> };
>
> enum ConnectionType {
> AutoConnection,
> DirectConnection,
> QueuedConnection,
> BlockingQueuedConnection,
> UniqueConnection = 0x80
> };
>
> enum ShortcutContext {
> WidgetShortcut,
> WindowShortcut,
> ApplicationShortcut,
> WidgetWithChildrenShortcut
> };
>
> enum FillRule {
> OddEvenFill,
> WindingFill
> };
>
> enum MaskMode {
> MaskInColor,
> MaskOutColor
> };
>
> enum ClipOperation {
> NoClip,
> ReplaceClip,
> IntersectClip
> };
>
>
> 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 {
> ImEnabled = 0x1,
> ImCursorRectangle = 0x2,
> ImMicroFocus = 0x2,
> ImFont = 0x4,
> ImCursorPosition = 0x8,
> ImSurroundingText = 0x10,
> ImCurrentSelection = 0x20,
> ImMaximumTextLength = 0x40,
> ImAnchorPosition = 0x80,
> ImHints = 0x100,
> ImPreferredLanguage = 0x200,
>
> ImPlatformData = 0x80000000,
> ImQueryInput = ImCursorRectangle | ImCursorPosition | ImSurroundingText |
> ImCurrentSelection | ImAnchorPosition,
> ImQueryAll = 0xffffffff
> };
> typedef QFlags<InputMethodQuery> InputMethodQueries;
>
> enum InputMethodHint {
> ImhNone = 0x0,
>
> ImhHiddenText = 0x1,
> ImhSensitiveData = 0x2,
> ImhNoAutoUppercase = 0x4,
> ImhPreferNumbers = 0x8,
> ImhPreferUppercase = 0x10,
> ImhPreferLowercase = 0x20,
> ImhNoPredictiveText = 0x40,
>
> ImhDate = 0x80,
> ImhTime = 0x100,
>
> ImhPreferLatin = 0x200,
>
> ImhDigitsOnly = 0x10000,
> ImhFormattedNumbersOnly = 0x20000,
> ImhUppercaseOnly = 0x40000,
> ImhLowercaseOnly = 0x80000,
> ImhDialableCharactersOnly = 0x100000,
> ImhEmailCharactersOnly = 0x200000,
> ImhUrlCharactersOnly = 0x400000,
> ImhLatinOnly = 0x800000,
>
> ImhExclusiveInputMask = 0xffff0000
> };
> typedef QFlags<InputMethodHint> InputMethodHints;
>
> enum ToolButtonStyle {
> ToolButtonIconOnly,
> ToolButtonTextOnly,
> ToolButtonTextBesideIcon,
> ToolButtonTextUnderIcon,
> ToolButtonFollowStyle
> };
>
> enum LayoutDirection {
> LeftToRight,
> RightToLeft,
> LayoutDirectionAuto
> };
>
> enum AnchorPoint {
> AnchorLeft = 0,
> AnchorHorizontalCenter,
> AnchorRight,
> AnchorTop,
> AnchorVerticalCenter,
> AnchorBottom
> };
>
> enum FindChildOption {
> FindDirectChildrenOnly = 0x0,
> FindChildrenRecursively = 0x1
> };
> typedef QFlags<FindChildOption> FindChildOptions;
>
> enum DropAction {
> CopyAction = 0x1,
> MoveAction = 0x2,
> LinkAction = 0x4,
> ActionMask = 0xff,
> TargetMoveAction = 0x8002,
> IgnoreAction = 0x0
> };
> typedef QFlags<DropAction> 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 = 0x0100
> };
>
> enum ItemFlag {
> NoItemFlags = 0,
> ItemIsSelectable = 1,
> ItemIsEditable = 2,
> ItemIsDragEnabled = 4,
> ItemIsDropEnabled = 8,
> ItemIsUserCheckable = 16,
> ItemIsEnabled = 32,
> ItemIsTristate = 64
> };
> typedef QFlags<ItemFlag> 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<MatchFlag> MatchFlags;
>
> typedef void * 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<TextInteractionFlag> 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
> };
> typedef QFlags<TouchPointState> 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<GestureFlag> GestureFlags;
>
>
> enum NavigationMode
> {
> NavigationModeNone,
> NavigationModeKeypadTabOrder,
> NavigationModeKeypadDirectional,
> NavigationModeCursorAuto,
> NavigationModeCursorForceVisible
> };
>
> enum CursorMoveStyle {
> LogicalMoveStyle,
> VisualMoveStyle
> };
>
> enum TimerType {
> PreciseTimer,
> CoarseTimer,
> VeryCoarseTimer
> };
>}
>
>
>
>
>constexpr inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, Qt::MouseButtons::enum_type f2) { return QFlags<Qt::MouseButtons::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, QFlags<Qt::MouseButtons::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MouseButtons::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, Qt::Orientations::enum_type f2) { return QFlags<Qt::Orientations::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, QFlags<Qt::Orientations::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Orientations::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, Qt::KeyboardModifiers::enum_type f2) { return QFlags<Qt::KeyboardModifiers::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, QFlags<Qt::KeyboardModifiers::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::KeyboardModifiers::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, Qt::WindowFlags::enum_type f2) { return QFlags<Qt::WindowFlags::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, QFlags<Qt::WindowFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, Qt::Alignment::enum_type f2) { return QFlags<Qt::Alignment::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, QFlags<Qt::Alignment::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Alignment::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, Qt::ImageConversionFlags::enum_type f2) { return QFlags<Qt::ImageConversionFlags::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, QFlags<Qt::ImageConversionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ImageConversionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, Qt::DockWidgetAreas::enum_type f2) { return QFlags<Qt::DockWidgetAreas::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, QFlags<Qt::DockWidgetAreas::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DockWidgetAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, Qt::ToolBarAreas::enum_type f2) { return QFlags<Qt::ToolBarAreas::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, QFlags<Qt::ToolBarAreas::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ToolBarAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, Qt::WindowStates::enum_type f2) { return QFlags<Qt::WindowStates::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, QFlags<Qt::WindowStates::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::ScreenOrientations::enum_type> operator|(Qt::ScreenOrientations::enum_type f1, Qt::ScreenOrientations::enum_type f2) { return QFlags<Qt::ScreenOrientations::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::ScreenOrientations::enum_type> operator|(Qt::ScreenOrientations::enum_type f1, QFlags<Qt::ScreenOrientations::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ScreenOrientations::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, Qt::DropActions::enum_type f2) { return QFlags<Qt::DropActions::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, QFlags<Qt::DropActions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DropActions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, Qt::ItemFlags::enum_type f2) { return QFlags<Qt::ItemFlags::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, QFlags<Qt::ItemFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ItemFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, Qt::MatchFlags::enum_type f2) { return QFlags<Qt::MatchFlags::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, QFlags<Qt::MatchFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MatchFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, Qt::TextInteractionFlags::enum_type f2) { return QFlags<Qt::TextInteractionFlags::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, QFlags<Qt::TextInteractionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TextInteractionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::InputMethodQueries::enum_type> operator|(Qt::InputMethodQueries::enum_type f1, Qt::InputMethodQueries::enum_type f2) { return QFlags<Qt::InputMethodQueries::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::InputMethodQueries::enum_type> operator|(Qt::InputMethodQueries::enum_type f1, QFlags<Qt::InputMethodQueries::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::InputMethodQueries::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::InputMethodHints::enum_type> operator|(Qt::InputMethodHints::enum_type f1, Qt::InputMethodHints::enum_type f2) { return QFlags<Qt::InputMethodHints::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::InputMethodHints::enum_type> operator|(Qt::InputMethodHints::enum_type f1, QFlags<Qt::InputMethodHints::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::InputMethodHints::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>constexpr inline QFlags<Qt::TouchPointStates::enum_type> operator|(Qt::TouchPointStates::enum_type f1, Qt::TouchPointStates::enum_type f2) { return QFlags<Qt::TouchPointStates::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::TouchPointStates::enum_type> operator|(Qt::TouchPointStates::enum_type f1, QFlags<Qt::TouchPointStates::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TouchPointStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>
>constexpr inline QFlags<Qt::GestureFlags::enum_type> operator|(Qt::GestureFlags::enum_type f1, Qt::GestureFlags::enum_type f2) { return QFlags<Qt::GestureFlags::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::GestureFlags::enum_type> operator|(Qt::GestureFlags::enum_type f1, QFlags<Qt::GestureFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::GestureFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>
>
>typedef bool (*qInternalCallback)(void **);
>
>class __attribute__((visibility("default"))) 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 DockPosition {
> LeftDock,
> RightDock,
> TopDock,
> BottomDock,
> DockCount
> };
>
> enum Callback {
> EventNotifyCallback,
> LastCallback
> };
> static bool registerCallback(Callback, qInternalCallback);
> static bool unregisterCallback(Callback, qInternalCallback);
> static bool activateCallbacks(Callback, void **);
>};
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qnamespace.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qarraydata.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qrefcount.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h" 2
># 1 "/usr/include/string.h" 1 3 4
># 29 "/usr/include/string.h" 3 4
>extern "C" {
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stddef.h" 1 3 4
># 35 "/usr/include/string.h" 2 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)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
>memchr (void *__s, int __c, size_t __n) throw ()
>{
> return __builtin_memchr (__s, __c, __n);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const void *
>memchr (__const void *__s, int __c, size_t __n) throw ()
>{
> return __builtin_memchr (__s, __c, __n);
>}
>
>}
>
>
>
>
>
>
>
>
>
>
>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)));
>
># 165 "/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)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
>strchr (char *__s, int __c) throw ()
>{
> return __builtin_strchr (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
>strchr (__const char *__s, int __c) throw ()
>{
> return __builtin_strchr (__s, __c);
>}
>
>}
>
>
>
>
>
>
>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)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
>strrchr (char *__s, int __c) throw ()
>{
> return __builtin_strrchr (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
>strrchr (__const char *__s, int __c) throw ()
>{
> return __builtin_strrchr (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>
>
>
>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)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
>strpbrk (char *__s, __const char *__accept) throw ()
>{
> return __builtin_strpbrk (__s, __accept);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
>strpbrk (__const char *__s, __const char *__accept) throw ()
>{
> return __builtin_strpbrk (__s, __accept);
>}
>
>}
>
>
>
>
>
>
>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)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
>strstr (char *__haystack, __const char *__needle) throw ()
>{
> return __builtin_strstr (__haystack, __needle);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
>strstr (__const char *__haystack, __const char *__needle) throw ()
>{
> return __builtin_strstr (__haystack, __needle);
>}
>
>}
>
>
>
>
>
>
>
>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)));
># 382 "/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 ();
>
># 438 "/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)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
>index (char *__s, int __c) throw ()
>{
> return __builtin_index (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
>index (__const char *__s, int __c) throw ()
>{
> return __builtin_index (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>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)));
>
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
>rindex (char *__s, int __c) throw ()
>{
> return __builtin_rindex (__s, __c);
>}
>
>extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
>rindex (__const char *__s, int __c) throw ()
>{
> return __builtin_rindex (__s, __c);
>}
>
>}
>
>
>
>
>
>
>
>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)));
># 646 "/usr/include/string.h" 3 4
>}
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h" 2
>
>
>
>
>
>struct QArrayAllocatedData;
>struct QArrayForeignData;
>struct __attribute__((visibility("default"))) QArrayData
>{
> enum ArrayType {
> RawDataType = 0x00,
> AllocatedDataType = 0x01,
> ForeignDataType = 0x02
> };
>
> enum ArrayOption {
> DataTypeBits = 0x0007,
> Unsharable = 0x0010,
> CapacityReserved = 0x0020,
> GrowsForward = 0x0040,
> GrowsBackwards = 0x0080,
>
>
> StaticDataFlags = RawDataType,
>
> DefaultAllocationFlags = 0,
>
> DefaultRawFlags = 0
> };
> typedef QFlags<ArrayOption> ArrayOptions;
>
> QtPrivate::RefCount ref;
> uint flags;
> int size;
>
> qptrdiff offset;
>
>
> ArrayType type() const
> {
> return ArrayType(flags & DataTypeBits);
> }
>
> inline QArrayAllocatedData *asAllocatedData();
> inline const QArrayAllocatedData *asAllocatedData() const;
> inline QArrayForeignData *asForeignData();
> inline const QArrayForeignData *asForeignData() const;
> inline int capacity() const;
>
> void *data()
> {
> ((!(size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData))) ? qt_assert("size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData)",
> "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h"
># 98 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h"
> ,
> 99
># 98 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h"
> ) : qt_noop())
> ;
> return reinterpret_cast<char *>(this) + offset;
> }
>
> const void *data() const
> {
> ((!(size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData))) ? qt_assert("size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData)",
> "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h"
># 105 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h"
> ,
> 106
># 105 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h"
> ) : qt_noop())
> ;
> return reinterpret_cast<const char *>(this) + offset;
> }
>
>
>
>
> bool isMutable() const
> {
> return type() == AllocatedDataType;
> }
>
> inline size_t detachCapacity(size_t newSize) const;
>
> ArrayOptions detachFlags() const
> {
> ArrayOptions result = DefaultAllocationFlags;
> if (!ref.isSharable())
> result |= Unsharable;
> if (flags & CapacityReserved)
> result |= CapacityReserved;
> return result;
> }
>
> ArrayOptions cloneFlags() const
> {
> ArrayOptions result = DefaultAllocationFlags;
> if (flags & CapacityReserved)
> result |= CapacityReserved;
> return result;
> }
>
> static QArrayData *allocate(size_t objectSize, size_t alignment,
> size_t capacity, ArrayOptions options = DefaultAllocationFlags)
> __attribute__ ((__warn_unused_result__));
> static QArrayData *reallocateUnaligned(QArrayData *data, size_t objectSize,
> size_t newCapacity, ArrayOptions newOptions = DefaultAllocationFlags)
> __attribute__ ((__warn_unused_result__));
> static QArrayData *prepareRawData(ArrayOptions options = ArrayOptions(RawDataType))
> __attribute__ ((__warn_unused_result__));
> static QArrayData *prepareForeignData(ArrayOptions options = ArrayOptions(ForeignDataType))
> __attribute__ ((__warn_unused_result__));
> static void deallocate(QArrayData *data, size_t objectSize,
> size_t alignment);
>
> static const QArrayData shared_null[2];
> static QArrayData *sharedNull() { return const_cast<QArrayData*>(shared_null); }
>};
>
>struct QArrayAllocatedData : public QArrayData
>{
> uint alloc;
>
>
>};
>
>struct QArrayForeignData : public QArrayData
>{
> void *token;
> void (*notifyFunction)(void *);
>
>};
>
>constexpr inline QFlags<QArrayData::ArrayOptions::enum_type> operator|(QArrayData::ArrayOptions::enum_type f1, QArrayData::ArrayOptions::enum_type f2) { return QFlags<QArrayData::ArrayOptions::enum_type>(f1) | f2; } constexpr inline QFlags<QArrayData::ArrayOptions::enum_type> operator|(QArrayData::ArrayOptions::enum_type f1, QFlags<QArrayData::ArrayOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QArrayData::ArrayOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>
>inline size_t QArrayData::detachCapacity(size_t newSize) const
>{
> if (type() == AllocatedDataType && (flags & CapacityReserved) && newSize < asAllocatedData()->alloc)
> return asAllocatedData()->alloc;
> return newSize;
>}
>
>inline QArrayAllocatedData *QArrayData::asAllocatedData()
>{
> ((!(type() == AllocatedDataType)) ? qt_assert("type() == AllocatedDataType","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h",180) : qt_noop());
> return static_cast<QArrayAllocatedData *>(this);
>}
>
>inline const QArrayAllocatedData *QArrayData::asAllocatedData() const
>{
> ((!(type() == AllocatedDataType)) ? qt_assert("type() == AllocatedDataType","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h",186) : qt_noop());
> return static_cast<const QArrayAllocatedData *>(this);
>}
>
>inline QArrayForeignData *QArrayData::asForeignData()
>{
> ((!(type() == ForeignDataType)) ? qt_assert("type() == ForeignDataType","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h",192) : qt_noop());
> return static_cast<QArrayForeignData *>(this);
>}
>
>inline const QArrayForeignData *QArrayData::asForeignData() const
>{
> ((!(type() == ForeignDataType)) ? qt_assert("type() == ForeignDataType","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h",198) : qt_noop());
> return static_cast<const QArrayForeignData *>(this);
>}
>
>inline int QArrayData::capacity() const
>{
> return type() == QArrayData::AllocatedDataType ? asAllocatedData()->alloc : 0;
>}
>
>template <class T>
>struct QTypedArrayData
> : QArrayData
>{
># 281 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h"
> typedef T* iterator;
> typedef const T* const_iterator;
>
>
> T *data() { return static_cast<T *>(QArrayData::data()); }
> const T *data() const { return static_cast<const T *>(QArrayData::data()); }
>
> iterator begin() { return data(); }
> iterator end() { return data() + size; }
> const_iterator begin() const { return data(); }
> const_iterator end() const { return data() + size; }
> const_iterator constBegin() const { return data(); }
> const_iterator constEnd() const { return data() + size; }
>
> class AlignmentDummy { QArrayData header; T data; };
>
> static QTypedArrayData *allocate(size_t capacity,
> ArrayOptions options = DefaultAllocationFlags) __attribute__ ((__warn_unused_result__))
> {
> static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
> return static_cast<QTypedArrayData *>(QArrayData::allocate(sizeof(T),
> __alignof__(AlignmentDummy), capacity, options));
> }
>
> static QTypedArrayData *reallocateUnaligned(QTypedArrayData *data, size_t capacity,
> ArrayOptions options = DefaultAllocationFlags) __attribute__ ((__warn_unused_result__))
> {
> static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
> static_assert(bool(__alignof__(AlignmentDummy) <= __alignof__(QTypedArrayData)), "Q_ALIGNOF(AlignmentDummy) <= Q_ALIGNOF(QTypedArrayData)");
> return static_cast<QTypedArrayData *>(QArrayData::reallocateUnaligned(data, sizeof(T),
> capacity, options));
> }
>
> static void deallocate(QArrayData *data)
> {
> static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
> QArrayData::deallocate(data, sizeof(T), __alignof__(AlignmentDummy));
> }
>
> static QTypedArrayData *fromRawData(const T *data, size_t n,
> ArrayOptions options = DefaultRawFlags)
> {
> static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
> QTypedArrayData *result = static_cast<QTypedArrayData *>(prepareRawData(options));
> if (result) {
> ((!(!result->ref.isShared())) ? qt_assert("!result->ref.isShared()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h",326) : qt_noop());
>
> result->offset = reinterpret_cast<const char *>(data)
> - reinterpret_cast<const char *>(result);
> result->size = int(n);
> }
> return result;
> }
>
> static QTypedArrayData *sharedNull()
> {
> static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
> return static_cast<QTypedArrayData *>(QArrayData::sharedNull());
> }
>
> static QTypedArrayData *sharedEmpty()
> {
> static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
> return allocate( 0);
> }
>
> static QTypedArrayData *unsharableEmpty()
> {
> static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
> return allocate( 0, Unsharable);
> }
>};
>
>template <class T, size_t N>
>struct QStaticArrayData
>{
>
> QArrayData header;
> T data[N];
>};
>
>
>template <class T>
>struct QArrayDataPointerRef
>{
> QTypedArrayData<T> *ptr;
>};
># 456 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qarraydata.h"
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qarraydata.h" 2
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h" 2
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/stdarg.h" 1 3 4
># 52 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h" 2
># 69 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h"
>
>
>
>
>
>
>
>
>
>__attribute__((visibility("default"))) 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;
>}
>
>__attribute__((visibility("default"))) char *qstrcpy(char *dst, const char *src);
>__attribute__((visibility("default"))) char *qstrncpy(char *dst, const char *src, uint len);
>
>__attribute__((visibility("default"))) int qstrcmp(const char *str1, const char *str2);
>__attribute__((visibility("default"))) int qstrcmp(const QByteArray &str1, const QByteArray &str2);
>__attribute__((visibility("default"))) 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));
>}
>__attribute__((visibility("default"))) int qstricmp(const char *, const char *);
>__attribute__((visibility("default"))) int qstrnicmp(const char *, const char *, uint len);
>
>
>__attribute__((visibility("default"))) int qvsnprintf(char *str, size_t n, const char *fmt, va_list ap);
>__attribute__((visibility("default"))) int qsnprintf(char *str, size_t n, const char *fmt, ...);
>
>
>
>__attribute__((visibility("default"))) quint16 qChecksum(const char *s, uint len);
>
>class QByteRef;
>class QString;
>class QDataStream;
>template <typename T> class QList;
>
>typedef QArrayData QByteArrayData;
>
>template<int N> struct QStaticByteArrayData
>{
> QByteArrayData ba;
> char data[N + 1];
>
> QByteArrayData *data_ptr() const
> {
> ((!(ba.ref.isStatic())) ? qt_assert("ba.ref.isStatic()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h",132) : qt_noop());
> return const_cast<QByteArrayData *>(&ba);
> }
>};
>
>struct QByteArrayDataPtr
>{
> QByteArrayData *ptr;
>};
># 188 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h"
>class __attribute__((visibility("default"))) QByteArray
>{
>private:
> typedef QTypedArrayData<char> Data;
>
>public:
> inline QByteArray();
> QByteArray(const char *, int size = -1);
> 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 QByteArray(QByteArray && other) : d(other.d) { other.d = Data::sharedNull(); }
> inline QByteArray &operator=(QByteArray &&other)
> { qSwap(d, other.d); return *this; }
>
>
> 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;
>
> bool contains(char c) const;
> bool contains(const char *a) const;
> bool 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;
>
> 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<QByteArray> split(char sep) const;
>
> QByteArray repeated(int times) const;
># 320 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h"
> 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 cbegin() const;
> const_iterator constBegin() const;
> iterator end();
> const_iterator end() const;
> const_iterator cend() 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;
>
> constexpr inline QByteArray(QByteArrayDataPtr dd)
> : d(reinterpret_cast<Data *>(dd.ptr))
> {
> }
>
>private:
> operator QNoImplicitBoolCast() const;
> Data *d;
> void reallocData(uint alloc, Data::ArrayOptions options);
> void expand(int i);
> QByteArray nulTerminated() const;
>
> friend class QByteRef;
> friend class QString;
> friend __attribute__((visibility("default"))) QByteArray qUncompress(const uchar *data, int nbytes);
>public:
> typedef Data * DataPtr;
> inline DataPtr &data_ptr() { return d; }
>};
>
>inline QByteArray::QByteArray(): d(Data::sharedNull()) { }
>inline QByteArray::~QByteArray() { if (!d->ref.deref()) Data::deallocate(d); }
>inline int QByteArray::size() const
>{ return d->size; }
>
>inline char QByteArray::at(int i) const
>{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h",419) : qt_noop()); return d->data()[i]; }
>inline char QByteArray::operator[](int i) const
>{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h",421) : qt_noop()); return d->data()[i]; }
>inline char QByteArray::operator[](uint i) const
>{ ((!(i < uint(size()))) ? qt_assert("i < uint(size())","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h",423) : 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.isShared() || !d->isMutable()) reallocData(uint(d->size) + 1u, d->detachFlags()); }
>inline bool QByteArray::isDetached() const
>{ return !d->ref.isShared(); }
>inline QByteArray::QByteArray(const QByteArray &a) : d(a.d)
>{ d->ref.ref(); }
>
>inline int QByteArray::capacity() const
>{ int realCapacity = d->capacity(); return realCapacity ? realCapacity - 1 : 0; }
>
>inline void QByteArray::reserve(int asize)
>{
> if (d->ref.isShared() || asize > capacity()) {
> reallocData(uint(asize) + 1u, d->detachFlags() | Data::CapacityReserved);
> } else {
> d->flags |= Data::CapacityReserved;
> }
>}
>
>inline void QByteArray::squeeze()
>{
> if (d->ref.isShared() || d->size < capacity()) {
> reallocData(uint(d->size) + 1u, d->detachFlags() & ~Data::CapacityReserved);
> } else {
> d->flags &= ~Data::CapacityReserved;
> }
>}
>
>class __attribute__((visibility("default"))) 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)
>{ ((!(i >= 0)) ? qt_assert("i >= 0","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qbytearray.h",497) : 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::cbegin() 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::cend() 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 bool QByteArray::contains(const QByteArray &a) const
>{ return indexOf(a) != -1; }
>inline bool QByteArray::contains(char c) const
>{ return 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 bool QByteArray::contains(const char *c) const
>{ return 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); }
>
>
>
>__attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QByteArray &);
>__attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QByteArray &);
>
>
>
>__attribute__((visibility("default"))) QByteArray qCompress(const uchar* data, int nbytes, int compressionLevel = -1);
>__attribute__((visibility("default"))) QByteArray qUncompress(const uchar* data, int nbytes);
>inline QByteArray qCompress(const QByteArray& data, int compressionLevel = -1)
>{ return qCompress(reinterpret_cast<const uchar *>(data.constData()), data.size(), compressionLevel); }
>inline QByteArray qUncompress(const QByteArray& data)
>{ return qUncompress(reinterpret_cast<const uchar*>(data.constData()), data.size()); }
>
>
>template<> class QTypeInfo<QByteArray > { 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), sizeOf = sizeof(QByteArray) }; static inline const char *name() { return "QByteArray"; } };
>template <> inline void qSwap<QByteArray>(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()); } }
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qbytearray.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qrefcount.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qnamespace.h" 1
># 49 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h" 2
># 67 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h"
>
>
>
>
>
>class QCharRef;
>class QRegExp;
>class QRegularExpression;
>class QString;
>class QStringList;
>class QTextCodec;
>class QStringRef;
>template <typename T> class QVector;
>
>class QLatin1String
>{
>public:
> constexpr inline explicit QLatin1String(const char *s) : m_size(s ? int(strlen(s)) : 0), m_data(s) {}
> constexpr inline explicit QLatin1String(const char *s, int sz) : m_size(sz), m_data(s) {}
> inline explicit QLatin1String(const QByteArray &s) : m_size(int(qstrnlen(s.constData(), s.size()))), m_data(s.constData()) {}
>
> inline const char *latin1() const { return m_data; }
> inline int size() const { return m_size; }
> inline const char *data() const { return m_data; }
>
> inline bool operator==(const QString &s) const;
> inline bool operator!=(const QString &s) const;
> inline bool operator>(const QString &s) const;
> inline bool operator<(const QString &s) const;
> inline bool operator>=(const QString &s) const;
> inline bool operator<=(const QString &s) const;
>
>
> 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 *s) const;
> inline bool operator<=(const char *s) const;
> inline bool operator>=(const char *s) const;
>
> inline bool operator==(const QByteArray &s) const;
> inline bool operator!=(const QByteArray &s) const;
> inline bool operator<(const QByteArray &s) const;
> inline bool operator>(const QByteArray &s) const;
> inline bool operator<=(const QByteArray &s) const;
> inline bool operator>=(const QByteArray &s) const;
>
>
>private:
> int m_size;
> const char *m_data;
>};
>template<> class QTypeInfo<QLatin1String > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLatin1String)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QLatin1String) }; static inline const char *name() { return "QLatin1String"; } };
>
>
>typedef QLatin1String QLatin1Literal;
>
>
>typedef QTypedArrayData<ushort> QStringData;
>
>
>
>
>typedef char16_t qunicodechar;
># 151 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h"
>static_assert(bool(sizeof(qunicodechar) == 2), "qunicodechar must typedef an integral type of size 2")
> ;
># 205 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h"
>template <int N>
>struct QStaticStringData
>{
> QArrayData str;
> qunicodechar data[N + 1];
>
> QStringData *data_ptr() const
> {
> ((!(str.ref.isStatic())) ? qt_assert("str.ref.isStatic()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h",213) : qt_noop());
> return const_cast<QStringData *>(static_cast<const QStringData*>(&str));
> }
>};
>
>struct QStringDataPtr
>{
> QStringData *ptr;
>};
>
>class __attribute__((visibility("default"))) QString
>{
>public:
> typedef QStringData Data;
>
> inline QString();
> explicit QString(const QChar *unicode, int size = -1);
> QString(QChar c);
> QString(int size, QChar c);
> inline QString(QLatin1String latin1);
> inline QString(const QString &);
> inline ~QString();
> QString &operator=(QChar c);
> QString &operator=(const QString &);
> inline QString &operator=(QLatin1String latin1);
>
> inline QString(QString && other) : d(other.d) { other.d = Data::sharedNull(); }
> inline QString &operator=(QString &&other)
> { qSwap(d, other.d); return *this; }
>
> 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();
>
> 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,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(qulonglong a, int fieldwidth=0, int base=10,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(long a, int fieldwidth=0, int base=10,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(ulong a, int fieldwidth=0, int base=10,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(int a, int fieldWidth = 0, int base = 10,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(uint a, int fieldWidth = 0, int base = 10,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(short a, int fieldWidth = 0, int base = 10,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(ushort a, int fieldWidth = 0, int base = 10,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(char a, int fieldWidth = 0,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(QChar a, int fieldWidth = 0,
> QChar fillChar = QLatin1Char(' ')) const __attribute__ ((__warn_unused_result__));
> QString arg(const QString &a, int fieldWidth = 0,
> 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(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(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 bool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
> inline bool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
> inline bool 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 bool contains(const QRegExp &rx) const { return indexOf(rx) != -1; }
> int count(const QRegExp &) const;
>
> int indexOf(QRegExp &, int from = 0) const;
> int lastIndexOf(QRegExp &, int from = -1) const;
> inline bool contains(QRegExp &rx) const { return indexOf(rx) != -1; }
>
>
>
> int indexOf(const QRegularExpression &re, int from = 0) const;
> int lastIndexOf(const QRegularExpression &re, int from = -1) const;
> bool contains(const QRegularExpression &re) const;
> int count(const QRegularExpression &re) const;
>
>
> enum SectionFlag {
> SectionDefault = 0x00,
> SectionSkipEmpty = 0x01,
> SectionIncludeLeadingSep = 0x02,
> SectionIncludeTrailingSep = 0x04,
> SectionCaseInsensitiveSeps = 0x08
> };
> typedef QFlags<SectionFlag> 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 &reg, int start, int end = -1, SectionFlags flags = SectionDefault) const;
>
>
> QString section(const QRegularExpression &re, 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(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
> bool startsWith(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(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
> bool endsWith(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 toHtmlEscaped() 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, QLatin1String s);
> QString &append(QChar c);
> QString &append(const QString &s);
> QString &append(const QStringRef &s);
> QString &append(QLatin1String s);
> inline QString &prepend(QChar c) { return insert(0, c); }
> inline QString &prepend(const QString &s) { return insert(0, s); }
> inline QString &prepend(QLatin1String s) { return insert(0, s); }
>
> inline QString &operator+=(QChar c) {
> if (d->ref.isShared() || d->size + 1 > capacity())
> reallocData(uint(d->size) + 2u, true);
> 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+=(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(QLatin1String before, QLatin1String after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
> QString &replace(QLatin1String before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
> QString &replace(const QString &before, 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, 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()); }
>
>
> QString &replace(const QRegularExpression &re, const QString &after);
> inline QString &remove(const QRegularExpression &re)
> { return replace(re, 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(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__));
>
>
> QStringList split(const QRegularExpression &sep, SplitBehavior behavior = KeepEmptyParts) const __attribute__ ((__warn_unused_result__));
>
> enum NormalizationForm {
> NormalizationForm_D,
> NormalizationForm_C,
> NormalizationForm_KD,
> NormalizationForm_KC
> };
> QString normalized(NormalizationForm mode, QChar::UnicodeVersion version = QChar::Unicode_Unassigned) const __attribute__ ((__warn_unused_result__));
>
> QString repeated(int times) const;
>
> const ushort *utf16() const;
>
> QByteArray toLatin1() const __attribute__ ((__warn_unused_result__));
> QByteArray toUtf8() const __attribute__ ((__warn_unused_result__));
> QByteArray toLocal8Bit() const __attribute__ ((__warn_unused_result__));
> QVector<uint> toUcs4() const __attribute__ ((__warn_unused_result__));
>
>
> static inline QString fromLatin1(const char *str, int size = -1)
> {
> QStringDataPtr dataPtr = { fromLatin1_helper(str, (str && size == -1) ? int(strlen(str)) : size) };
> return QString(dataPtr);
> }
> static inline QString fromUtf8(const char *str, int size = -1)
> {
> return fromUtf8_helper(str, (str && size == -1) ? int(strlen(str)) : size);
> }
> static inline QString fromLocal8Bit(const char *str, int size = -1)
> {
> return fromLocal8Bit_helper(str, (str && size == -1) ? int(strlen(str)) : size);
> }
> static inline QString fromLatin1(const QByteArray &str)
> { return fromLatin1(str.data(), qstrnlen(str.constData(), str.size())); }
> static inline QString fromUtf8(const QByteArray &str)
> { return fromUtf8(str.data(), qstrnlen(str.constData(), str.size())); }
> static inline QString fromLocal8Bit(const QByteArray &str)
> { return fromLocal8Bit(str.data(), qstrnlen(str.constData(), str.size())); }
> static QString fromUtf16(const ushort *, int size = -1);
> static QString fromUcs4(const uint *, int size = -1);
> static QString fromRawData(const QChar *, int size);
>
>
> static inline QString fromAscii(const char *str, int size = -1)
> { return fromLatin1(str, size); }
> static inline QString fromAscii(const QByteArray &str)
> { return fromLatin1(str); }
> QByteArray toAscii() const __attribute__ ((__warn_unused_result__))
> { return toLatin1(); }
>
>
> inline int toWCharArray(wchar_t *array) const;
> static inline QString fromWCharArray(const wchar_t *string, int size = -1) __attribute__ ((__warn_unused_result__));
>
> 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, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
> int compare(QLatin1String other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
>
> static inline int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive)
> { return s1.compare(s2, cs); }
>
> static inline int compare(const QString &s1, QLatin1String s2,
> Qt::CaseSensitivity cs = Qt::CaseSensitive)
> { return s1.compare(s2, cs); }
> static inline int compare(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);
>
> friend __attribute__((visibility("default"))) bool operator==(const QString &s1, const QString &s2);
> friend __attribute__((visibility("default"))) bool operator<(const QString &s1, const QString &s2);
> friend inline bool operator>(const QString &s1, const QString &s2) { return s2 < s1; }
> friend inline bool operator!=(const QString &s1, const QString &s2) { return !(s1 == s2); }
> friend inline bool operator<=(const QString &s1, const QString &s2) { return !(s1 > s2); }
> friend inline bool operator>=(const QString &s1, const QString &s2) { return !(s1 < s2); }
>
> bool operator==(QLatin1String s) const;
> bool operator<(QLatin1String s) const;
> bool operator>(QLatin1String s) const;
> inline bool operator!=(QLatin1String s) const { return !operator==(s); }
> inline bool operator<=(QLatin1String s) const { return !operator>(s); }
> inline bool operator>=(QLatin1String s) const { return !operator<(s); }
>
>
>
> inline QString(const char *ch)
> : d(fromAscii_helper(ch, ch ? int(strlen(ch)) : -1))
> {}
> inline QString(const QByteArray &a)
> : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size())))
> {}
> inline QString &operator=(const char *ch)
> { return (*this = fromUtf8(ch)); }
> inline QString &operator=(const QByteArray &a)
> { return (*this = fromUtf8(a)); }
> inline QString &operator=(char c)
> { return (*this = QChar::fromLatin1(c)); }
>
>
> inline QString &prepend(const char *s)
> { return prepend(QString::fromUtf8(s)); }
> inline QString &prepend(const QByteArray &s)
> { return prepend(QString::fromUtf8(s)); }
> inline QString &append(const char *s)
> { return append(QString::fromUtf8(s)); }
> inline QString &append(const QByteArray &s)
> { return append(QString::fromUtf8(s)); }
> inline QString &operator+=(const char *s)
> { return append(QString::fromUtf8(s)); }
> inline QString &operator+=(const QByteArray &s)
> { return append(QString::fromUtf8(s)); }
> inline QString &operator+=(char c)
> { return append(QChar::fromLatin1(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 *s) const;
> inline bool operator>(const char *s) const;
> inline bool operator>=(const char *s) const;
>
> inline bool operator==(const QByteArray &s) const;
> inline bool operator!=(const QByteArray &s) const;
> inline bool operator<(const QByteArray &s) const;
> inline bool operator>(const QByteArray &s) const;
> inline bool operator<=(const QByteArray &s) const;
> inline bool operator>=(const QByteArray &s) const;
>
> friend inline bool operator==(const char *s1, const QString &s2);
> friend inline bool operator!=(const char *s1, const QString &s2);
> friend inline bool operator<(const char *s1, const QString &s2);
> friend inline bool operator>(const char *s1, const QString &s2);
> friend inline bool operator<=(const char *s1, const QString &s2);
> friend inline bool operator>=(const char *s1, const QString &s2);
>
> friend inline bool operator==(const char *s1, const QStringRef &s2);
> friend inline bool operator!=(const char *s1, const QStringRef &s2);
> friend inline bool operator<(const char *s1, const QStringRef &s2);
> friend inline bool operator>(const char *s1, const QStringRef &s2);
> friend inline bool operator<=(const char *s1, const QStringRef &s2);
> friend inline bool operator>=(const char *s1, const QStringRef &s2);
>
>
> typedef QChar *iterator;
> typedef const QChar *const_iterator;
> typedef iterator Iterator;
> typedef const_iterator ConstIterator;
> iterator begin();
> const_iterator begin() const;
> const_iterator cbegin() const;
> const_iterator constBegin() const;
> iterator end();
> const_iterator end() const;
> const_iterator cend() 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 std::wstring &s);
> inline std::wstring toStdWString() const;
>
>
> struct Null { };
> static const Null null;
> inline QString(const Null &): d(Data::sharedNull()) {}
> inline QString &operator=(const Null &) { *this = QString(); return *this; }
> inline bool isNull() const { return d == Data::sharedNull(); }
>
>
> bool isSimpleText() const;
> bool isRightToLeft() const;
>
> QString(int size, Qt::Initialization);
> constexpr inline QString(QStringDataPtr dd) : d(dd.ptr) {}
>
>private:
># 704 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h"
> Data *d;
>
> void reallocData(uint alloc, bool grow = false);
> 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,
> const char *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);
> static QString fromUtf8_helper(const char *str, int size);
> static QString fromLocal8Bit_helper(const char *, int size);
> static int toUcs4_helper(const ushort *uc, int length, uint *out);
> void replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen);
> friend class QCharRef;
> friend class QTextCodec;
> friend class QStringRef;
> friend class QByteArray;
> friend struct QAbstractConcatenable;
>
>public:
> typedef Data * DataPtr;
> inline DataPtr &data_ptr() { return d; }
>};
>
>inline QString::QString(QLatin1String aLatin1) : d(fromLatin1_helper(aLatin1.latin1(), aLatin1.size()))
>{ }
>inline int QString::length() const
>{ return d->size; }
>inline const QChar QString::at(int i) const
>{ ((!(uint(i) < uint(size()))) ? qt_assert("uint(i) < uint(size())","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h",743) : qt_noop()); return d->data()[i]; }
>inline const QChar QString::operator[](int i) const
>{ ((!(uint(i) < uint(size()))) ? qt_assert("uint(i) < uint(size())","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h",745) : qt_noop()); return d->data()[i]; }
>inline const QChar QString::operator[](uint i) const
>{ ((!(i < uint(size()))) ? qt_assert("i < uint(size())","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h",747) : qt_noop()); return d->data()[i]; }
>inline bool QString::isEmpty() const
>{ return d->size == 0; }
>inline const QChar *QString::unicode() const
>{ return reinterpret_cast<const QChar*>(d->data()); }
>inline const QChar *QString::data() const
>{ return reinterpret_cast<const QChar*>(d->data()); }
>inline QChar *QString::data()
>{ detach(); return reinterpret_cast<QChar*>(d->data()); }
>inline const QChar *QString::constData() const
>{ return reinterpret_cast<const QChar*>(d->data()); }
>inline void QString::detach()
>{ if (d->ref.isShared() || !d->isMutable()) reallocData(uint(d->size) + 1u); }
>inline bool QString::isDetached() const
>{ return !d->ref.isShared(); }
>inline QString &QString::operator=(QLatin1String s)
>{
> *this = fromLatin1(s.latin1(), s.size());
> return *this;
>}
>inline void QString::clear()
>{ if (!isNull()) *this = QString(); }
>inline QString::QString(const QString &other) : d(other.d)
>{ ((!(&other != this)) ? qt_assert("&other != this","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h",770) : qt_noop()); d->ref.ref(); }
>inline int QString::capacity() const
>{ int realCapacity = d->capacity(); return realCapacity ? realCapacity - 1 : 0; }
>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, QChar fillChar) const
>{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
>inline QString QString::arg(uint a, int fieldWidth, int base, QChar fillChar) const
>{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
>inline QString QString::arg(long a, int fieldWidth, int base, QChar fillChar) const
>{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
>inline QString QString::arg(ulong a, int fieldWidth, int base, QChar fillChar) const
>{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
>inline QString QString::arg(short a, int fieldWidth, int base, QChar fillChar) const
>{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
>inline QString QString::arg(ushort a, int fieldWidth, int base, 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); }
>
>inline int QString::toWCharArray(wchar_t *array) const
>{
> if (sizeof(wchar_t) == sizeof(QChar)) {
> memcpy(array, d->data(), sizeof(QChar) * size());
> return size();
> }
> return toUcs4_helper(d->data(), size(), reinterpret_cast<uint *>(array));
>}
>inline QString QString::fromWCharArray(const wchar_t *string, int size)
>{
> return sizeof(wchar_t) == sizeof(QChar) ? fromUtf16(reinterpret_cast<const ushort *>(string), size)
> : fromUcs4(reinterpret_cast<const uint *>(string), size);
>}
>
>
>class __attribute__((visibility("default"))) 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=(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::fromLatin1(c)); }
> inline QCharRef &operator=(uchar c)
> { return operator=(QChar::fromLatin1(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).toLatin1(); }
>
> char toLatin1() const { return QChar(*this).toLatin1(); }
> ushort unicode() const { return QChar(*this).unicode(); }
> ushort& unicode() { return s.data()[i].unicode(); }
>
>};
>template<> class QTypeInfo<QCharRef > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QCharRef)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QCharRef) }; static inline const char *name() { return "QCharRef"; } };
>
>inline void QCharRef::setRow(uchar arow) { QChar(*this).setRow(arow); }
>inline void QCharRef::setCell(uchar acell) { QChar(*this).setCell(acell); }
>
>
>inline QString::QString() : d(Data::sharedNull()) {}
>inline QString::~QString() { if (!d->ref.deref()) Data::deallocate(d); }
>
>inline void QString::reserve(int asize)
>{
> if (d->ref.isShared() || asize > capacity())
> reallocData(uint(asize) + 1u);
>
>
> d->flags |= Data::CapacityReserved;
>}
>
>inline void QString::squeeze()
>{
> if (d->ref.isShared() || d->size < capacity())
> reallocData(uint(d->size) + 1u);
>
>
> d->flags &= ~Data::CapacityReserved;
>}
>
>inline QString &QString::setUtf16(const ushort *autf16, int asize)
>{ return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); }
>inline QCharRef QString::operator[](int i)
>{ ((!(i >= 0)) ? qt_assert("i >= 0","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h",946) : 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<QChar*>(d->data()); }
>inline QString::const_iterator QString::begin() const
>{ return reinterpret_cast<const QChar*>(d->data()); }
>inline QString::const_iterator QString::cbegin() const
>{ return reinterpret_cast<const QChar*>(d->data()); }
>inline QString::const_iterator QString::constBegin() const
>{ return reinterpret_cast<const QChar*>(d->data()); }
>inline QString::iterator QString::end()
>{ detach(); return reinterpret_cast<QChar*>(d->data() + d->size); }
>inline QString::const_iterator QString::end() const
>{ return reinterpret_cast<const QChar*>(d->data() + d->size); }
>inline QString::const_iterator QString::cend() const
>{ return reinterpret_cast<const QChar*>(d->data() + d->size); }
>inline QString::const_iterator QString::constEnd() const
>{ return reinterpret_cast<const QChar*>(d->data() + d->size); }
>inline bool QString::contains(const QString &s, Qt::CaseSensitivity cs) const
>{ return indexOf(s, 0, cs) != -1; }
>inline bool QString::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
>{ return indexOf(s, 0, cs) != -1; }
>inline bool QString::contains(QChar c, Qt::CaseSensitivity cs) const
>{ return 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 operator==(QLatin1String s1, QLatin1String s2)
>{ return (s1.size() == s2.size() && !memcmp(s1.latin1(), s2.latin1(), s1.size())); }
>inline bool operator!=(QLatin1String s1, QLatin1String s2)
>{ return (s1.size() != s2.size() || memcmp(s1.latin1(), s2.latin1(), s1.size())); }
>inline bool operator<(QLatin1String s1, QLatin1String s2)
>{ int r = memcmp(s1.latin1(), s2.latin1(), qMin(s1.size(), s2.size()));
> return (r < 0) || (r == 0 && s1.size() < s2.size()); }
>inline bool operator<=(QLatin1String s1, QLatin1String s2)
>{ int r = memcmp(s1.latin1(), s2.latin1(), qMin(s1.size(), s2.size()));
> return (r < 0) || (r == 0 && s1.size() <= s2.size()); }
>inline bool operator>(QLatin1String s1, QLatin1String s2)
>{ int r = memcmp(s1.latin1(), s2.latin1(), qMin(s1.size(), s2.size()));
> return (r > 0) || (r == 0 && s1.size() > s2.size()); }
>inline bool operator>=(QLatin1String s1, QLatin1String s2)
>{ int r = memcmp(s1.latin1(), s2.latin1(), qMin(s1.size(), s2.size()));
> return (r > 0) || (r == 0 && s1.size() >= s2.size()); }
>
>inline bool QLatin1String::operator==(const QString &s) const
>{ return s == *this; }
>inline bool QLatin1String::operator!=(const QString &s) const
>{ return s != *this; }
>inline bool QLatin1String::operator>(const QString &s) const
>{ return s < *this; }
>inline bool QLatin1String::operator<(const QString &s) const
>{ return s > *this; }
>inline bool QLatin1String::operator>=(const QString &s) const
>{ return s <= *this; }
>inline bool QLatin1String::operator<=(const QString &s) const
>{ return s >= *this; }
>
>
>inline bool QString::operator==(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) == 0; }
>inline bool QString::operator!=(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) != 0; }
>inline bool QString::operator<(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) < 0; }
>inline bool QString::operator>(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) > 0; }
>inline bool QString::operator<=(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) <= 0; }
>inline bool QString::operator>=(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) >= 0; }
>
>inline bool operator==(const char *s1, const QString &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) == 0; }
>inline bool operator!=(const char *s1, const QString &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) != 0; }
>inline bool operator<(const char *s1, const QString &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) < 0; }
>inline bool operator>(const char *s1, const QString &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) > 0; }
>inline bool operator<=(const char *s1, const QString &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) <= 0; }
>inline bool operator>=(const char *s1, const QString &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) >= 0; }
>
>inline bool operator==(const char *s1, QLatin1String s2)
>{ return QString::fromUtf8(s1) == s2; }
>inline bool operator!=(const char *s1, QLatin1String s2)
>{ return QString::fromUtf8(s1) != s2; }
>inline bool operator<(const char *s1, QLatin1String s2)
>{ return (QString::fromUtf8(s1) < s2); }
>inline bool operator>(const char *s1, QLatin1String s2)
>{ return (QString::fromUtf8(s1) > s2); }
>inline bool operator<=(const char *s1, QLatin1String s2)
>{ return (QString::fromUtf8(s1) <= s2); }
>inline bool operator>=(const char *s1, QLatin1String s2)
>{ return (QString::fromUtf8(s1) >= s2); }
>
>inline bool QLatin1String::operator==(const char *s) const
>{ return QString::fromUtf8(s) == *this; }
>inline bool QLatin1String::operator!=(const char *s) const
>{ return QString::fromUtf8(s) != *this; }
>inline bool QLatin1String::operator<(const char *s) const
>{ return QString::fromUtf8(s) > *this; }
>inline bool QLatin1String::operator>(const char *s) const
>{ return QString::fromUtf8(s) < *this; }
>inline bool QLatin1String::operator<=(const char *s) const
>{ return QString::fromUtf8(s) >= *this; }
>inline bool QLatin1String::operator>=(const char *s) const
>{ return QString::fromUtf8(s) <= *this; }
>
>inline bool QLatin1String::operator==(const QByteArray &s) const
>{ return QString::fromUtf8(s) == *this; }
>inline bool QLatin1String::operator!=(const QByteArray &s) const
>{ return QString::fromUtf8(s) != *this; }
>inline bool QLatin1String::operator<(const QByteArray &s) const
>{ return QString::fromUtf8(s) > *this; }
>inline bool QLatin1String::operator>(const QByteArray &s) const
>{ return QString::fromUtf8(s) < *this; }
>inline bool QLatin1String::operator<=(const QByteArray &s) const
>{ return QString::fromUtf8(s) >= *this; }
>inline bool QLatin1String::operator>=(const QByteArray &s) const
>{ return QString::fromUtf8(s) <= *this; }
>
>inline bool QString::operator==(const QByteArray &s) const
>{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) == 0; }
>inline bool QString::operator!=(const QByteArray &s) const
>{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) != 0; }
>inline bool QString::operator<(const QByteArray &s) const
>{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) < 0; }
>inline bool QString::operator>(const QByteArray &s) const
>{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) > 0; }
>inline bool QString::operator<=(const QByteArray &s) const
>{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) <= 0; }
>inline bool QString::operator>=(const QByteArray &s) const
>{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) >= 0; }
>
>inline bool QByteArray::operator==(const QString &s) const
>{ return QString::compare_helper(s.constData(), s.size(), constData(), qstrnlen(constData(), size())) == 0; }
>inline bool QByteArray::operator!=(const QString &s) const
>{ return QString::compare_helper(s.constData(), s.size(), constData(), qstrnlen(constData(), size())) != 0; }
>inline bool QByteArray::operator<(const QString &s) const
>{ return QString::compare_helper(s.constData(), s.size(), constData(), qstrnlen(constData(), size())) < 0; }
>inline bool QByteArray::operator>(const QString &s) const
>{ return QString::compare_helper(s.constData(), s.size(), constData(), qstrnlen(constData(), size())) > 0; }
>inline bool QByteArray::operator<=(const QString &s) const
>{ return QString::compare_helper(s.constData(), s.size(), constData(), qstrnlen(constData(), size())) <= 0; }
>inline bool QByteArray::operator>=(const QString &s) const
>{ return QString::compare_helper(s.constData(), s.size(), constData(), qstrnlen(constData(), size())) >= 0; }
># 1145 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h"
>inline std::string QString::toStdString() const
>{ const QByteArray asc = toUtf8(); return std::string(asc.constData(), asc.length()); }
>
>inline QString QString::fromStdString(const std::string &s)
>{ return fromUtf8(s.data(), int(s.size())); }
>
>inline std::wstring QString::toStdWString() const
>{
> std::wstring str;
> str.resize(length());
>
>
>
>
>
>
>
> str.resize(toWCharArray(&(*str.begin())));
> return str;
>}
>
>inline QString QString::fromStdWString(const std::wstring &s)
>{ return fromWCharArray(s.data(), int(s.size())); }
>
>
>__attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QString &);
>__attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QString &);
>
>
>template<> class QTypeInfo<QString > { 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), sizeOf = sizeof(QString) }; static inline const char *name() { return "QString"; } };
>template <> inline void qSwap<QString>(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()); } }
>constexpr inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QString::SectionFlags::enum_type f2) { return QFlags<QString::SectionFlags::enum_type>(f1) | f2; } constexpr inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QFlags<QString::SectionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QString::SectionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>
>
>class __attribute__((visibility("default"))) 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 bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
> inline bool contains(QChar ch, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
> inline bool contains(QLatin1String str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
> inline bool 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<const QChar *>(QString::Data::sharedNull()->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__))
> { return toLatin1(); }
>
> QByteArray toLatin1() const __attribute__ ((__warn_unused_result__));
> QByteArray toUtf8() const __attribute__ ((__warn_unused_result__));
> QByteArray toLocal8Bit() const __attribute__ ((__warn_unused_result__));
> QVector<uint> 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
> { ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h",1258) : qt_noop()); return m_string->at(i + m_position); }
>
>
>
> 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 *s) const;
> inline bool operator>(const char *s) const;
> inline bool operator>=(const char *s) const;
>
>
> 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);
>};
>template<> class QTypeInfo<QStringRef > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QStringRef)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QStringRef) }; static inline const char *name() { return "QStringRef"; } };
>
>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){}
>
>__attribute__((visibility("default"))) bool operator==(const QStringRef &s1,const QStringRef &s2);
>inline bool operator!=(const QStringRef &s1,const QStringRef &s2)
>{ return !(s1 == s2); }
>__attribute__((visibility("default"))) 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; }
>__attribute__((visibility("default"))) bool operator==(QLatin1String s1, const QStringRef &s2);
>inline bool operator!=(QLatin1String s1, const QStringRef &s2)
>{ return !(s1 == s2); }
>inline bool operator==(const QStringRef &s1, QLatin1String s2)
>{ return s2 == s1; }
>inline bool operator!=(const QStringRef &s1, QLatin1String s2)
>{ return s2 != s1; }
>
>__attribute__((visibility("default"))) 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 QStringRef::operator==(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) == 0; }
>inline bool QStringRef::operator!=(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) != 0; }
>inline bool QStringRef::operator<(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) < 0; }
>inline bool QStringRef::operator<=(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) > 0; }
>inline bool QStringRef::operator>(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) <= 0; }
>inline bool QStringRef::operator>=(const char *s) const
>{ return QString::compare_helper(constData(), size(), s, -1) >= 0; }
>
>inline bool operator==(const char *s1, const QStringRef &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) == 0; }
>inline bool operator!=(const char *s1, const QStringRef &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) != 0; }
>inline bool operator<(const char *s1, const QStringRef &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) < 0; }
>inline bool operator<=(const char *s1, const QStringRef &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) > 0; }
>inline bool operator>(const char *s1, const QStringRef &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) <= 0; }
>inline bool operator>=(const char *s1, const QStringRef &s2)
>{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) >= 0; }
>
>
>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 bool QStringRef::contains(const QString &s, Qt::CaseSensitivity cs) const
>{ return indexOf(s, 0, cs) != -1; }
>inline bool QStringRef::contains(QLatin1String s, Qt::CaseSensitivity cs) const
>{ return indexOf(s, 0, cs) != -1; }
>inline bool QStringRef::contains(QChar c, Qt::CaseSensitivity cs) const
>{ return indexOf(c, 0, cs) != -1; }
>inline bool QStringRef::contains(const QStringRef &s, Qt::CaseSensitivity cs) const
>{ return indexOf(s, 0, cs) != -1; }
>
>namespace Qt {
>
> inline QString escape(const QString &plain) {
> return plain.toHtmlEscaped();
>}
>
>}
>
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qstringbuilder.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringbuilder.h" 1
># 52 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringbuilder.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qstring.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qstring.h" 2
># 53 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringbuilder.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qbytearray.h" 1
># 54 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringbuilder.h" 2
>
>
>
>
>
>
>
>
>struct __attribute__((visibility("default"))) QAbstractConcatenable
>{
>protected:
> static void convertFromAscii(const char *a, int len, QChar *&out);
> static inline void convertFromAscii(char a, QChar *&out)
> {
> *out++ = QLatin1Char(a);
> }
>};
>
>template <typename T> struct QConcatenable {};
>
>namespace QtStringBuilder {
> template <typename A, typename B> struct ConvertToTypeHelper
> { typedef A ConvertTo; };
> template <typename T> struct ConvertToTypeHelper<T, QString>
> { typedef QString ConvertTo; };
>}
>
>template<typename Builder, typename T>
>struct QStringBuilderCommon
>{
> T toUpper() const { return resolved().toUpper(); }
> T toLower() const { return resolved().toLower(); }
>
>protected:
> const T resolved() const { return *static_cast<const Builder*>(this); }
>};
>
>template<typename Builder, typename T>
>struct QStringBuilderBase : public QStringBuilderCommon<Builder, T>
>{
>};
>
>template<typename Builder>
>struct QStringBuilderBase<Builder, QString> : public QStringBuilderCommon<Builder, QString>
>{
> QByteArray toLatin1() const { return this->resolved().toLatin1(); }
> QByteArray toUtf8() const { return this->resolved().toUtf8(); }
> QByteArray toLocal8Bit() const { return this->resolved().toLocal8Bit(); }
>};
>
>template <typename A, typename B>
>class QStringBuilder : public QStringBuilderBase<QStringBuilder<A, B>, typename QtStringBuilder::ConvertToTypeHelper<typename QConcatenable<A>::ConvertTo, typename QConcatenable::ConvertTo>::ConvertTo>
>{
>public:
> QStringBuilder(const A &a_, const B &b_) : a(a_), b(b_) {}
>private:
> friend class QByteArray;
> friend class QString;
> template <typename T> T convertTo() const
> {
> const uint len = QConcatenable< QStringBuilder<A, B> >::size(*this);
> T s(len, Qt::Uninitialized);
>
> typename T::iterator d = s.data();
> typename T::const_iterator const start = d;
> QConcatenable< QStringBuilder<A, B> >::appendTo(*this, d);
>
> if (!QConcatenable< QStringBuilder<A, B> >::ExactSize && int(len) != d - start) {
>
>
> s.resize(d - start);
> }
> return s;
> }
>
> typedef QConcatenable<QStringBuilder<A, B> > Concatenable;
> typedef typename Concatenable::ConvertTo ConvertTo;
>public:
> operator ConvertTo() const { return convertTo<ConvertTo>(); }
>
> int size() const { return Concatenable::size(*this); }
>
> const A &a;
> const B &b;
>};
>
>template <>
>class QStringBuilder <QString, QString> : public QStringBuilderBase<QStringBuilder<QString, QString>, QString>
>{
> public:
> QStringBuilder(const QString &a_, const QString &b_) : a(a_), b(b_) {}
>
> operator QString() const
> { QString r(a); r += b; return r; }
>
> const QString &a;
> const QString &b;
>};
>
>template <>
>class QStringBuilder <QByteArray, QByteArray> : public QStringBuilderBase<QStringBuilder<QByteArray, QByteArray>, QByteArray>
>{
> public:
> QStringBuilder(const QByteArray &a_, const QByteArray &b_) : a(a_), b(b_) {}
>
> operator QByteArray() const
> { QByteArray r(a); r += b; return r; }
>
> const QByteArray &a;
> const QByteArray &b;
>};
>
>
>template <> struct QConcatenable<char> : private QAbstractConcatenable
>{
> typedef char type;
> typedef QByteArray ConvertTo;
> enum { ExactSize = true };
> static int size(const char) { return 1; }
>
> static inline void appendTo(const char c, QChar *&out)
> {
> QAbstractConcatenable::convertFromAscii(c, out);
> }
>
> static inline void appendTo(const char c, char *&out)
> { *out++ = c; }
>};
>
>template <> struct QConcatenable<QLatin1Char>
>{
> typedef QLatin1Char type;
> typedef QString ConvertTo;
> enum { ExactSize = true };
> static int size(const QLatin1Char) { return 1; }
> static inline void appendTo(const QLatin1Char c, QChar *&out)
> { *out++ = c; }
> static inline void appendTo(const QLatin1Char c, char *&out)
> { *out++ = c.toLatin1(); }
>};
>
>template <> struct QConcatenable<QChar> : private QAbstractConcatenable
>{
> typedef QChar type;
> typedef QString ConvertTo;
> enum { ExactSize = true };
> static int size(const QChar) { return 1; }
> static inline void appendTo(const QChar c, QChar *&out)
> { *out++ = c; }
>};
>
>template <> struct QConcatenable<QChar::SpecialCharacter> : private QAbstractConcatenable
>{
> typedef QChar::SpecialCharacter type;
> typedef QString ConvertTo;
> enum { ExactSize = true };
> static int size(const QChar::SpecialCharacter) { return 1; }
> static inline void appendTo(const QChar::SpecialCharacter c, QChar *&out)
> { *out++ = c; }
>};
>
>template <> struct QConcatenable<QCharRef> : private QAbstractConcatenable
>{
> typedef QCharRef type;
> typedef QString ConvertTo;
> enum { ExactSize = true };
> static int size(QCharRef) { return 1; }
> static inline void appendTo(QCharRef c, QChar *&out)
> { *out++ = QChar(c); }
>};
>
>template <> struct QConcatenable<QLatin1String>
>{
> typedef QLatin1String type;
> typedef QString ConvertTo;
> enum { ExactSize = true };
> static int size(const QLatin1String a) { return a.size(); }
> static inline void appendTo(const QLatin1String a, QChar *&out)
> {
> if (a.data()) {
> for (const char *s = a.data(); *s; )
> *out++ = QLatin1Char(*s++);
> }
> }
> static inline void appendTo(const QLatin1String a, char *&out)
> {
> if (a.data()) {
> for (const char *s = a.data(); *s; )
> *out++ = *s++;
> }
> }
>};
>
>template <> struct QConcatenable<QString> : private QAbstractConcatenable
>{
> typedef QString type;
> typedef QString ConvertTo;
> enum { ExactSize = true };
> static int size(const QString &a) { return a.size(); }
> static inline void appendTo(const QString &a, QChar *&out)
> {
> const int n = a.size();
> memcpy(out, reinterpret_cast<const char*>(a.constData()), sizeof(QChar) * n);
> out += n;
> }
>};
>
>template <> struct QConcatenable<QStringRef> : private QAbstractConcatenable
>{
> typedef QStringRef type;
> typedef QString ConvertTo;
> enum { ExactSize = true };
> static int size(const QStringRef &a) { return a.size(); }
> static inline void appendTo(const QStringRef &a, QChar *&out)
> {
> const int n = a.size();
> memcpy(out, reinterpret_cast<const char*>(a.constData()), sizeof(QChar) * n);
> out += n;
> }
>};
>
>template <int N> struct QConcatenable<char[N]> : private QAbstractConcatenable
>{
> typedef char type[N];
> typedef QByteArray ConvertTo;
> enum { ExactSize = false };
> static int size(const char[N]) { return N - 1; }
>
> static inline void appendTo(const char a[N], QChar *&out)
> {
> QAbstractConcatenable::convertFromAscii(a, N - 1, out);
> }
>
> static inline void appendTo(const char a[N], char *&out)
> {
> while (*a)
> *out++ = *a++;
> }
>};
>
>template <int N> struct QConcatenable<const char[N]> : private QAbstractConcatenable
>{
> typedef const char type[N];
> typedef QByteArray ConvertTo;
> enum { ExactSize = false };
> static int size(const char[N]) { return N - 1; }
>
> static inline void appendTo(const char a[N], QChar *&out)
> {
> QAbstractConcatenable::convertFromAscii(a, N - 1, out);
> }
>
> static inline void appendTo(const char a[N], char *&out)
> {
> while (*a)
> *out++ = *a++;
> }
>};
>
>template <> struct QConcatenable<const char *> : private QAbstractConcatenable
>{
> typedef char const *type;
> typedef QByteArray ConvertTo;
> enum { ExactSize = false };
> static int size(const char *a) { return qstrlen(a); }
>
> static inline void appendTo(const char *a, QChar *&out)
> { QAbstractConcatenable::convertFromAscii(a, -1, out); }
>
> static inline void appendTo(const char *a, char *&out)
> {
> if (!a)
> return;
> while (*a)
> *out++ = *a++;
> }
>};
>
>template <> struct QConcatenable<QByteArray> : private QAbstractConcatenable
>{
> typedef QByteArray type;
> typedef QByteArray ConvertTo;
> enum { ExactSize = false };
> static int size(const QByteArray &ba) { return ba.size(); }
>
> static inline void appendTo(const QByteArray &ba, QChar *&out)
> {
> QAbstractConcatenable::convertFromAscii(ba.constData(), ba.size(), out);
> }
>
> static inline void appendTo(const QByteArray &ba, char *&out)
> {
> const char *a = ba.constData();
> const char * const end = ba.end();
> while (a != end)
> *out++ = *a++;
> }
>};
>
>
>template <typename A, typename B>
>struct QConcatenable< QStringBuilder<A, B> >
>{
> typedef QStringBuilder<A, B> type;
> typedef typename QtStringBuilder::ConvertToTypeHelper<typename QConcatenable<A>::ConvertTo, typename QConcatenable::ConvertTo>::ConvertTo ConvertTo;
> enum { ExactSize = QConcatenable<A>::ExactSize && QConcatenable::ExactSize };
> static int size(const type &p)
> {
> return QConcatenable<A>::size(p.a) + QConcatenable::size(p.b);
> }
> template<typename T> static inline void appendTo(const type &p, T *&out)
> {
> QConcatenable<A>::appendTo(p.a, out);
> QConcatenable::appendTo(p.b, out);
> }
>};
>
>template <typename A, typename B>
>QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable::type>
>operator%(const A &a, const B &b)
>{
> return QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable::type>(a, b);
>}
>
>
>
>
>template <typename A, typename B>
>QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable::type>
>operator+(const A &a, const B &b)
>{
> return QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable::type>(a, b);
>}
>
>
>namespace QtStringBuilder {
>template <typename A, typename B>
>QByteArray &appendToByteArray(QByteArray &a, const QStringBuilder<A, B> &b, char)
>{
>
> int len = a.size() + QConcatenable< QStringBuilder<A, B> >::size(b);
> a.reserve(len);
> char *it = a.data() + a.size();
> QConcatenable< QStringBuilder<A, B> >::appendTo(b, it);
> a.resize(len);
> return a;
>}
># 410 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringbuilder.h"
>}
>
>template <typename A, typename B>
>QByteArray &operator+=(QByteArray &a, const QStringBuilder<A, B> &b)
>{
> return QtStringBuilder::appendToByteArray(a, b,
> typename QConcatenable< QStringBuilder<A, B> >::ConvertTo::value_type());
>}
>
>template <typename A, typename B>
>QString &operator+=(QString &a, const QStringBuilder<A, B> &b)
>{
> int len = a.size() + QConcatenable< QStringBuilder<A, B> >::size(b);
> a.reserve(len);
> QChar *it = a.data() + a.size();
> QConcatenable< QStringBuilder<A, B> >::appendTo(b, it);
> a.resize(it - a.constData());
> return a;
>}
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qstringbuilder.h" 2
># 1403 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstring.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qstring.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/QString" 2
># 40 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/QStringList" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qstringlist.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringlist.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringlist.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qalgorithms.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qalgorithms.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qalgorithms.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qalgorithms.h" 2
>
>
>
>
>
>
>
>
>
>
>namespace QAlgorithmsPrivate {
>
>template <typename RandomAccessIterator, typename T, typename LessThan>
> void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
>template <typename RandomAccessIterator, typename T>
>inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy);
>
>template <typename RandomAccessIterator, typename T, typename LessThan>
> void qStableSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
>template <typename RandomAccessIterator, typename T>
>inline void qStableSortHelper(RandomAccessIterator, RandomAccessIterator, const T &);
>
>template <typename RandomAccessIterator, typename T, typename LessThan>
> RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
>template <typename RandomAccessIterator, typename T, typename LessThan>
> RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
>template <typename RandomAccessIterator, typename T, typename LessThan>
> RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
>
>}
>
>template <typename InputIterator, typename OutputIterator>
>inline OutputIterator qCopy(InputIterator begin, InputIterator end, OutputIterator dest)
>{
> while (begin != end)
> *dest++ = *begin++;
> return dest;
>}
>
>template <typename BiIterator1, typename BiIterator2>
>inline BiIterator2 qCopyBackward(BiIterator1 begin, BiIterator1 end, BiIterator2 dest)
>{
> while (begin != end)
> *--dest = *--end;
> return dest;
>}
>
>template <typename InputIterator1, typename InputIterator2>
>inline bool qEqual(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
>{
> for (; first1 != last1; ++first1, ++first2)
> if (!(*first1 == *first2))
> return false;
> return true;
>}
>
>template <typename ForwardIterator, typename T>
>inline void qFill(ForwardIterator first, ForwardIterator last, const T &val)
>{
> for (; first != last; ++first)
> *first = val;
>}
>
>template <typename Container, typename T>
>inline void qFill(Container &container, const T &val)
>{
> qFill(container.begin(), container.end(), val);
>}
>
>template <typename InputIterator, typename T>
>inline InputIterator qFind(InputIterator first, InputIterator last, const T &val)
>{
> while (first != last && !(*first == val))
> ++first;
> return first;
>}
>
>template <typename Container, typename T>
>inline typename Container::const_iterator qFind(const Container &container, const T &val)
>{
> return qFind(container.constBegin(), container.constEnd(), val);
>}
>
>template <typename InputIterator, typename T, typename Size>
>inline void qCount(InputIterator first, InputIterator last, const T &value, Size &n)
>{
> for (; first != last; ++first)
> if (*first == value)
> ++n;
>}
>
>template <typename Container, typename T, typename Size>
>inline void qCount(const Container &container, const T &value, Size &n)
>{
> qCount(container.constBegin(), container.constEnd(), value, n);
>}
># 154 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qalgorithms.h"
>template <typename T>
>class qLess
>{
>public:
> inline bool operator()(const T &t1, const T &t2) const
> {
> return (t1 < t2);
> }
>};
>
>template <typename T>
>class qGreater
>{
>public:
> inline bool operator()(const T &t1, const T &t2) const
> {
> return (t2 < t1);
> }
>};
>
>
>template <typename RandomAccessIterator>
>inline void qSort(RandomAccessIterator start, RandomAccessIterator end)
>{
> if (start != end)
> QAlgorithmsPrivate::qSortHelper(start, end, *start);
>}
>
>template <typename RandomAccessIterator, typename LessThan>
>inline void qSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
>{
> if (start != end)
> QAlgorithmsPrivate::qSortHelper(start, end, *start, lessThan);
>}
>
>template<typename Container>
>inline void qSort(Container &c)
>{
>
>
>
>
> if (!c.empty())
> QAlgorithmsPrivate::qSortHelper(c.begin(), c.end(), *c.begin());
>}
>
>template <typename RandomAccessIterator>
>inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end)
>{
> if (start != end)
> QAlgorithmsPrivate::qStableSortHelper(start, end, *start);
>}
>
>template <typename RandomAccessIterator, typename LessThan>
>inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
>{
> if (start != end)
> QAlgorithmsPrivate::qStableSortHelper(start, end, *start, lessThan);
>}
>
>template<typename Container>
>inline void qStableSort(Container &c)
>{
>
>
>
>
> if (!c.empty())
> QAlgorithmsPrivate::qStableSortHelper(c.begin(), c.end(), *c.begin());
>}
>
>template <typename RandomAccessIterator, typename T>
> 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 <typename RandomAccessIterator, typename T, typename LessThan>
> RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
>{
> return QAlgorithmsPrivate::qLowerBoundHelper(begin, end, value, lessThan);
>}
>
>template <typename Container, typename T>
> typename Container::const_iterator qLowerBound(const Container &container, const T &value)
>{
> return QAlgorithmsPrivate::qLowerBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
>}
>
>template <typename RandomAccessIterator, typename T>
> 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 <typename RandomAccessIterator, typename T, typename LessThan>
> RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
>{
> return QAlgorithmsPrivate::qUpperBoundHelper(begin, end, value, lessThan);
>}
>
>template <typename Container, typename T>
> typename Container::const_iterator qUpperBound(const Container &container, const T &value)
>{
> return QAlgorithmsPrivate::qUpperBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
>}
>
>template <typename RandomAccessIterator, typename T>
> 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 <typename RandomAccessIterator, typename T, typename LessThan>
> RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
>{
> return QAlgorithmsPrivate::qBinaryFindHelper(begin, end, value, lessThan);
>}
>
>template <typename Container, typename T>
> typename Container::const_iterator qBinaryFind(const Container &container, const T &value)
>{
> return QAlgorithmsPrivate::qBinaryFindHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
>}
>
>template <typename ForwardIterator>
> void qDeleteAll(ForwardIterator begin, ForwardIterator end)
>{
> while (begin != end) {
> delete *begin;
> ++begin;
> }
>}
>
>template <typename Container>
>inline void qDeleteAll(const Container &c)
>{
> qDeleteAll(c.begin(), c.end());
>}
>
>
>
>
>
>namespace QAlgorithmsPrivate {
>
>template <typename RandomAccessIterator, typename T, typename LessThan>
> 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 <typename RandomAccessIterator, typename T>
>inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
>{
> qSortHelper(begin, end, dummy, qLess<T>());
>}
>
>template <typename RandomAccessIterator>
> void qReverse(RandomAccessIterator begin, RandomAccessIterator end)
>{
> --end;
> while (begin < end)
> qSwap(*begin++, *end--);
>}
>
>template <typename RandomAccessIterator>
> void qRotate(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end)
>{
> qReverse(begin, middle);
> qReverse(middle, end);
> qReverse(begin, end);
>}
>
>template <typename RandomAccessIterator, typename T, typename LessThan>
> 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 <typename RandomAccessIterator, typename T, typename LessThan>
> 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 <typename RandomAccessIterator, typename T>
>inline void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
>{
> qStableSortHelper(begin, end, dummy, qLess<T>());
>}
>
>template <typename RandomAccessIterator, typename T, typename LessThan>
> 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 <typename RandomAccessIterator, typename T, typename LessThan>
> 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 <typename RandomAccessIterator, typename T, typename LessThan>
> 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;
>}
>
>}
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qalgorithms.h" 2
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringlist.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qdatastream.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/io/qdatastream.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/io/qdatastream.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qscopedpointer.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qscopedpointer.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qscopedpointer.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qscopedpointer.h" 2
>
>
>
>
>
>
>template <typename T>
>struct QScopedPointerDeleter
>{
> static inline void cleanup(T *pointer)
> {
>
>
>
> typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ];
> (void) sizeof(IsIncompleteType);
>
> delete pointer;
> }
>};
>
>template <typename T>
>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) free(pointer); }
>};
>
>template <typename T, typename Cleanup = QScopedPointerDeleter<T> >
>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
> {
> ((!(d)) ? qt_assert("d","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qscopedpointer.h",105) : qt_noop());
> return *d;
> }
>
> inline T *operator->() const
> {
> ((!(d)) ? qt_assert("d","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qscopedpointer.h",111) : 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<T, Cleanup> &other)
> {
> qSwap(d, other.d);
> }
>
> typedef T *pointer;
>
>protected:
> T *d;
>
>private:
> QScopedPointer(const QScopedPointer &) = delete; QScopedPointer &operator=(const QScopedPointer &) = delete;
>};
>
>template <class T, class Cleanup>
>inline bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
>{
> return lhs.data() == rhs.data();
>}
>
>template <class T, class Cleanup>
>inline bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
>{
> return lhs.data() != rhs.data();
>}
>
>template <class T, class Cleanup>
>inline void qSwap(QScopedPointer<T, Cleanup> &p1, QScopedPointer<T, Cleanup> &p2)
>{ p1.swap(p2); }
>
>
>namespace std {
> template <class T, class Cleanup>
> inline void swap(::QScopedPointer<T, Cleanup> &p1, ::QScopedPointer<T, Cleanup> &p2)
> { p1.swap(p2); }
>}
>
>
>
>
>namespace QtPrivate {
> template <typename X, typename Y> struct QScopedArrayEnsureSameType;
> template <typename X> struct QScopedArrayEnsureSameType<X,X> { typedef X* Type; };
> template <typename X> struct QScopedArrayEnsureSameType<const X, X> { typedef X* Type; };
>}
>
>template <typename T, typename Cleanup = QScopedPointerArrayDeleter<T> >
>class QScopedArrayPointer : public QScopedPointer<T, Cleanup>
>{
>public:
> inline QScopedArrayPointer() : QScopedPointer<T, Cleanup>(0) {}
>
> template <typename D>
> explicit inline QScopedArrayPointer(D *p, typename QtPrivate::QScopedArrayEnsureSameType<T,D>::Type = 0)
> : QScopedPointer<T, Cleanup>(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 *) {
># 236 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qscopedpointer.h"
> }
>
> QScopedArrayPointer(const QScopedArrayPointer &) = delete; QScopedArrayPointer &operator=(const QScopedArrayPointer &) = delete;
>};
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qscopedpointer.h" 2
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/io/qdatastream.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qiodevice.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/io/qiodevice.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/io/qiodevice.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qobject.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h" 1
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qobjectdefs.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qnamespace.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs.h" 2
>
># 1 "../../../../qt5/qtbase/include/QtCore/qobjectdefs_impl.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs_impl.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs_impl.h"
>
>
>
>
>
>namespace QtPrivate {
> template <typename T> struct RemoveRef { typedef T Type; };
> template <typename T> struct RemoveRef<T&> { typedef T Type; };
> template <typename T> struct RemoveConstRef { typedef T Type; };
> template <typename T> struct RemoveConstRef<const T&> { typedef T Type; };
># 71 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs_impl.h"
> template <typename...> struct List {};
> template <typename Head, typename... Tail> struct List<Head, Tail...> { typedef Head Car; typedef List<Tail...> Cdr; };
> template <typename, typename> struct List_Append;
> template <typename... L1, typename...L2> struct List_Append<List<L1...>, List<L2...>> { typedef List<L1..., L2...> Value; };
> template <typename L, int N> struct List_Left {
> typedef typename List_Append<List<typename L::Car>,typename List_Left<typename L::Cdr, N - 1>::Value>::Value Value;
> };
> template <typename L> struct List_Left<L, 0> { typedef List<> Value; };
>
>
> template <typename L, int N> struct List_Select { typedef typename List_Select<typename L::Cdr, N - 1>::Value Value; };
> template <typename L> struct List_Select<L,0> { typedef typename L::Car Value; };
>
>
>
>
>
>
>
> template <typename T>
> struct ApplyReturnValue {
> void *data;
> ApplyReturnValue(void *data_) : data(data_) {}
> };
> template<typename T, typename U>
> void operator,(const T &value, const ApplyReturnValue &container) {
> if (container.data)
> *reinterpret_cast<U*>(container.data) = value;
> }
>
> template<typename T, typename U>
> void operator,(T &&value, const ApplyReturnValue &container) {
> if (container.data)
> *reinterpret_cast<U*>(container.data) = value;
> }
>
> template<typename T>
> void operator,(T, const ApplyReturnValue<void> &) {}
># 382 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs_impl.h"
> template <int...> struct IndexesList {};
> template <typename IndexList, int Right> struct IndexesAppend;
> template <int... Left, int Right> struct IndexesAppend<IndexesList<Left...>, Right>
> { typedef IndexesList<Left..., Right> Value; };
> template <int N> struct Indexes
> { typedef typename IndexesAppend<typename Indexes<N - 1>::Value, N - 1>::Value Value; };
> template <> struct Indexes<0> { typedef IndexesList<> Value; };
> template<typename Func> struct FunctionPointer { enum {ArgumentCount = -1}; };
>
> template <typename, typename, typename, typename> struct FunctorCall;
> template <int... I, typename... SignalArgs, typename R, typename Function>
> struct FunctorCall<IndexesList<I...>, List<SignalArgs...>, R, Function> {
> static void call(Function f, void **arg) {
> f((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[I+1]))...), ApplyReturnValue<R>(arg[0]);
> }
> };
> template <int... I, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
> struct FunctorCall<IndexesList<I...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...)> {
> static void call(SlotRet (Obj::*f)(SlotArgs...), Obj *o, void **arg) {
> (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[I+1]))...), ApplyReturnValue<R>(arg[0]);
> }
> };
>
> template<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...)>
> {
> typedef Obj Object;
> typedef List<Args...> Arguments;
> typedef Ret ReturnType;
> typedef Ret (Obj::*Function) (Args...);
> enum {ArgumentCount = sizeof...(Args)};
> template <typename SignalArgs, typename R>
> static void call(Function f, Obj *o, void **arg) {
> FunctorCall<typename Indexes<ArgumentCount>::Value, SignalArgs, R, Function>::call(f, o, arg);
> }
> };
>
> template<typename Ret, typename... Args> struct FunctionPointer<Ret (*) (Args...)>
> {
> typedef List<Args...> Arguments;
> typedef Ret ReturnType;
> typedef Ret (*Function) (Args...);
> enum {ArgumentCount = sizeof...(Args)};
> template <typename SignalArgs, typename R>
> static void call(Function f, void *, void **arg) {
> FunctorCall<typename Indexes<ArgumentCount>::Value, SignalArgs, R, Function>::call(f, arg);
> }
> };
>
> template<typename Function, int N> struct Functor
> {
> template <typename SignalArgs, typename R>
> static void call(Function &f, void *, void **arg) {
> FunctorCall<typename Indexes<N>::Value, SignalArgs, R, Function>::call(f, arg);
> }
> };
>
>
>
>
>
>
>
> template<typename A1, typename A2> struct AreArgumentsCompatible {
> static int test(A2);
> static char test(...);
> static A1 dummy();
> enum { value = sizeof(test(dummy())) == sizeof(int) };
> };
> template<typename A1, typename A2> struct AreArgumentsCompatible<A1, A2&> { enum { value = false }; };
> template<typename A> struct AreArgumentsCompatible<A&, A&> { enum { value = true }; };
>
> template<typename A> struct AreArgumentsCompatible<void, A> { enum { value = true }; };
> template<typename A> struct AreArgumentsCompatible<A, void> { enum { value = true }; };
> template<> struct AreArgumentsCompatible<void, void> { enum { value = true }; };
># 467 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs_impl.h"
> template <typename List1, typename List2> struct CheckCompatibleArguments { enum { value = false }; };
> template <> struct CheckCompatibleArguments<List<>, List<>> { enum { value = true }; };
> template <typename List1> struct CheckCompatibleArguments<List1, List<>> { enum { value = true }; };
> template <typename Arg1, typename Arg2, typename... Tail1, typename... Tail2>
> struct CheckCompatibleArguments<List<Arg1, Tail1...>, List<Arg2, Tail2...>>
> {
> enum { value = AreArgumentsCompatible<typename RemoveConstRef<Arg1>::Type, typename RemoveConstRef<Arg2>::Type>::value
> && CheckCompatibleArguments<List<Tail1...>, List<Tail2...>>::value };
> };
>
>
>}
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qobjectdefs_impl.h" 2
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs.h" 2
>
>
>
>
>
>
>class QByteArray;
>struct QArrayData;
>typedef QArrayData QByteArrayData;
>
>class QString;
># 133 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs.h"
>template <typename T>
>inline int qYouForgotTheQ_OBJECT_Macro(T, T) { return 0; }
>
>template <typename T1, typename T2>
>inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {}
># 208 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs.h"
>__attribute__((visibility("default"))) const char *qFlagLocation(const char *method);
># 236 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobjectdefs.h"
>class QObject;
>class QMetaMethod;
>class QMetaEnum;
>class QMetaProperty;
>class QMetaClassInfo;
>
>
>class __attribute__((visibility("default"))) QGenericArgument
>{
>public:
> inline QGenericArgument(const char *aName = 0, const void *aData = 0)
> : _data(aData), _name(aName) {}
> inline void *data() const { return const_cast<void *>(_data); }
> inline const char *name() const { return _name; }
>
>private:
> const void *_data;
> const char *_name;
>};
>
>class __attribute__((visibility("default"))) QGenericReturnArgument: public QGenericArgument
>{
>public:
> inline QGenericReturnArgument(const char *aName = 0, void *aData = 0)
> : QGenericArgument(aName, aData)
> {}
>};
>
>template <class T>
>class QArgument: public QGenericArgument
>{
>public:
> inline QArgument(const char *aName, const T &aData)
> : QGenericArgument(aName, static_cast<const void *>(&aData))
> {}
>};
>template <class T>
>class QArgument<T &>: public QGenericArgument
>{
>public:
> inline QArgument(const char *aName, T &aData)
> : QGenericArgument(aName, static_cast<const void *>(&aData))
> {}
>};
>
>
>template <typename T>
>class QReturnArgument: public QGenericReturnArgument
>{
>public:
> inline QReturnArgument(const char *aName, T &aData)
> : QGenericReturnArgument(aName, static_cast<void *>(&aData))
> {}
>};
>
>struct __attribute__((visibility("default"))) QMetaObject
>{
> class Connection;
> 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, int n = -1) 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 bool checkConnectArgs(const QMetaMethod &signal,
> const QMetaMethod &method);
> static QByteArray normalizedSignature(const char *method);
> static QByteArray normalizedType(const char *type);
>
>
> static Connection 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, const QMetaObject *, int local_signal_index, void **argv);
> static void activate(QObject *sender, int method_offset, int signal_offset, int local_signal_index, void **argv);
>
> 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,
> IndexOfMethod
> };
>
> int static_metacall(Call, int, void **) const;
> static int metacall(QObject *, Call, int, void **);
>
> struct {
> const QMetaObject *superdata;
> const QByteArrayData *stringdata;
> const uint *data;
> typedef void (*StaticMetacallFunction)(QObject *, QMetaObject::Call, int, void **);
> StaticMetacallFunction static_metacall;
> const QMetaObject **relatedMetaObjects;
> void *extradata;
> } d;
>};
>
>class __attribute__((visibility("default"))) QMetaObject::Connection {
> void *d_ptr;
> explicit Connection(void *data) : d_ptr(data) { }
> friend class QObject;
> friend struct QMetaObject;
>public:
> ~Connection();
> Connection();
> Connection(const Connection &other);
> Connection &operator=(const Connection &other);
>
>
>
> typedef void *Connection::*RestrictedBool;
> operator RestrictedBool() const { return d_ptr ? &Connection::d_ptr : 0; }
>
>
>
> inline Connection(Connection &&o) : d_ptr(o.d_ptr) { o.d_ptr = 0; }
> inline Connection &operator=(Connection &&other)
> { qSwap(d_ptr, other.d_ptr); return *this; }
>
>};
>
>inline const QMetaObject *QMetaObject::superClass() const
>{ return d.superdata; }
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qobjectdefs.h" 2
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qstring.h" 1
># 49 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qbytearray.h" 1
># 50 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qlist.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qalgorithms.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qiterator.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qiterator.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qiterator.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qiterator.h" 2
>
>
>
>
># 191 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qiterator.h"
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qiterator.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qrefcount.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h" 2
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iterator" 1 3
># 58 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iterator" 3
> 
># 59 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iterator" 3
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 1 3
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> 
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ios" 1 3
># 37 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ios" 3
> 
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ios" 3
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
>
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 64 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> class locale
> {
> public:
>
>
> typedef int category;
>
>
> class facet;
> class id;
> class _Impl;
>
> friend class facet;
> friend class _Impl;
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Cache>
> friend struct __use_cache;
># 100 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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);
># 119 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> locale() throw();
># 128 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> locale(const locale& __other) throw();
># 138 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> explicit
> locale(const char* __s);
># 153 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> locale(const locale& __base, const char* __s, category __cat);
># 166 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> locale(const locale& __base, const locale& __add, category __cat);
># 179 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> template<typename _Facet>
> locale(const locale& __other, _Facet* __f);
>
>
> ~locale() throw();
># 193 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> const locale&
> operator=(const locale& __other) throw();
># 208 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> template<typename _Facet>
> locale
> combine(const locale& __other) const;
>
>
>
>
>
>
> string
> name() const;
># 227 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> bool
> operator==(const locale& __other) const throw();
>
>
>
>
>
>
>
> bool
> operator!=(const locale& __other) const throw()
> { return !(this->operator==(__other)); }
># 255 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> template<typename _Char, typename _Traits, typename _Alloc>
> bool
> operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
> const basic_string<_Char, _Traits, _Alloc>& __s2) const;
># 271 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
># 306 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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);
> };
># 340 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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:
># 371 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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&);
> };
># 438 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> class locale::id
> {
> private:
> friend class locale;
> friend class locale::_Impl;
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
>
>
>
> mutable size_t _M_index;
>
>
> static _Atomic_word _S_refcount;
>
> void
> operator=(const id&);
>
> id(const id&);
>
> public:
>
>
>
> id() { }
>
> size_t
> _M_id() const throw();
> };
>
>
>
> class locale::_Impl
> {
> public:
>
> friend class locale;
> friend class locale::facet;
>
> template<typename _Facet>
> friend bool
> has_facet(const locale&) throw();
>
> template<typename _Facet>
> friend const _Facet&
> use_facet(const locale&);
>
> template<typename _Cache>
> friend struct __use_cache;
>
> private:
>
> _Atomic_word _M_refcount;
> const facet** _M_facets;
> size_t _M_facets_size;
> const facet** _M_caches;
> char** _M_names;
> static const locale::id* const _S_id_ctype[];
> static const locale::id* const _S_id_numeric[];
> static const locale::id* const _S_id_collate[];
> static const locale::id* const _S_id_time[];
> static const locale::id* const _S_id_monetary[];
> static const locale::id* const _S_id_messages[];
> static const locale::id* const* const _S_facet_categories[];
>
> void
> _M_add_reference() throw()
> { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
>
> void
> _M_remove_reference() throw()
> {
>
> ;
> if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
> {
> ;
> try
> { delete this; }
> catch(...)
> { }
> }
> }
>
> _Impl(const _Impl&, size_t);
> _Impl(const char*, size_t);
> _Impl(size_t) throw();
>
> ~_Impl() throw();
>
> _Impl(const _Impl&);
>
> void
> operator=(const _Impl&);
>
> bool
> _M_check_same_name()
> {
> bool __ret = true;
> if (_M_names[1])
>
> for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
> __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
> return __ret;
> }
>
> void
> _M_replace_categories(const _Impl*, category);
>
> void
> _M_replace_category(const _Impl*, const locale::id* const*);
>
> void
> _M_replace_facet(const _Impl*, const locale::id*);
>
> void
> _M_install_facet(const locale::id*, const facet*);
>
> template<typename _Facet>
> void
> _M_init_facet(_Facet* __facet)
> { _M_install_facet(&_Facet::id, __facet); }
>
> void
> _M_install_cache(const facet*, size_t);
> };
># 585 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> template<typename _CharT>
> class 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;
># 612 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> explicit
> collate(size_t __refs = 0)
> : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
> { }
># 626 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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))
> { }
># 643 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 662 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> string_type
> transform(const _CharT* __lo, const _CharT* __hi) const
> { return this->do_transform(__lo, __hi); }
># 676 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 705 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> virtual int
> do_compare(const _CharT* __lo1, const _CharT* __hi1,
> const _CharT* __lo2, const _CharT* __hi2) const;
># 719 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> virtual string_type
> do_transform(const _CharT* __lo, const _CharT* __hi) const;
># 732 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 3
> virtual long
> do_hash(const _CharT* __lo, const _CharT* __hi) const;
> };
>
> template<typename _CharT>
> locale::id collate<_CharT>::id;
>
>
> template<>
> int
> collate<char>::_M_compare(const char*, const char*) const throw();
>
> template<>
> size_t
> collate<char>::_M_transform(char*, const char*, size_t) const throw();
>
>
> template<>
> int
> collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
>
> template<>
> size_t
> collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
>
>
>
> template<typename _CharT>
> class 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-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.tcc" 1 3
># 37 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.tcc" 3
> 
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Facet>
> 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<typename _Facet>
> locale
> locale::
> combine(const locale& __other) const
> {
> _Impl* __tmp = new _Impl(*_M_impl, 1);
> try
> {
> __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
> }
> catch(...)
> {
> __tmp->_M_remove_reference();
> throw;
> }
> return locale(__tmp);
> }
>
> template<typename _CharT, typename _Traits, typename _Alloc>
> bool
> locale::
> operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
> const basic_string<_CharT, _Traits, _Alloc>& __s2) const
> {
> typedef std::collate<_CharT> __collate_type;
> const __collate_type& __collate = use_facet<__collate_type>(*this);
> return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
> __s2.data(), __s2.data() + __s2.length()) < 0);
> }
># 101 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.tcc" 3
> template<typename _Facet>
> bool
> has_facet(const locale& __loc) throw()
> {
> const size_t __i = _Facet::id._M_id();
> const locale::facet** __facets = __loc._M_impl->_M_facets;
> return (__i < __loc._M_impl->_M_facets_size
>
> && dynamic_cast<const _Facet*>(__facets[__i]));
>
>
>
> }
># 128 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.tcc" 3
> template<typename _Facet>
> const _Facet&
> use_facet(const locale& __loc)
> {
> const size_t __i = _Facet::id._M_id();
> const locale::facet** __facets = __loc._M_impl->_M_facets;
> if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
> __throw_bad_cast();
>
> return dynamic_cast<const _Facet&>(*__facets[__i]);
>
>
>
> }
>
>
>
> template<typename _CharT>
> int
> collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
> { return 0; }
>
>
> template<typename _CharT>
> size_t
> collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
> { return 0; }
>
> template<typename _CharT>
> 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 _CharT>
> 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<typename _CharT>
> 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<unsigned long>::
> __digits - 7)));
> return static_cast<long>(__val);
> }
>
>
>
>
> extern template class collate<char>;
> extern template class collate_byname<char>;
>
> extern template
> const collate<char>&
> use_facet<collate<char> >(const locale&);
>
> extern template
> bool
> has_facet<collate<char> >(const locale&);
>
>
> extern template class collate<wchar_t>;
> extern template class collate_byname<wchar_t>;
>
> extern template
> const collate<wchar_t>&
> use_facet<collate<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<collate<wchar_t> >(const locale&);
>
>
>
>
>}
># 790 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_classes.h" 2 3
># 44 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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 constexpr _Ios_Fmtflags
> operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline constexpr _Ios_Fmtflags
> operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline constexpr _Ios_Fmtflags
> operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
> { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline constexpr _Ios_Fmtflags
> operator~(_Ios_Fmtflags __a)
> { return _Ios_Fmtflags(~static_cast<int>(__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 constexpr _Ios_Openmode
> operator&(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline constexpr _Ios_Openmode
> operator|(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline constexpr _Ios_Openmode
> operator^(_Ios_Openmode __a, _Ios_Openmode __b)
> { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline constexpr _Ios_Openmode
> operator~(_Ios_Openmode __a)
> { return _Ios_Openmode(~static_cast<int>(__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 constexpr _Ios_Iostate
> operator&(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
>
> inline constexpr _Ios_Iostate
> operator|(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
>
> inline constexpr _Ios_Iostate
> operator^(_Ios_Iostate __a, _Ios_Iostate __b)
> { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
>
> inline constexpr _Ios_Iostate
> operator~(_Ios_Iostate __a)
> { return _Ios_Iostate(~static_cast<int>(__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
> };
># 201 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> class ios_base
> {
> public:
>
>
>
>
>
>
>
> class failure : public exception
> {
> public:
>
>
> explicit
> failure(const string& __str) throw();
>
>
>
> virtual
> ~failure() throw();
>
> virtual const char*
> what() const throw();
>
> private:
> string _M_msg;
> };
># 257 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
># 332 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
># 363 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
># 395 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
># 421 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> enum event
> {
> erase_event,
> imbue_event,
> copyfmt_event
> };
># 438 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> typedef void (*event_callback) (event __e, ios_base& __b, int __i);
># 450 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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; }
># 563 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> fmtflags
> flags(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags = __fmtfl;
> return __old;
> }
># 579 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> fmtflags
> setf(fmtflags __fmtfl)
> {
> fmtflags __old = _M_flags;
> _M_flags |= __fmtfl;
> return __old;
> }
># 596 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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; }
># 622 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 673 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> static bool
> sync_with_stdio(bool __sync = true);
># 685 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> locale
> imbue(const locale& __loc) throw();
># 696 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> locale
> getloc() const
> { return _M_ios_locale; }
># 707 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> const locale&
> _M_getloc() const
> { return _M_ios_locale; }
># 726 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> static int
> xalloc() throw();
># 742 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 763 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 780 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ios_base.h" 3
> virtual ~ios_base();
>
> protected:
> ios_base() throw ();
>
>
>
> private:
> ios_base(const ios_base&);
>
> ios_base&
> operator=(const ios_base&);
> };
>
>
>
> 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;
> }
>
>
>}
># 44 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ios" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 1 3
># 37 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> 
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
># 46 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
> basic_streambuf<_CharT, _Traits>*, bool&);
># 116 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> template<typename _CharT, typename _Traits>
> class basic_streambuf
> {
> public:
>
>
>
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename traits_type::int_type int_type;
> typedef typename traits_type::pos_type pos_type;
> typedef typename traits_type::off_type off_type;
>
>
>
>
> typedef basic_streambuf<char_type, traits_type> __streambuf_type;
>
>
> friend class basic_ios<char_type, traits_type>;
> friend class basic_istream<char_type, traits_type>;
> friend class basic_ostream<char_type, traits_type>;
> friend class istreambuf_iterator<char_type, traits_type>;
> friend class ostreambuf_iterator<char_type, traits_type>;
>
> friend streamsize
> __copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&);
>
> template<bool _IsMove, typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> _CharT2*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT2>,
> istreambuf_iterator<_CharT2>, _CharT2*);
>
> template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> istreambuf_iterator<_CharT2> >::__type
> find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> const _CharT2&);
>
> template<typename _CharT2, typename _Traits2>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
>
> template<typename _CharT2, typename _Traits2, typename _Alloc>
> friend basic_istream<_CharT2, _Traits2>&
> operator>>(basic_istream<_CharT2, _Traits2>&,
> basic_string<_CharT2, _Traits2, _Alloc>&);
>
> template<typename _CharT2, typename _Traits2, typename _Alloc>
> friend basic_istream<_CharT2, _Traits2>&
> getline(basic_istream<_CharT2, _Traits2>&,
> basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
>
> protected:
># 182 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> 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()
> { }
># 206 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> locale
> pubimbue(const locale& __loc)
> {
> locale __tmp(this->getloc());
> this->imbue(__loc);
> _M_buf_locale = __loc;
> return __tmp;
> }
># 223 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> locale
> getloc() const
> { return _M_buf_locale; }
># 236 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> __streambuf_type*
> pubsetbuf(char_type* __s, streamsize __n)
> { return this->setbuf(__s, __n); }
># 248 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 260 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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(); }
># 281 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> streamsize
> in_avail()
> {
> const streamsize __ret = this->egptr() - this->gptr();
> return __ret ? __ret : this->showmanyc();
> }
># 295 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 313 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 335 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 354 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> streamsize
> sgetn(char_type* __s, streamsize __n)
> { return this->xsgetn(__s, __n); }
># 369 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 394 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 421 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 447 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> streamsize
> sputn(const char_type* __s, streamsize __n)
> { return this->xsputn(__s, __n); }
>
> protected:
># 461 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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())
> { }
># 479 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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; }
># 495 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> void
> gbump(int __n) { _M_in_cur += __n; }
># 506 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 526 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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; }
># 542 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> void
> pbump(int __n) { _M_out_cur += __n; }
># 552 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> void
> setp(char_type* __pbeg, char_type* __pend)
> {
> _M_out_beg = _M_out_cur = __pbeg;
> _M_out_end = __pend;
> }
># 573 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual void
> imbue(const locale& __loc)
> { }
># 588 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual basic_streambuf<char_type,_Traits>*
> setbuf(char_type*, streamsize)
> { return this; }
># 599 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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)); }
># 611 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual pos_type
> seekpos(pos_type,
> ios_base::openmode = ios_base::in | ios_base::out)
> { return pos_type(off_type(-1)); }
># 624 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual int
> sync() { return 0; }
># 646 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual streamsize
> showmanyc() { return 0; }
># 662 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual streamsize
> xsgetn(char_type* __s, streamsize __n);
># 684 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual int_type
> underflow()
> { return traits_type::eof(); }
># 697 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 721 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual int_type
> pbackfail(int_type __c = traits_type::eof())
> { return traits_type::eof(); }
># 739 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual streamsize
> xsputn(const char_type* __s, streamsize __n);
># 765 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 3
> virtual int_type
> overflow(int_type __c = traits_type::eof())
> { return traits_type::eof(); }
>
>
>
> public:
># 780 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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 __streambuf_type& __sb)
> : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
> _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
> _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
> _M_buf_locale(__sb._M_buf_locale)
> { }
>
> __streambuf_type&
> operator=(const __streambuf_type&) { return *this; };
> };
>
>
> template<>
> streamsize
> __copy_streambufs_eof(basic_streambuf<char>* __sbin,
> basic_streambuf<char>* __sbout, bool& __ineof);
>
> template<>
> streamsize
> __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
> basic_streambuf<wchar_t>* __sbout, bool& __ineof);
>
>
>
>}
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/streambuf.tcc" 1 3
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/streambuf.tcc" 3
> 
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/streambuf.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_streambuf<_CharT, _Traits>::
> xsgetn(char_type* __s, streamsize __n)
> {
> streamsize __ret = 0;
> while (__ret < __n)
> {
> const streamsize __buf_len = this->egptr() - this->gptr();
> if (__buf_len)
> {
> const streamsize __remaining = __n - __ret;
> const streamsize __len = std::min(__buf_len, __remaining);
> traits_type::copy(__s, this->gptr(), __len);
> __ret += __len;
> __s += __len;
> this->__safe_gbump(__len);
> }
>
> if (__ret < __n)
> {
> const int_type __c = this->uflow();
> if (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> traits_type::assign(*__s++, traits_type::to_char_type(__c));
> ++__ret;
> }
> else
> break;
> }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_streambuf<_CharT, _Traits>::
> xsputn(const char_type* __s, streamsize __n)
> {
> streamsize __ret = 0;
> while (__ret < __n)
> {
> const streamsize __buf_len = this->epptr() - this->pptr();
> if (__buf_len)
> {
> const streamsize __remaining = __n - __ret;
> const streamsize __len = std::min(__buf_len, __remaining);
> traits_type::copy(this->pptr(), __s, __len);
> __ret += __len;
> __s += __len;
> this->__safe_pbump(__len);
> }
>
> if (__ret < __n)
> {
> int_type __c = this->overflow(traits_type::to_int_type(*__s));
> if (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> ++__ret;
> ++__s;
> }
> else
> break;
> }
> }
> return __ret;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> streamsize
> __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout,
> bool& __ineof)
> {
> streamsize __ret = 0;
> __ineof = true;
> typename _Traits::int_type __c = __sbin->sgetc();
> while (!_Traits::eq_int_type(__c, _Traits::eof()))
> {
> __c = __sbout->sputc(_Traits::to_char_type(__c));
> if (_Traits::eq_int_type(__c, _Traits::eof()))
> {
> __ineof = false;
> break;
> }
> ++__ret;
> __c = __sbin->snextc();
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> inline streamsize
> __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
> basic_streambuf<_CharT, _Traits>* __sbout)
> {
> bool __ineof;
> return __copy_streambufs_eof(__sbin, __sbout, __ineof);
> }
>
>
>
>
> extern template class basic_streambuf<char>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<char>*,
> basic_streambuf<char>*);
> extern template
> streamsize
> __copy_streambufs_eof(basic_streambuf<char>*,
> basic_streambuf<char>*, bool&);
>
>
> extern template class basic_streambuf<wchar_t>;
> extern template
> streamsize
> __copy_streambufs(basic_streambuf<wchar_t>*,
> basic_streambuf<wchar_t>*);
> extern template
> streamsize
> __copy_streambufs_eof(basic_streambuf<wchar_t>*,
> basic_streambuf<wchar_t>*, bool&);
>
>
>
>
>}
># 827 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/streambuf" 2 3
># 45 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ios" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 1 3
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> 
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwctype" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwctype" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwctype" 3
># 52 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwctype" 3
># 1 "/usr/include/wctype.h" 1 3 4
># 34 "/usr/include/wctype.h" 3 4
># 1 "/usr/include/wchar.h" 1 3 4
># 35 "/usr/include/wctype.h" 2 3 4
># 50 "/usr/include/wctype.h" 3 4
>
>
>
>typedef unsigned long int wctype_t;
>
># 72 "/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 ();
># 172 "/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 ();
>
>
>}
># 214 "/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 ();
>
>
>
>}
># 53 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cwctype" 2 3
># 82 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
>}
>
>
>
>
>
>
>
>namespace std
>{
>
> using std::iswblank;
>
>}
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cctype" 1 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cctype" 3
> 
># 42 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/cctype" 3
># 43 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/ctype_base.h" 1 3
># 37 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/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;
> };
>
>
>}
># 44 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 2 3
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/streambuf_iterator.h" 1 3
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/streambuf_iterator.h" 3
> 
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/streambuf_iterator.h" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 51 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/streambuf_iterator.h" 3
> template<typename _CharT, typename _Traits>
> class istreambuf_iterator
> : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
> _CharT*,
>
>
> _CharT>
>
>
>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef typename _Traits::int_type int_type;
> typedef basic_streambuf<_CharT, _Traits> streambuf_type;
> typedef basic_istream<_CharT, _Traits> istream_type;
>
>
> template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> ostreambuf_iterator<_CharT2> >::__type
> copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> ostreambuf_iterator<_CharT2>);
>
> template<bool _IsMove, typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> _CharT2*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT2>,
> istreambuf_iterator<_CharT2>, _CharT2*);
>
> template<typename _CharT2>
> friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
> istreambuf_iterator<_CharT2> >::__type
> find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
> const _CharT2&);
>
> private:
>
>
>
>
>
>
>
> mutable streambuf_type* _M_sbuf;
> mutable int_type _M_c;
>
> public:
>
> constexpr istreambuf_iterator() noexcept
> : _M_sbuf(0), _M_c(traits_type::eof()) { }
>
>
> istreambuf_iterator(const istreambuf_iterator&) noexcept = default;
>
> ~istreambuf_iterator() = default;
>
>
>
> istreambuf_iterator(istream_type& __s) noexcept
> : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
>
>
> istreambuf_iterator(streambuf_type* __s) noexcept
> : _M_sbuf(__s), _M_c(traits_type::eof()) { }
>
>
>
>
> char_type
> operator*() const
> {
>
>
>
>
>
>
>
> return traits_type::to_char_type(_M_get());
> }
>
>
> istreambuf_iterator&
> operator++()
> {
>
>
> ;
> if (_M_sbuf)
> {
> _M_sbuf->sbumpc();
> _M_c = traits_type::eof();
> }
> return *this;
> }
>
>
> istreambuf_iterator
> operator++(int)
> {
>
>
> ;
>
> istreambuf_iterator __old = *this;
> if (_M_sbuf)
> {
> __old._M_c = _M_sbuf->sbumpc();
> _M_c = traits_type::eof();
> }
> return __old;
> }
>
>
>
>
>
> bool
> equal(const istreambuf_iterator& __b) const
> { return _M_at_eof() == __b._M_at_eof(); }
>
> private:
> int_type
> _M_get() const
> {
> const int_type __eof = traits_type::eof();
> int_type __ret = __eof;
> if (_M_sbuf)
> {
> if (!traits_type::eq_int_type(_M_c, __eof))
> __ret = _M_c;
> else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
> __eof))
> _M_c = __ret;
> else
> _M_sbuf = 0;
> }
> return __ret;
> }
>
> bool
> _M_at_eof() const
> {
> const int_type __eof = traits_type::eof();
> return traits_type::eq_int_type(_M_get(), __eof);
> }
> };
>
> template<typename _CharT, typename _Traits>
> inline bool
> operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
> const istreambuf_iterator<_CharT, _Traits>& __b)
> { return __a.equal(__b); }
>
> template<typename _CharT, typename _Traits>
> inline bool
> operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
> const istreambuf_iterator<_CharT, _Traits>& __b)
> { return !__a.equal(__b); }
>
>
> template<typename _CharT, typename _Traits>
> class ostreambuf_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _Traits traits_type;
> typedef basic_streambuf<_CharT, _Traits> streambuf_type;
> typedef basic_ostream<_CharT, _Traits> ostream_type;
>
>
> template<typename _CharT2>
> 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) noexcept
> : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
>
>
> ostreambuf_iterator(streambuf_type* __s) noexcept
> : _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 noexcept
> { 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 _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT> >::__type
> copy(istreambuf_iterator<_CharT> __first,
> istreambuf_iterator<_CharT> __last,
> ostreambuf_iterator<_CharT> __result)
> {
> if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
> {
> bool __ineof;
> __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
> if (!__ineof)
> __result._M_failed = true;
> }
> return __result;
> }
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT> >::__type
> __copy_move_a2(_CharT* __first, _CharT* __last,
> ostreambuf_iterator<_CharT> __result)
> {
> const streamsize __num = __last - __first;
> if (__num > 0)
> __result._M_put(__first, __num);
> return __result;
> }
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> ostreambuf_iterator<_CharT> >::__type
> __copy_move_a2(const _CharT* __first, const _CharT* __last,
> ostreambuf_iterator<_CharT> __result)
> {
> const streamsize __num = __last - __first;
> if (__num > 0)
> __result._M_put(__first, __num);
> return __result;
> }
>
> template<bool _IsMove, typename _CharT>
> typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
> _CharT*>::__type
> __copy_move_a2(istreambuf_iterator<_CharT> __first,
> istreambuf_iterator<_CharT> __last, _CharT* __result)
> {
> typedef istreambuf_iterator<_CharT> __is_iterator_type;
> typedef typename __is_iterator_type::traits_type traits_type;
> typedef typename __is_iterator_type::streambuf_type streambuf_type;
> typedef typename traits_type::int_type int_type;
>
> if (__first._M_sbuf && !__last._M_sbuf)
> {
> streambuf_type* __sb = __first._M_sbuf;
> int_type __c = __sb->sgetc();
> while (!traits_type::eq_int_type(__c, traits_type::eof()))
> {
> const streamsize __n = __sb->egptr() - __sb->gptr();
> if (__n > 1)
> {
> traits_type::copy(__result, __sb->gptr(), __n);
> __sb->__safe_gbump(__n);
> __result += __n;
> __c = __sb->underflow();
> }
> else
> {
> *__result++ = traits_type::to_char_type(__c);
> __c = __sb->snextc();
> }
> }
> }
> return __result;
> }
>
> template<typename _CharT>
> 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;
> }
>
>
>
>
>}
># 51 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 2 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 66 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> template<typename _Tp>
> void
> __convert_to_v(const char*, _Tp&, ios_base::iostate&,
> const __c_locale&) throw();
>
>
> template<>
> void
> __convert_to_v(const char*, float&, ios_base::iostate&,
> const __c_locale&) throw();
>
> template<>
> void
> __convert_to_v(const char*, double&, ios_base::iostate&,
> const __c_locale&) throw();
>
> template<>
> void
> __convert_to_v(const char*, long double&, ios_base::iostate&,
> const __c_locale&) throw();
>
>
>
> template<typename _CharT, typename _Traits>
> struct __pad
> {
> static void
> _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
> const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
> };
>
>
>
>
>
>
> template<typename _CharT>
> _CharT*
> __add_grouping(_CharT* __s, _CharT __sep,
> const char* __gbeg, size_t __gsize,
> const _CharT* __first, const _CharT* __last);
>
>
>
>
> template<typename _CharT>
> inline
> ostreambuf_iterator<_CharT>
> __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
> {
> __s._M_put(__ws, __len);
> return __s;
> }
>
>
> template<typename _CharT, typename _OutIter>
> inline
> _OutIter
> __write(_OutIter __s, const _CharT* __ws, int __len)
> {
> for (int __j = 0; __j < __len; __j++, ++__s)
> *__s = __ws[__j];
> return __s;
> }
># 144 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> template<typename _CharT>
> class __ctype_abstract_base : public locale::facet, public ctype_base
> {
> public:
>
>
> typedef _CharT char_type;
># 163 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> bool
> is(mask __m, char_type __c) const
> { return this->do_is(__m, __c); }
># 180 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 196 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 212 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 226 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 241 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 255 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 270 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 287 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char_type
> widen(char __c) const
> { return this->do_widen(__c); }
># 306 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 325 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char
> narrow(char_type __c, char __dfault) const
> { return this->do_narrow(__c, __dfault); }
># 347 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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() { }
># 372 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const = 0;
># 391 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi,
> mask* __vec) const = 0;
># 410 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 429 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const = 0;
># 447 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type __c) const = 0;
># 464 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const = 0;
># 480 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type __c) const = 0;
># 497 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const = 0;
># 516 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const = 0;
># 537 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
># 558 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char __dfault) const = 0;
># 583 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> };
># 606 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> template<typename _CharT>
> 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<typename _CharT>
> locale::id ctype<_CharT>::id;
># 675 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> template<>
> class ctype<char> : public locale::facet, public ctype_base
> {
> public:
>
>
> typedef char char_type;
>
> protected:
>
> __c_locale _M_c_locale_ctype;
> bool _M_del;
> __to_type _M_toupper;
> __to_type _M_tolower;
> const mask* _M_table;
> mutable char _M_widen_ok;
> mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
> mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
> mutable char _M_narrow_ok;
>
>
> public:
>
> static locale::id id;
>
> static const size_t table_size = 1 + static_cast<unsigned char>(-1);
># 712 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> explicit
> ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
># 725 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> explicit
> ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
> size_t __refs = 0);
># 738 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> inline bool
> is(mask __m, char __c) const;
># 753 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> inline const char*
> is(const char* __lo, const char* __hi, mask* __vec) const;
># 767 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> inline const char*
> scan_is(mask __m, const char* __lo, const char* __hi) const;
># 781 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> inline const char*
> scan_not(mask __m, const char* __lo, const char* __hi) const;
># 796 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char_type
> toupper(char_type __c) const
> { return this->do_toupper(__c); }
># 813 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> const char_type*
> toupper(char_type *__lo, const char_type* __hi) const
> { return this->do_toupper(__lo, __hi); }
># 829 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char_type
> tolower(char_type __c) const
> { return this->do_tolower(__c); }
># 846 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> const char_type*
> tolower(char_type* __lo, const char_type* __hi) const
> { return this->do_tolower(__lo, __hi); }
># 866 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char_type
> widen(char __c) const
> {
> if (_M_widen_ok)
> return _M_widen[static_cast<unsigned char>(__c)];
> this->_M_widen_init();
> return this->do_widen(__c);
> }
># 893 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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);
> }
># 924 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char
> narrow(char_type __c, char __dfault) const
> {
> if (_M_narrow[static_cast<unsigned char>(__c)])
> return _M_narrow[static_cast<unsigned char>(__c)];
> const char __t = do_narrow(__c, __dfault);
> if (__t != __dfault)
> _M_narrow[static_cast<unsigned char>(__c)] = __t;
> return __t;
> }
># 957 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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();
># 1006 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type __c) const;
># 1023 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1039 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type __c) const;
># 1056 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1076 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const
> { return __c; }
># 1099 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 1125 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char __dfault) const
> { return __c; }
># 1151 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> };
># 1176 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> template<>
> class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
> {
> public:
>
>
> typedef wchar_t char_type;
> typedef wctype_t __wmask_type;
>
> protected:
> __c_locale _M_c_locale_ctype;
>
>
> bool _M_narrow_ok;
> char _M_narrow[128];
> wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
>
>
> mask _M_bit[16];
> __wmask_type _M_wmask[16];
>
> public:
>
>
> static locale::id id;
># 1209 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> explicit
> ctype(size_t __refs = 0);
># 1220 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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();
># 1244 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual bool
> do_is(mask __m, char_type __c) const;
># 1263 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
># 1281 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
># 1299 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_scan_not(mask __m, const char_type* __lo,
> const char_type* __hi) const;
># 1316 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_toupper(char_type __c) const;
># 1333 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_toupper(char_type* __lo, const char_type* __hi) const;
># 1349 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_tolower(char_type __c) const;
># 1366 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char_type*
> do_tolower(char_type* __lo, const char_type* __hi) const;
># 1386 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_widen(char __c) const;
># 1408 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual const char*
> do_widen(const char* __lo, const char* __hi, char_type* __to) const;
># 1431 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char
> do_narrow(char_type __c, char __dfault) const;
># 1457 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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<typename _CharT>
> 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<char> : public ctype<char>
> {
> public:
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~ctype_byname();
> };
>
>
> template<>
> class ctype_byname<wchar_t> : public ctype<wchar_t>
> {
> public:
> explicit
> ctype_byname(const char* __s, size_t __refs = 0);
>
> protected:
> virtual
> ~ctype_byname();
> };
>
>
>
>}
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
># 37 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/x86_64-redhat-linux/bits/ctype_inline.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> bool
> ctype<char>::
> is(mask __m, char __c) const
> { return _M_table[static_cast<unsigned char>(__c)] & __m; }
>
> const char*
> ctype<char>::
> is(const char* __low, const char* __high, mask* __vec) const
> {
> while (__low < __high)
> *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
> return __high;
> }
>
> const char*
> ctype<char>::
> scan_is(mask __m, const char* __low, const char* __high) const
> {
> while (__low < __high
> && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
> ++__low;
> return __low;
> }
>
> const char*
> ctype<char>::
> scan_not(mask __m, const char* __low, const char* __high) const
> {
> while (__low < __high
> && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
> ++__low;
> return __low;
> }
>
>
>}
># 1514 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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<typename _CharT>
> 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<typename _CharT>
> __numpunct_cache<_CharT>::~__numpunct_cache()
> {
> if (_M_allocated)
> {
> delete [] _M_grouping;
> delete [] _M_truename;
> delete [] _M_falsename;
> }
> }
># 1642 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> template<typename _CharT>
> 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(); }
># 1680 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> explicit
> numpunct(__cache_type* __cache, size_t __refs = 0)
> : facet(__refs), _M_data(__cache)
> { _M_initialize_numpunct(); }
># 1694 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> explicit
> numpunct(__c_locale __cloc, size_t __refs = 0)
> : facet(__refs), _M_data(0)
> { _M_initialize_numpunct(__cloc); }
># 1708 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char_type
> decimal_point() const
> { return this->do_decimal_point(); }
># 1721 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> char_type
> thousands_sep() const
> { return this->do_thousands_sep(); }
># 1752 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> string
> grouping() const
> { return this->do_grouping(); }
># 1765 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> string_type
> truename() const
> { return this->do_truename(); }
># 1778 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> string_type
> falsename() const
> { return this->do_falsename(); }
>
> protected:
>
> virtual
> ~numpunct();
># 1795 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_decimal_point() const
> { return _M_data->_M_decimal_point; }
># 1807 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual char_type
> do_thousands_sep() const
> { return _M_data->_M_thousands_sep; }
># 1820 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual string
> do_grouping() const
> { return _M_data->_M_grouping; }
># 1833 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual string_type
> do_truename() const
> { return _M_data->_M_truename; }
># 1846 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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<typename _CharT>
> locale::id numpunct<_CharT>::id;
>
> template<>
> numpunct<char>::~numpunct();
>
> template<>
> void
> numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
>
>
> template<>
> numpunct<wchar_t>::~numpunct();
>
> template<>
> void
> numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
>
>
>
> template<typename _CharT>
> 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() { }
> };
>
>
># 1916 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> template<typename _CharT, typename _InIter>
> class num_get : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _InIter iter_type;
>
>
>
> static locale::id id;
># 1937 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> explicit
> num_get(size_t __refs = 0) : facet(__refs) { }
># 1963 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 1999 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 2058 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 2100 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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() { }
>
> iter_type
> _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
> string&) const;
>
> template<typename _ValueT>
> iter_type
> _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
> _ValueT&) const;
>
> template<typename _CharT2>
> typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
> _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
> {
> int __ret = -1;
> if (__len <= 10)
> {
> if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
> __ret = __c - _CharT2('0');
> }
> else
> {
> if (__c >= _CharT2('0') && __c <= _CharT2('9'))
> __ret = __c - _CharT2('0');
> else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
> __ret = 10 + (__c - _CharT2('a'));
> else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
> __ret = 10 + (__c - _CharT2('A'));
> }
> return __ret;
> }
>
> template<typename _CharT2>
> typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
> int>::__type
> _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
> {
> int __ret = -1;
> const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
> if (__q)
> {
> __ret = __q - __zero;
> if (__ret > 15)
> __ret -= 6;
> }
> return __ret;
> }
># 2171 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
># 2234 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> };
>
> template<typename _CharT, typename _InIter>
> locale::id num_get<_CharT, _InIter>::id;
># 2252 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> template<typename _CharT, typename _OutIter>
> class num_put : public locale::facet
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef _OutIter iter_type;
>
>
>
> static locale::id id;
># 2273 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> explicit
> num_put(size_t __refs = 0) : facet(__refs) { }
># 2291 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 2333 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 2396 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 2421 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> iter_type
> put(iter_type __s, ios_base& __io, char_type __fill,
> const void* __v) const
> { return this->do_put(__s, __io, __fill, __v); }
>
> protected:
> template<typename _ValueT>
> iter_type
> _M_insert_float(iter_type, ios_base& __io, char_type __fill,
> char __mod, _ValueT __v) const;
>
> void
> _M_group_float(const char* __grouping, size_t __grouping_size,
> char_type __sep, const char_type* __p, char_type* __new,
> char_type* __cs, int& __len) const;
>
> template<typename _ValueT>
> iter_type
> _M_insert_int(iter_type, ios_base& __io, char_type __fill,
> _ValueT __v) const;
>
> void
> _M_group_int(const char* __grouping, size_t __grouping_size,
> char_type __sep, ios_base& __io, char_type* __new,
> char_type* __cs, int& __len) const;
>
> void
> _M_pad(char_type __fill, streamsize __w, ios_base& __io,
> char_type* __new, const char_type* __cs, int& __len) const;
>
>
> virtual
> ~num_put() { };
># 2469 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 3
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> long long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
> virtual iter_type
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> unsigned long long __v) const
> { return _M_insert_int(__s, __io, __fill, __v); }
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type, double) const;
>
>
>
>
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type, long double) const;
>
>
> virtual iter_type
> do_put(iter_type, ios_base&, char_type, const void*) const;
>
>
>
>
>
>
>
> };
>
> template <typename _CharT, typename _OutIter>
> locale::id num_put<_CharT, _OutIter>::id;
>
>
>
>
>
>
>
>
>
> template<typename _CharT>
> inline bool
> isspace(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
>
>
> template<typename _CharT>
> inline bool
> isprint(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
>
>
> template<typename _CharT>
> inline bool
> iscntrl(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
>
>
> template<typename _CharT>
> inline bool
> isupper(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
>
>
> template<typename _CharT>
> inline bool
> islower(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
>
>
> template<typename _CharT>
> inline bool
> isalpha(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
>
>
> template<typename _CharT>
> inline bool
> isdigit(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
>
>
> template<typename _CharT>
> inline bool
> ispunct(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
>
>
> template<typename _CharT>
> inline bool
> isxdigit(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
>
>
> template<typename _CharT>
> inline bool
> isalnum(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
>
>
> template<typename _CharT>
> inline bool
> isgraph(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
>
>
> template<typename _CharT>
> inline _CharT
> toupper(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
>
>
> template<typename _CharT>
> inline _CharT
> tolower(_CharT __c, const locale& __loc)
> { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
>
>
>}
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.tcc" 1 3
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.tcc" 3
> 
># 36 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
> template<typename _Facet>
> struct __use_cache
> {
> const _Facet*
> operator() (const locale& __loc) const;
> };
>
>
> template<typename _CharT>
> struct __use_cache<__numpunct_cache<_CharT> >
> {
> const __numpunct_cache<_CharT>*
> operator() (const locale& __loc) const
> {
> const size_t __i = numpunct<_CharT>::id._M_id();
> const locale::facet** __caches = __loc._M_impl->_M_caches;
> if (!__caches[__i])
> {
> __numpunct_cache<_CharT>* __tmp = 0;
> try
> {
> __tmp = new __numpunct_cache<_CharT>;
> __tmp->_M_cache(__loc);
> }
> catch(...)
> {
> delete __tmp;
> throw;
> }
> __loc._M_impl->_M_install_cache(__tmp, __i);
> }
> return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
> }
> };
>
> template<typename _CharT>
> void
> __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
> {
> _M_allocated = true;
>
> const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
>
> char* __grouping = 0;
> _CharT* __truename = 0;
> _CharT* __falsename = 0;
> try
> {
> _M_grouping_size = __np.grouping().size();
> __grouping = new char[_M_grouping_size];
> __np.grouping().copy(__grouping, _M_grouping_size);
> _M_grouping = __grouping;
> _M_use_grouping = (_M_grouping_size
> && static_cast<signed char>(_M_grouping[0]) > 0
> && (_M_grouping[0]
> != __gnu_cxx::__numeric_traits<char>::__max));
>
> _M_truename_size = __np.truename().size();
> __truename = new _CharT[_M_truename_size];
> __np.truename().copy(__truename, _M_truename_size);
> _M_truename = __truename;
>
> _M_falsename_size = __np.falsename().size();
> __falsename = new _CharT[_M_falsename_size];
> __np.falsename().copy(__falsename, _M_falsename_size);
> _M_falsename = __falsename;
>
> _M_decimal_point = __np.decimal_point();
> _M_thousands_sep = __np.thousands_sep();
>
> const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
> __ct.widen(__num_base::_S_atoms_out,
> __num_base::_S_atoms_out
> + __num_base::_S_oend, _M_atoms_out);
> __ct.widen(__num_base::_S_atoms_in,
> __num_base::_S_atoms_in
> + __num_base::_S_iend, _M_atoms_in);
> }
> catch(...)
> {
> delete [] __grouping;
> delete [] __truename;
> delete [] __falsename;
> throw;
> }
> }
># 138 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.tcc" 3
> __attribute__ ((__pure__)) bool
> __verify_grouping(const char* __grouping, size_t __grouping_size,
> const string& __grouping_tmp) throw ();
>
>
>
> template<typename _CharT, typename _InIter>
> _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<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
>
>
> __xtrc.clear();
> break;
> }
> }
> else
> break;
> }
> else if (__c == __lc->_M_decimal_point)
> {
> if (!__found_dec && !__found_sci)
> {
>
>
>
> if (__found_grouping.size())
> __found_grouping += static_cast<char>(__sep_pos);
> __xtrc += '.';
> __found_dec = true;
> }
> else
> break;
> }
> else
> {
> const char_type* __q =
> __traits_type::find(__lit_zero, 10, __c);
> if (__q)
> {
> __xtrc += '0' + (__q - __lit_zero);
> __found_mantissa = true;
> ++__sep_pos;
> }
> else if ((__c == __lit[__num_base::_S_ie]
> || __c == __lit[__num_base::_S_iE])
> && !__found_sci && __found_mantissa)
> {
>
> if (__found_grouping.size() && !__found_dec)
> __found_grouping += static_cast<char>(__sep_pos);
> __xtrc += 'e';
> __found_sci = true;
>
>
> if (++__beg != __end)
> {
> __c = *__beg;
> const bool __plus = __c == __lit[__num_base::_S_iplus];
> if ((__plus || __c == __lit[__num_base::_S_iminus])
> && !(__lc->_M_use_grouping
> && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> __xtrc += __plus ? '+' : '-';
> else
> continue;
> }
> else
> {
> __testeof = true;
> break;
> }
> }
> else
> break;
> }
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
>
>
>
> if (__found_grouping.size())
> {
>
> if (!__found_dec && !__found_sci)
> __found_grouping += static_cast<char>(__sep_pos);
>
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __found_grouping))
> __err = ios_base::failbit;
> }
>
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> template<typename _ValueT>
> _InIter
> num_get<_CharT, _InIter>::
> _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
> ios_base::iostate& __err, _ValueT& __v) const
> {
> typedef char_traits<_CharT> __traits_type;
> using __gnu_cxx::__add_unsigned;
> typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
> const _CharT* __lit = __lc->_M_atoms_in;
> char_type __c = char_type();
>
>
> const ios_base::fmtflags __basefield = __io.flags()
> & ios_base::basefield;
> const bool __oct = __basefield == ios_base::oct;
> int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
>
>
> bool __testeof = __beg == __end;
>
>
> bool __negative = false;
> if (!__testeof)
> {
> __c = *__beg;
> __negative = __c == __lit[__num_base::_S_iminus];
> if ((__negative || __c == __lit[__num_base::_S_iplus])
> && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> && !(__c == __lc->_M_decimal_point))
> {
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> }
>
>
>
> bool __found_zero = false;
> int __sep_pos = 0;
> while (!__testeof)
> {
> if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> || __c == __lc->_M_decimal_point)
> break;
> else if (__c == __lit[__num_base::_S_izero]
> && (!__found_zero || __base == 10))
> {
> __found_zero = true;
> ++__sep_pos;
> if (__basefield == 0)
> __base = 8;
> if (__base == 8)
> __sep_pos = 0;
> }
> else if (__found_zero
> && (__c == __lit[__num_base::_S_ix]
> || __c == __lit[__num_base::_S_iX]))
> {
> if (__basefield == 0)
> __base = 16;
> if (__base == 16)
> {
> __found_zero = false;
> __sep_pos = 0;
> }
> else
> break;
> }
> else
> break;
>
> if (++__beg != __end)
> {
> __c = *__beg;
> if (!__found_zero)
> break;
> }
> else
> __testeof = true;
> }
>
>
>
> const size_t __len = (__base == 16 ? __num_base::_S_iend
> - __num_base::_S_izero : __base);
>
>
> string __found_grouping;
> if (__lc->_M_use_grouping)
> __found_grouping.reserve(32);
> bool __testfail = false;
> bool __testoverflow = false;
> const __unsigned_type __max =
> (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
> ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
> : __gnu_cxx::__numeric_traits<_ValueT>::__max;
> const __unsigned_type __smax = __max / __base;
> __unsigned_type __result = 0;
> int __digit = 0;
> const char_type* __lit_zero = __lit + __num_base::_S_izero;
>
> if (!__lc->_M_allocated)
>
> while (!__testeof)
> {
> __digit = _M_find(__lit_zero, __len, __c);
> if (__digit == -1)
> break;
>
> if (__result > __smax)
> __testoverflow = true;
> else
> {
> __result *= __base;
> __testoverflow |= __result > __max - __digit;
> __result += __digit;
> ++__sep_pos;
> }
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
> else
> while (!__testeof)
> {
>
>
> if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
> {
>
>
> if (__sep_pos)
> {
> __found_grouping += static_cast<char>(__sep_pos);
> __sep_pos = 0;
> }
> else
> {
> __testfail = true;
> break;
> }
> }
> else if (__c == __lc->_M_decimal_point)
> break;
> else
> {
> const char_type* __q =
> __traits_type::find(__lit_zero, __len, __c);
> if (!__q)
> break;
>
> __digit = __q - __lit_zero;
> if (__digit > 15)
> __digit -= 6;
> if (__result > __smax)
> __testoverflow = true;
> else
> {
> __result *= __base;
> __testoverflow |= __result > __max - __digit;
> __result += __digit;
> ++__sep_pos;
> }
> }
>
> if (++__beg != __end)
> __c = *__beg;
> else
> __testeof = true;
> }
>
>
>
> if (__found_grouping.size())
> {
>
> __found_grouping += static_cast<char>(__sep_pos);
>
> if (!std::__verify_grouping(__lc->_M_grouping,
> __lc->_M_grouping_size,
> __found_grouping))
> __err = ios_base::failbit;
> }
>
>
>
> if ((!__sep_pos && !__found_zero && !__found_grouping.size())
> || __testfail)
> {
> __v = 0;
> __err = ios_base::failbit;
> }
> else if (__testoverflow)
> {
> if (__negative
> && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
> __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
> else
> __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
> __err = ios_base::failbit;
> }
> else
> __v = __negative ? -__result : __result;
>
> if (__testeof)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, bool& __v) const
> {
> if (!(__io.flags() & ios_base::boolalpha))
> {
>
>
>
> long __l = -1;
> __beg = _M_extract_int(__beg, __end, __io, __err, __l);
> if (__l == 0 || __l == 1)
> __v = bool(__l);
> else
> {
>
>
> __v = true;
> __err = ios_base::failbit;
> if (__beg == __end)
> __err |= ios_base::eofbit;
> }
> }
> else
> {
>
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
> bool __testf = true;
> bool __testt = true;
> bool __donef = __lc->_M_falsename_size == 0;
> bool __donet = __lc->_M_truename_size == 0;
> bool __testeof = false;
> size_t __n = 0;
> while (!__donef || !__donet)
> {
> if (__beg == __end)
> {
> __testeof = true;
> break;
> }
>
> const char_type __c = *__beg;
>
> if (!__donef)
> __testf = __c == __lc->_M_falsename[__n];
>
> if (!__testf && __donet)
> break;
>
> if (!__donet)
> __testt = __c == __lc->_M_truename[__n];
>
> if (!__testt && __donef)
> break;
>
> if (!__testt && !__testf)
> break;
>
> ++__n;
> ++__beg;
>
> __donef = !__testf || __n >= __lc->_M_falsename_size;
> __donet = !__testt || __n >= __lc->_M_truename_size;
> }
> if (__testf && __n == __lc->_M_falsename_size && __n)
> {
> __v = false;
> if (__testt && __n == __lc->_M_truename_size)
> __err = ios_base::failbit;
> else
> __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
> }
> else if (__testt && __n == __lc->_M_truename_size && __n)
> {
> __v = true;
> __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
> }
> else
> {
>
>
> __v = false;
> __err = ios_base::failbit;
> if (__testeof)
> __err |= ios_base::eofbit;
> }
> }
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, float& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, double& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
># 732 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, long double& __v) const
> {
> string __xtrc;
> __xtrc.reserve(32);
> __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
> std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
> if (__beg == __end)
> __err |= ios_base::eofbit;
> return __beg;
> }
>
> template<typename _CharT, typename _InIter>
> _InIter
> num_get<_CharT, _InIter>::
> do_get(iter_type __beg, iter_type __end, ios_base& __io,
> ios_base::iostate& __err, void*& __v) const
> {
>
> typedef ios_base::fmtflags fmtflags;
> const fmtflags __fmt = __io.flags();
> __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
>
> typedef __gnu_cxx::__conditional_type<(sizeof(void*)
> <= sizeof(unsigned long)),
> unsigned long, unsigned long long>::__type _UIntPtrType;
>
> _UIntPtrType __ul;
> __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
>
>
> __io.flags(__fmt);
>
> __v = reinterpret_cast<void*>(__ul);
> return __beg;
> }
>
>
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
> _CharT* __new, const _CharT* __cs, int& __len) const
> {
>
>
> __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
> __cs, __w, __len);
> __len = static_cast<int>(__w);
> }
>
>
>
> template<typename _CharT, typename _ValueT>
> int
> __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
> ios_base::fmtflags __flags, bool __dec)
> {
> _CharT* __buf = __bufend;
> if (__builtin_expect(__dec, true))
> {
>
> do
> {
> *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
> __v /= 10;
> }
> while (__v != 0);
> }
> else if ((__flags & ios_base::basefield) == ios_base::oct)
> {
>
> do
> {
> *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
> __v >>= 3;
> }
> while (__v != 0);
> }
> else
> {
>
> const bool __uppercase = __flags & ios_base::uppercase;
> const int __case_offset = __uppercase ? __num_base::_S_oudigits
> : __num_base::_S_odigits;
> do
> {
> *--__buf = __lit[(__v & 0xf) + __case_offset];
> __v >>= 4;
> }
> while (__v != 0);
> }
> return __bufend - __buf;
> }
>
>
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
> ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
> {
> _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
> __grouping_size, __cs, __cs + __len);
> __len = __p - __new;
> }
>
> template<typename _CharT, typename _OutIter>
> template<typename _ValueT>
> _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<streamsize>(__len))
> {
> _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __cs3, __cs, __len);
> __cs = __cs3;
> }
> __io.width(0);
>
>
>
> return std::__write(__s, __cs, __len);
> }
>
> template<typename _CharT, typename _OutIter>
> void
> num_put<_CharT, _OutIter>::
> _M_group_float(const char* __grouping, size_t __grouping_size,
> _CharT __sep, const _CharT* __p, _CharT* __new,
> _CharT* __cs, int& __len) const
> {
>
>
>
> const int __declen = __p ? __p - __cs : __len;
> _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
> __grouping_size,
> __cs, __cs + __declen);
>
>
> int __newlen = __p2 - __new;
> if (__p)
> {
> char_traits<_CharT>::copy(__p2, __p, __len - __declen);
> __newlen += __len - __declen;
> }
> __len = __newlen;
> }
># 968 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _OutIter>
> template<typename _ValueT>
> _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);
>
>
>
>
> int __cs_size = __max_digits * 3;
> char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> __fbuf, __prec, __v);
>
>
> if (__len >= __cs_size)
> {
> __cs_size = __len + 1;
> __cs = static_cast<char*>(__builtin_alloca(__cs_size));
> __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
> __fbuf, __prec, __v);
> }
># 1029 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.tcc" 3
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __len));
> __ctype.widen(__cs, __cs + __len, __ws);
>
>
> _CharT* __wp = 0;
> const char* __p = char_traits<char>::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<streamsize>(__len))
> {
> _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __w));
> _M_pad(__fill, __w, __io, __ws3, __ws, __len);
> __ws = __ws3;
> }
> __io.width(0);
>
>
>
> return std::__write(__s, __ws, __len);
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
> {
> const ios_base::fmtflags __flags = __io.flags();
> if ((__flags & ios_base::boolalpha) == 0)
> {
> const long __l = __v;
> __s = _M_insert_int(__s, __io, __fill, __l);
> }
> else
> {
> typedef __numpunct_cache<_CharT> __cache_type;
> __use_cache<__cache_type> __uc;
> const locale& __loc = __io._M_getloc();
> const __cache_type* __lc = __uc(__loc);
>
> const _CharT* __name = __v ? __lc->_M_truename
> : __lc->_M_falsename;
> int __len = __v ? __lc->_M_truename_size
> : __lc->_M_falsename_size;
>
> const streamsize __w = __io.width();
> if (__w > static_cast<streamsize>(__len))
> {
> const streamsize __plen = __w - __len;
> _CharT* __ps
> = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
> * __plen));
>
> char_traits<_CharT>::assign(__ps, __plen, __fill);
> __io.width(0);
>
> if ((__flags & ios_base::adjustfield) == ios_base::left)
> {
> __s = std::__write(__s, __name, __len);
> __s = std::__write(__s, __ps, __plen);
> }
> else
> {
> __s = std::__write(__s, __ps, __plen);
> __s = std::__write(__s, __name, __len);
> }
> return __s;
> }
> __io.width(0);
> __s = std::__write(__s, __name, __len);
> }
> return __s;
> }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
> { return _M_insert_float(__s, __io, __fill, char(), __v); }
># 1154 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> long double __v) const
> { return _M_insert_float(__s, __io, __fill, 'L', __v); }
>
> template<typename _CharT, typename _OutIter>
> _OutIter
> num_put<_CharT, _OutIter>::
> do_put(iter_type __s, ios_base& __io, char_type __fill,
> const void* __v) const
> {
> const ios_base::fmtflags __flags = __io.flags();
> const ios_base::fmtflags __fmt = ~(ios_base::basefield
> | ios_base::uppercase);
> __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
>
> typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
> <= sizeof(unsigned long)),
> unsigned long, unsigned long long>::__type _UIntPtrType;
>
> __s = _M_insert_int(__s, __io, __fill,
> reinterpret_cast<_UIntPtrType>(__v));
> __io.flags(__flags);
> return __s;
> }
>
>
># 1191 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.tcc" 3
> template<typename _CharT, typename _Traits>
> void
> __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
> _CharT* __news, const _CharT* __olds,
> streamsize __newlen, streamsize __oldlen)
> {
> const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
> const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
>
>
> if (__adjust == ios_base::left)
> {
> _Traits::copy(__news, __olds, __oldlen);
> _Traits::assign(__news + __oldlen, __plen, __fill);
> return;
> }
>
> size_t __mod = 0;
> if (__adjust == ios_base::internal)
> {
>
>
>
> const locale& __loc = __io._M_getloc();
> const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
>
> if (__ctype.widen('-') == __olds[0]
> || __ctype.widen('+') == __olds[0])
> {
> __news[0] = __olds[0];
> __mod = 1;
> ++__news;
> }
> else if (__ctype.widen('0') == __olds[0]
> && __oldlen > 1
> && (__ctype.widen('x') == __olds[1]
> || __ctype.widen('X') == __olds[1]))
> {
> __news[0] = __olds[0];
> __news[1] = __olds[1];
> __mod = 2;
> __news += 2;
> }
>
> }
> _Traits::assign(__news, __plen, __fill);
> _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
> }
>
> template<typename _CharT>
> _CharT*
> __add_grouping(_CharT* __s, _CharT __sep,
> const char* __gbeg, size_t __gsize,
> const _CharT* __first, const _CharT* __last)
> {
> size_t __idx = 0;
> size_t __ctr = 0;
>
> while (__last - __first > __gbeg[__idx]
> && static_cast<signed char>(__gbeg[__idx]) > 0
> && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
> {
> __last -= __gbeg[__idx];
> __idx < __gsize - 1 ? ++__idx : ++__ctr;
> }
>
> while (__first != __last)
> *__s++ = *__first++;
>
> while (__ctr--)
> {
> *__s++ = __sep;
> for (char __i = __gbeg[__idx]; __i > 0; --__i)
> *__s++ = *__first++;
> }
>
> while (__idx--)
> {
> *__s++ = __sep;
> for (char __i = __gbeg[__idx]; __i > 0; --__i)
> *__s++ = *__first++;
> }
>
> return __s;
> }
>
>
>
>
> extern template class numpunct<char>;
> extern template class numpunct_byname<char>;
> extern template class num_get<char>;
> extern template class num_put<char>;
> extern template class ctype_byname<char>;
>
> extern template
> const ctype<char>&
> use_facet<ctype<char> >(const locale&);
>
> extern template
> const numpunct<char>&
> use_facet<numpunct<char> >(const locale&);
>
> extern template
> const num_put<char>&
> use_facet<num_put<char> >(const locale&);
>
> extern template
> const num_get<char>&
> use_facet<num_get<char> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<char> >(const locale&);
>
> extern template
> bool
> has_facet<numpunct<char> >(const locale&);
>
> extern template
> bool
> has_facet<num_put<char> >(const locale&);
>
> extern template
> bool
> has_facet<num_get<char> >(const locale&);
>
>
> extern template class numpunct<wchar_t>;
> extern template class numpunct_byname<wchar_t>;
> extern template class num_get<wchar_t>;
> extern template class num_put<wchar_t>;
> extern template class ctype_byname<wchar_t>;
>
> extern template
> const ctype<wchar_t>&
> use_facet<ctype<wchar_t> >(const locale&);
>
> extern template
> const numpunct<wchar_t>&
> use_facet<numpunct<wchar_t> >(const locale&);
>
> extern template
> const num_put<wchar_t>&
> use_facet<num_put<wchar_t> >(const locale&);
>
> extern template
> const num_get<wchar_t>&
> use_facet<num_get<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<ctype<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<numpunct<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<num_put<wchar_t> >(const locale&);
>
> extern template
> bool
> has_facet<num_get<wchar_t> >(const locale&);
>
>
>
>
>}
># 2608 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/locale_facets.h" 2 3
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Facet>
> inline const _Facet&
> __check_facet(const _Facet* __f)
> {
> if (!__f)
> __throw_bad_cast();
> return *__f;
> }
># 63 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> template<typename _CharT, typename _Traits>
> class basic_ios : public ios_base
> {
> public:
>
>
>
>
>
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
>
>
>
>
> typedef ctype<_CharT> __ctype_type;
> typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
> __num_put_type;
> typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
> __num_get_type;
>
>
>
> protected:
> basic_ostream<_CharT, _Traits>* _M_tie;
> mutable char_type _M_fill;
> mutable bool _M_fill_init;
> basic_streambuf<_CharT, _Traits>* _M_streambuf;
>
>
> const __ctype_type* _M_ctype;
>
> const __num_put_type* _M_num_put;
>
> const __num_get_type* _M_num_get;
>
> public:
>
>
>
>
>
>
>
> operator void*() const
> { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
>
> bool
> operator!() const
> { return this->fail(); }
># 128 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> iostate
> rdstate() const
> { return _M_streambuf_state; }
># 139 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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; }
># 192 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> bool
> fail() const
> { return (this->rdstate() & (badbit | failbit)) != 0; }
>
>
>
>
>
>
>
> bool
> bad() const
> { return (this->rdstate() & badbit) != 0; }
># 213 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> iostate
> exceptions() const
> { return _M_exception; }
># 248 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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() { }
># 286 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> basic_ostream<_CharT, _Traits>*
> tie() const
> { return _M_tie; }
># 298 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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; }
># 338 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> basic_streambuf<_CharT, _Traits>*
> rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
># 352 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 381 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> char_type
> fill(char_type __ch)
> {
> char_type __old = this->fill();
> _M_fill = __ch;
> return __old;
> }
># 401 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> locale
> imbue(const locale& __loc);
># 421 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 3
> char
> narrow(char_type __c, char __dfault) const
> { return __check_facet(_M_ctype).narrow(__c, __dfault); }
># 440 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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);
>
> void
> _M_cache_locale(const locale& __loc);
> };
>
>
>}
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.tcc" 1 3
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.tcc" 3
> 
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.tcc" 3
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::clear(iostate __state)
> {
> if (this->rdbuf())
> _M_streambuf_state = __state;
> else
> _M_streambuf_state = __state | badbit;
> if (this->exceptions() & this->rdstate())
> __throw_ios_failure(("basic_ios::clear"));
> }
>
> template<typename _CharT, typename _Traits>
> basic_streambuf<_CharT, _Traits>*
> basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
> {
> basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
> _M_streambuf = __sb;
> this->clear();
> return __old;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ios<_CharT, _Traits>&
> basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
> {
>
>
> if (this != &__rhs)
> {
>
>
>
>
> _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
> _M_local_word : new _Words[__rhs._M_word_size];
>
>
> _Callback_list* __cb = __rhs._M_callbacks;
> if (__cb)
> __cb->_M_add_reference();
> _M_call_callbacks(erase_event);
> if (_M_word != _M_local_word)
> {
> delete [] _M_word;
> _M_word = 0;
> }
> _M_dispose_callbacks();
>
>
> _M_callbacks = __cb;
> for (int __i = 0; __i < __rhs._M_word_size; ++__i)
> __words[__i] = __rhs._M_word[__i];
> _M_word = __words;
> _M_word_size = __rhs._M_word_size;
>
> this->flags(__rhs.flags());
> this->width(__rhs.width());
> this->precision(__rhs.precision());
> this->tie(__rhs.tie());
> this->fill(__rhs.fill());
> _M_ios_locale = __rhs.getloc();
> _M_cache_locale(_M_ios_locale);
>
> _M_call_callbacks(copyfmt_event);
>
>
> this->exceptions(__rhs.exceptions());
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> locale
> basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
> {
> locale __old(this->getloc());
> ios_base::imbue(__loc);
> _M_cache_locale(__loc);
> if (this->rdbuf() != 0)
> this->rdbuf()->pubimbue(__loc);
> return __old;
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
> {
>
> ios_base::_M_init();
>
>
> _M_cache_locale(_M_ios_locale);
># 147 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.tcc" 3
> _M_fill = _CharT();
> _M_fill_init = false;
>
> _M_tie = 0;
> _M_exception = goodbit;
> _M_streambuf = __sb;
> _M_streambuf_state = __sb ? goodbit : badbit;
> }
>
> template<typename _CharT, typename _Traits>
> void
> basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
> {
> if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
> _M_ctype = &use_facet<__ctype_type>(__loc);
> else
> _M_ctype = 0;
>
> if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
> _M_num_put = &use_facet<__num_put_type>(__loc);
> else
> _M_num_put = 0;
>
> if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
> _M_num_get = &use_facet<__num_get_type>(__loc);
> else
> _M_num_get = 0;
> }
>
>
>
>
> extern template class basic_ios<char>;
>
>
> extern template class basic_ios<wchar_t>;
>
>
>
>
>}
># 474 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/basic_ios.h" 2 3
># 46 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ios" 2 3
># 41 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 2 3
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> template<typename _CharT, typename _Traits>
> class basic_ostream : virtual public basic_ios<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_ios<_CharT, _Traits> __ios_type;
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
> typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
> __num_put_type;
> typedef ctype<_CharT> __ctype_type;
># 81 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> explicit
> basic_ostream(__streambuf_type* __sb)
> { this->init(__sb); }
>
>
>
>
>
>
> virtual
> ~basic_ostream() { }
>
>
> class sentry;
> friend class sentry;
># 105 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 163 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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<unsigned long>(__n));
> }
>
> __ostream_type&
> operator<<(int __n);
>
> __ostream_type&
> operator<<(unsigned int __n)
> {
>
>
> return _M_insert(static_cast<unsigned long>(__n));
> }
>
>
> __ostream_type&
> operator<<(long long __n)
> { return _M_insert(__n); }
>
> __ostream_type&
> operator<<(unsigned long long __n)
> { return _M_insert(__n); }
># 217 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> __ostream_type&
> operator<<(double __f)
> { return _M_insert(__f); }
>
> __ostream_type&
> operator<<(float __f)
> {
>
>
> return _M_insert(static_cast<double>(__f));
> }
>
> __ostream_type&
> operator<<(long double __f)
> { return _M_insert(__f); }
># 242 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> __ostream_type&
> operator<<(const void* __p)
> { return _M_insert(__p); }
># 267 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> __ostream_type&
> operator<<(__streambuf_type* __sb);
># 300 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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);
> }
># 332 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> __ostream_type&
> write(const char_type* __s, streamsize __n);
># 345 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> __ostream_type&
> flush();
># 355 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> pos_type
> tellp();
># 366 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> __ostream_type&
> seekp(pos_type);
># 378 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> __ostream_type&
> seekp(off_type, ios_base::seekdir);
>
> protected:
> basic_ostream()
> { this->init(0); }
>
> template<typename _ValueT>
> __ostream_type&
> _M_insert(_ValueT __v);
> };
># 397 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> template <typename _CharT, typename _Traits>
> class basic_ostream<_CharT, _Traits>::sentry
> {
>
> bool _M_ok;
> basic_ostream<_CharT, _Traits>& _M_os;
>
> public:
># 416 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> explicit
> sentry(basic_ostream<_CharT, _Traits>& __os);
># 426 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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);
> }
> }
># 445 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> explicit
>
> operator bool() const
> { return _M_ok; }
> };
># 467 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
> { return __ostream_insert(__out, &__c, 1); }
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
> { return (__out << __out.widen(__c)); }
>
>
> template <class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, char __c)
> { return __ostream_insert(__out, &__c, 1); }
>
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
> { return (__out << static_cast<char>(__c)); }
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
> { return (__out << static_cast<char>(__c)); }
># 509 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
> {
> if (!__s)
> __out.setstate(ios_base::badbit);
> else
> __ostream_insert(__out, __s,
> static_cast<streamsize>(_Traits::length(__s)));
> return __out;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits> &
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
>
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
> {
> if (!__s)
> __out.setstate(ios_base::badbit);
> else
> __ostream_insert(__out, __s,
> static_cast<streamsize>(_Traits::length(__s)));
> return __out;
> }
>
>
> template<class _Traits>
> inline basic_ostream<char, _Traits>&
> operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
>
> template<class _Traits>
> inline basic_ostream<char, _Traits> &
> operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
> { return (__out << reinterpret_cast<const char*>(__s)); }
># 560 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> endl(basic_ostream<_CharT, _Traits>& __os)
> { return flush(__os.put(__os.widen('\n'))); }
># 572 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> ends(basic_ostream<_CharT, _Traits>& __os)
> { return __os.put(_CharT()); }
>
>
>
>
>
>
> template<typename _CharT, typename _Traits>
> inline basic_ostream<_CharT, _Traits>&
> flush(basic_ostream<_CharT, _Traits>& __os)
> { return __os.flush(); }
># 598 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 3
> template<typename _CharT, typename _Traits, typename _Tp>
> inline basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
> { return (__os << __x); }
>
>
>
>}
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ostream.tcc" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ostream.tcc" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/ostream.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>::sentry::
> sentry(basic_ostream<_CharT, _Traits>& __os)
> : _M_ok(false), _M_os(__os)
> {
>
> if (__os.tie() && __os.good())
> __os.tie()->flush();
>
> if (__os.good())
> _M_ok = true;
> else
> __os.setstate(ios_base::failbit);
> }
>
> template<typename _CharT, typename _Traits>
> template<typename _ValueT>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> _M_insert(_ValueT __v)
> {
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const __num_put_type& __np = __check_facet(this->_M_num_put);
> if (__np.put(*this, *this, this->fill(), __v).failed())
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(short __n)
> {
>
>
> const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
> if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
> else
> return _M_insert(static_cast<long>(__n));
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(int __n)
> {
>
>
> const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
> if (__fmt == ios_base::oct || __fmt == ios_base::hex)
> return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
> else
> return _M_insert(static_cast<long>(__n));
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> operator<<(__streambuf_type* __sbin)
> {
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this);
> if (__cerb && __sbin)
> {
> try
> {
> if (!__copy_streambufs(__sbin, this->rdbuf()))
> __err |= ios_base::failbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::failbit); }
> }
> else if (!__sbin)
> __err |= ios_base::badbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> put(char_type __c)
> {
>
>
>
>
>
>
> sentry __cerb(*this);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __put = this->rdbuf()->sputc(__c);
> if (traits_type::eq_int_type(__put, traits_type::eof()))
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> write(const _CharT* __s, streamsize __n)
> {
>
>
>
>
>
>
>
> sentry __cerb(*this);
> if (__cerb)
> {
> try
> { _M_write(__s, __n); }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> flush()
> {
>
>
>
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_ostream<_CharT, _Traits>::pos_type
> basic_ostream<_CharT, _Traits>::
> tellp()
> {
> pos_type __ret = pos_type(-1);
> try
> {
> if (!this->fail())
> __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> seekp(pos_type __pos)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
>
> const pos_type __p = this->rdbuf()->pubseekpos(__pos,
> ios_base::out);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> basic_ostream<_CharT, _Traits>::
> seekp(off_type __off, ios_base::seekdir __dir)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
>
> const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
> ios_base::out);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_ostream<_CharT, _Traits>&
> operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
> {
> if (!__s)
> __out.setstate(ios_base::badbit);
> else
> {
>
>
> const size_t __clen = char_traits<char>::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<char>;
> extern template ostream& endl(ostream&);
> extern template ostream& ends(ostream&);
> extern template ostream& flush(ostream&);
> extern template ostream& operator<<(ostream&, char);
> extern template ostream& operator<<(ostream&, unsigned char);
> extern template ostream& operator<<(ostream&, signed char);
> extern template ostream& operator<<(ostream&, const char*);
> extern template ostream& operator<<(ostream&, const unsigned char*);
> extern template ostream& operator<<(ostream&, const signed char*);
>
> extern template ostream& ostream::_M_insert(long);
> extern template ostream& ostream::_M_insert(unsigned long);
> extern template ostream& ostream::_M_insert(bool);
>
> extern template ostream& ostream::_M_insert(long long);
> extern template ostream& ostream::_M_insert(unsigned long long);
>
> extern template ostream& ostream::_M_insert(double);
> extern template ostream& ostream::_M_insert(long double);
> extern template ostream& ostream::_M_insert(const void*);
>
>
> extern template class basic_ostream<wchar_t>;
> extern template wostream& endl(wostream&);
> extern template wostream& ends(wostream&);
> extern template wostream& flush(wostream&);
> extern template wostream& operator<<(wostream&, wchar_t);
> extern template wostream& operator<<(wostream&, char);
> extern template wostream& operator<<(wostream&, const wchar_t*);
> extern template wostream& operator<<(wostream&, const char*);
>
> extern template wostream& wostream::_M_insert(long);
> extern template wostream& wostream::_M_insert(unsigned long);
> extern template wostream& wostream::_M_insert(bool);
>
> extern template wostream& wostream::_M_insert(long long);
> extern template wostream& wostream::_M_insert(unsigned long long);
>
> extern template wostream& wostream::_M_insert(double);
> extern template wostream& wostream::_M_insert(long double);
> extern template wostream& wostream::_M_insert(const void*);
>
>
>
>
>}
># 608 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/ostream" 2 3
># 65 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iterator" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 1 3
># 38 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> 
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
>
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
># 55 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_istream : virtual public basic_ios<_CharT, _Traits>
> {
> public:
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_ios<_CharT, _Traits> __ios_type;
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
> __num_get_type;
> typedef ctype<_CharT> __ctype_type;
>
> protected:
>
>
>
>
>
> streamsize _M_gcount;
>
> public:
>
>
>
>
>
>
>
> explicit
> basic_istream(__streambuf_type* __sb)
> : _M_gcount(streamsize(0))
> { this->init(__sb); }
>
>
>
>
>
>
> virtual
> ~basic_istream()
> { _M_gcount = streamsize(0); }
>
>
> class sentry;
> friend class sentry;
># 117 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
> }
># 165 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 211 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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); }
># 232 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> operator>>(void*& __p)
> { return _M_extract(__p); }
># 256 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> operator>>(__streambuf_type* __sb);
># 266 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> streamsize
> gcount() const
> { return _M_gcount; }
># 299 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> int_type
> get();
># 313 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> get(char_type& __c);
># 340 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> get(char_type* __s, streamsize __n, char_type __delim);
># 351 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> get(char_type* __s, streamsize __n)
> { return this->get(__s, __n, this->widen('\n')); }
># 374 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> get(__streambuf_type& __sb, char_type __delim);
># 384 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> get(__streambuf_type& __sb)
> { return this->get(__sb, this->widen('\n')); }
># 413 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> getline(char_type* __s, streamsize __n, char_type __delim);
># 424 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> getline(char_type* __s, streamsize __n)
> { return this->getline(__s, __n, this->widen('\n')); }
># 448 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> ignore(streamsize __n, int_type __delim);
>
> __istream_type&
> ignore(streamsize __n);
>
> __istream_type&
> ignore();
># 465 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> int_type
> peek();
># 483 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> read(char_type* __s, streamsize __n);
># 502 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> streamsize
> readsome(char_type* __s, streamsize __n);
># 519 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> putback(char_type __c);
># 535 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> unget();
># 553 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> int
> sync();
># 568 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> pos_type
> tellg();
># 583 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> seekg(pos_type);
># 599 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> __istream_type&
> seekg(off_type, ios_base::seekdir);
>
>
> protected:
> basic_istream()
> : _M_gcount(streamsize(0))
> { this->init(0); }
>
> template<typename _ValueT>
> __istream_type&
> _M_extract(_ValueT& __v);
> };
>
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> getline(char_type* __s, streamsize __n, char_type __delim);
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> ignore(streamsize __n);
>
> template<>
> basic_istream<char>&
> basic_istream<char>::
> ignore(streamsize __n, int_type __delim);
>
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> getline(char_type* __s, streamsize __n, char_type __delim);
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> ignore(streamsize __n);
>
> template<>
> basic_istream<wchar_t>&
> basic_istream<wchar_t>::
> ignore(streamsize __n, int_type __delim);
># 654 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_istream<_CharT, _Traits>::sentry
> {
>
> bool _M_ok;
>
> public:
>
> typedef _Traits traits_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::__ctype_type __ctype_type;
> typedef typename _Traits::int_type __int_type;
># 690 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> explicit
> sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
># 701 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> explicit
>
> operator bool() const
> { return _M_ok; }
> };
># 719 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
> { return (__in >> reinterpret_cast<char&>(__c)); }
># 761 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
>
>
> template<>
> basic_istream<char>&
> operator>>(basic_istream<char>& __in, char* __s);
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
>
> template<class _Traits>
> inline basic_istream<char, _Traits>&
> operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
> { return (__in >> reinterpret_cast<char*>(__s)); }
># 788 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> template<typename _CharT, typename _Traits>
> class basic_iostream
> : public basic_istream<_CharT, _Traits>,
> public basic_ostream<_CharT, _Traits>
> {
> public:
>
>
>
> typedef _CharT char_type;
> typedef typename _Traits::int_type int_type;
> typedef typename _Traits::pos_type pos_type;
> typedef typename _Traits::off_type off_type;
> typedef _Traits traits_type;
>
>
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_ostream<_CharT, _Traits> __ostream_type;
>
>
>
>
>
>
>
> explicit
> basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
> : __istream_type(__sb), __ostream_type(__sb) { }
>
>
>
>
> virtual
> ~basic_iostream() { }
>
> protected:
> basic_iostream()
> : __istream_type(), __ostream_type() { }
> };
># 848 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> ws(basic_istream<_CharT, _Traits>& __is);
># 864 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 3
> template<typename _CharT, typename _Traits, typename _Tp>
> inline basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
> { return (__is >> __x); }
>
>
>
>}
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/istream.tcc" 1 3
># 39 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/istream.tcc" 3
> 
># 40 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/istream.tcc" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>::sentry::
> sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
> {
> ios_base::iostate __err = ios_base::goodbit;
> if (__in.good())
> {
> if (__in.tie())
> __in.tie()->flush();
> if (!__noskip && bool(__in.flags() & ios_base::skipws))
> {
> const __int_type __eof = traits_type::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> const __ctype_type& __ct = __check_facet(__in._M_ctype);
> while (!traits_type::eq_int_type(__c, __eof)
> && __ct.is(ctype_base::space,
> traits_type::to_char_type(__c)))
> __c = __sb->snextc();
>
>
>
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> }
>
> if (__in.good() && __err == ios_base::goodbit)
> _M_ok = true;
> else
> {
> __err |= ios_base::failbit;
> __in.setstate(__err);
> }
> }
>
> template<typename _CharT, typename _Traits>
> template<typename _ValueT>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> _M_extract(_ValueT& __v)
> {
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __v);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(short& __n)
> {
>
>
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> long __l;
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __l);
>
>
>
> if (__l < __gnu_cxx::__numeric_traits<short>::__min)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<short>::__min;
> }
> else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<short>::__max;
> }
> else
> __n = short(__l);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(int& __n)
> {
>
>
> sentry __cerb(*this, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> long __l;
> const __num_get_type& __ng = __check_facet(this->_M_num_get);
> __ng.get(*this, 0, *this, __err, __l);
>
>
>
> if (__l < __gnu_cxx::__numeric_traits<int>::__min)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<int>::__min;
> }
> else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
> {
> __err |= ios_base::failbit;
> __n = __gnu_cxx::__numeric_traits<int>::__max;
> }
> else
> __n = int(__l);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> operator>>(__streambuf_type* __sbout)
> {
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, false);
> if (__cerb && __sbout)
> {
> try
> {
> bool __ineof;
> if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
> __err |= ios_base::failbit;
> if (__ineof)
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::failbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::failbit); }
> }
> else if (!__sbout)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::int_type
> basic_istream<_CharT, _Traits>::
> get(void)
> {
> const int_type __eof = traits_type::eof();
> int_type __c = __eof;
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> __c = this->rdbuf()->sbumpc();
>
> if (!traits_type::eq_int_type(__c, __eof))
> _M_gcount = 1;
> else
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return __c;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(char_type& __c)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __cb = this->rdbuf()->sbumpc();
>
> if (!traits_type::eq_int_type(__cb, traits_type::eof()))
> {
> _M_gcount = 1;
> __c = traits_type::to_char_type(__cb);
> }
> else
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(char_type* __s, streamsize __n, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
> while (_M_gcount + 1 < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim))
> {
> *__s++ = traits_type::to_char_type(__c);
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
>
>
> if (__n > 0)
> *__s = char_type();
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> get(__streambuf_type& __sb, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __this_sb = this->rdbuf();
> int_type __c = __this_sb->sgetc();
> char_type __c2 = traits_type::to_char_type(__c);
>
> while (!traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim)
> && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
> {
> ++_M_gcount;
> __c = __this_sb->snextc();
> __c2 = traits_type::to_char_type(__c);
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> getline(char_type* __s, streamsize __n, char_type __delim)
> {
> _M_gcount = 0;
> ios_base::iostate __err = ios_base::goodbit;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> const int_type __idelim = traits_type::to_int_type(__delim);
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
> while (_M_gcount + 1 < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __idelim))
> {
> *__s++ = traits_type::to_char_type(__c);
> __c = __sb->snextc();
> ++_M_gcount;
> }
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> else
> {
> if (traits_type::eq_int_type(__c, __idelim))
> {
> __sb->sbumpc();
> ++_M_gcount;
> }
> else
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
>
>
> if (__n > 0)
> *__s = char_type();
> if (!_M_gcount)
> __err |= ios_base::failbit;
> if (__err)
> this->setstate(__err);
> return *this;
> }
>
>
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(void)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
>
> if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
> __err |= ios_base::eofbit;
> else
> _M_gcount = 1;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb && __n > 0)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
># 515 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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<streamsize>::__max
> && !traits_type::eq_int_type(__c, __eof))
> {
> _M_gcount =
> __gnu_cxx::__numeric_traits<streamsize>::__min;
> __large_ignore = true;
> }
> else
> break;
> }
>
> if (__large_ignore)
> _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
> if (traits_type::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> ignore(streamsize __n, int_type __delim)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb && __n > 0)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> int_type __c = __sb->sgetc();
>
>
> bool __large_ignore = false;
> while (true)
> {
> while (_M_gcount < __n
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __delim))
> {
> ++_M_gcount;
> __c = __sb->snextc();
> }
> if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
> && !traits_type::eq_int_type(__c, __eof)
> && !traits_type::eq_int_type(__c, __delim))
> {
> _M_gcount =
> __gnu_cxx::__numeric_traits<streamsize>::__min;
> __large_ignore = true;
> }
> else
> break;
> }
>
> if (__large_ignore)
> _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__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<streamsize>::__max)
> ++_M_gcount;
> __sb->sbumpc();
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::int_type
> basic_istream<_CharT, _Traits>::
> peek(void)
> {
> int_type __c = traits_type::eof();
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> __c = this->rdbuf()->sgetc();
> if (traits_type::eq_int_type(__c, traits_type::eof()))
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return __c;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> read(char_type* __s, streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> _M_gcount = this->rdbuf()->sgetn(__s, __n);
> if (_M_gcount != __n)
> __err |= (ios_base::eofbit | ios_base::failbit);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> streamsize
> basic_istream<_CharT, _Traits>::
> readsome(char_type* __s, streamsize __n)
> {
> _M_gcount = 0;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
>
> const streamsize __num = this->rdbuf()->in_avail();
> if (__num > 0)
> _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
> else if (__num == -1)
> __err |= ios_base::eofbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return _M_gcount;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> putback(char_type __c)
> {
>
>
> _M_gcount = 0;
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> if (!__sb
> || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> unget(void)
> {
>
>
> _M_gcount = 0;
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const int_type __eof = traits_type::eof();
> __streambuf_type* __sb = this->rdbuf();
> if (!__sb
> || traits_type::eq_int_type(__sb->sungetc(), __eof))
> __err |= ios_base::badbit;
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> int
> basic_istream<_CharT, _Traits>::
> sync(void)
> {
>
>
> int __ret = -1;
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> __streambuf_type* __sb = this->rdbuf();
> if (__sb)
> {
> if (__sb->pubsync() == -1)
> __err |= ios_base::badbit;
> else
> __ret = 0;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> typename basic_istream<_CharT, _Traits>::pos_type
> basic_istream<_CharT, _Traits>::
> tellg(void)
> {
>
>
> pos_type __ret = pos_type(-1);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> try
> {
> if (!this->fail())
> __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
> ios_base::in);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> }
> return __ret;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> seekg(pos_type __pos)
> {
>
>
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
> const pos_type __p = this->rdbuf()->pubseekpos(__pos,
> ios_base::in);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> basic_istream<_CharT, _Traits>::
> seekg(off_type __off, ios_base::seekdir __dir)
> {
>
>
>
> this->clear(this->rdstate() & ~ios_base::eofbit);
> sentry __cerb(*this, true);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> if (!this->fail())
> {
>
> const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
> ios_base::in);
>
>
> if (__p == pos_type(off_type(-1)))
> __err |= ios_base::failbit;
> }
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> this->_M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { this->_M_setstate(ios_base::badbit); }
> if (__err)
> this->setstate(__err);
> }
> return *this;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef typename __istream_type::int_type __int_type;
>
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> ios_base::iostate __err = ios_base::goodbit;
> try
> {
> const __int_type __cb = __in.rdbuf()->sbumpc();
> if (!_Traits::eq_int_type(__cb, _Traits::eof()))
> __c = _Traits::to_char_type(__cb);
> else
> __err |= (ios_base::eofbit | ios_base::failbit);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __in._M_setstate(ios_base::badbit); }
> if (__err)
> __in.setstate(__err);
> }
> return __in;
> }
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef typename _Traits::int_type int_type;
> typedef _CharT char_type;
> typedef ctype<_CharT> __ctype_type;
>
> streamsize __extracted = 0;
> ios_base::iostate __err = ios_base::goodbit;
> typename __istream_type::sentry __cerb(__in, false);
> if (__cerb)
> {
> try
> {
>
> streamsize __num = __in.width();
> if (__num <= 0)
> __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
>
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
>
> const int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> int_type __c = __sb->sgetc();
>
> while (__extracted < __num - 1
> && !_Traits::eq_int_type(__c, __eof)
> && !__ct.is(ctype_base::space,
> _Traits::to_char_type(__c)))
> {
> *__s++ = _Traits::to_char_type(__c);
> ++__extracted;
> __c = __sb->snextc();
> }
> if (_Traits::eq_int_type(__c, __eof))
> __err |= ios_base::eofbit;
>
>
>
> *__s = char_type();
> __in.width(0);
> }
> catch(__cxxabiv1::__forced_unwind&)
> {
> __in._M_setstate(ios_base::badbit);
> throw;
> }
> catch(...)
> { __in._M_setstate(ios_base::badbit); }
> }
> if (!__extracted)
> __err |= ios_base::failbit;
> if (__err)
> __in.setstate(__err);
> return __in;
> }
>
>
> template<typename _CharT, typename _Traits>
> basic_istream<_CharT, _Traits>&
> ws(basic_istream<_CharT, _Traits>& __in)
> {
> typedef basic_istream<_CharT, _Traits> __istream_type;
> typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
> typedef typename __istream_type::int_type __int_type;
> typedef ctype<_CharT> __ctype_type;
>
> const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
> const __int_type __eof = _Traits::eof();
> __streambuf_type* __sb = __in.rdbuf();
> __int_type __c = __sb->sgetc();
>
> while (!_Traits::eq_int_type(__c, __eof)
> && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
> __c = __sb->snextc();
>
> if (_Traits::eq_int_type(__c, __eof))
> __in.setstate(ios_base::eofbit);
> return __in;
> }
>
>
>
>
> extern template class basic_istream<char>;
> 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<char>;
>
>
> extern template class basic_istream<wchar_t>;
> extern template wistream& ws(wistream&);
> extern template wistream& operator>>(wistream&, wchar_t&);
> extern template wistream& operator>>(wistream&, wchar_t*);
>
> extern template wistream& wistream::_M_extract(unsigned short&);
> extern template wistream& wistream::_M_extract(unsigned int&);
> extern template wistream& wistream::_M_extract(long&);
> extern template wistream& wistream::_M_extract(unsigned long&);
> extern template wistream& wistream::_M_extract(bool&);
>
> extern template wistream& wistream::_M_extract(long long&);
> extern template wistream& wistream::_M_extract(unsigned long long&);
>
> extern template wistream& wistream::_M_extract(float&);
> extern template wistream& wistream::_M_extract(double&);
> extern template wistream& wistream::_M_extract(long double&);
> extern template wistream& wistream::_M_extract(void*&);
>
> extern template class basic_iostream<wchar_t>;
>
>
>
>
>}
># 874 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/istream" 2 3
># 66 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iterator" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stream_iterator.h" 1 3
># 33 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stream_iterator.h" 3
> 
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stream_iterator.h" 3
>
>
>
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
>
>
>
>
>
>
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
> class istream_iterator
> : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
> {
> 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:
>
> constexpr 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<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
> 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 <class _Tp, class _CharT, class _Traits, class _Dist>
> 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-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stream_iterator.h" 3
> template<typename _Tp, typename _CharT = char,
> typename _Traits = char_traits<_CharT> >
> class ostream_iterator
> : public iterator<output_iterator_tag, void, void, void, void>
> {
> 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-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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-redhat-linux/4.7.0/../../../../include/c++/4.7.0/iterator" 2 3
># 50 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h" 2
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/list" 1 3
># 59 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/list" 3
> 
># 60 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/list" 3
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 1 3
># 65 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
> namespace __detail
> {
> 
># 78 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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) noexcept;
>
> void
> _M_transfer(_List_node_base* const __first,
> _List_node_base* const __last) noexcept;
>
> void
> _M_reverse() noexcept;
>
> void
> _M_hook(_List_node_base* const __position) noexcept;
>
> void
> _M_unhook() noexcept;
> };
>
> 
> }
>
>
>
>
> template<typename _Tp>
> struct _List_node : public __detail::_List_node_base
> {
>
> _Tp _M_data;
>
>
> template<typename... _Args>
> _List_node(_Args&&... __args)
> : __detail::_List_node_base(), _M_data(std::forward<_Args>(__args)...)
> { }
>
> };
>
>
>
>
>
>
> template<typename _Tp>
> 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) { }
>
>
> 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<typename _Tp>
> 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) { }
>
>
>
> 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<typename _Val>
> inline bool
> operator==(const _List_iterator<_Val>& __x,
> const _List_const_iterator<_Val>& __y)
> { return __x._M_node == __y._M_node; }
>
> template<typename _Val>
> inline bool
> operator!=(const _List_iterator<_Val>& __x,
> const _List_const_iterator<_Val>& __y)
> { return __x._M_node != __y._M_node; }
>
>
>
> template<typename _Tp, typename _Alloc>
> class _List_base
> {
> protected:
># 306 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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;
>
> struct _List_impl
> : public _Node_alloc_type
> {
> __detail::_List_node_base _M_node;
>
>
> size_t _M_size;
>
>
> _List_impl()
> : _Node_alloc_type(), _M_node()
>
> , _M_size(0)
>
> { }
>
> _List_impl(const _Node_alloc_type& __a)
> : _Node_alloc_type(__a), _M_node()
>
> , _M_size(0)
>
> { }
>
>
> _List_impl(_Node_alloc_type&& __a)
> : _Node_alloc_type(std::move(__a)), _M_node(), _M_size(0)
> { }
>
> };
>
> _List_impl _M_impl;
>
> _List_node<_Tp>*
> _M_get_node()
> {
> _List_node<_Tp>* __tmp = _M_impl._Node_alloc_type::allocate(1);
>
> ++_M_impl._M_size;
>
> return __tmp;
> }
>
> void
> _M_put_node(_List_node<_Tp>* __p)
> {
> _M_impl._Node_alloc_type::deallocate(__p, 1);
>
> --_M_impl._M_size;
>
> }
>
> public:
> typedef _Alloc allocator_type;
>
> _Node_alloc_type&
> _M_get_Node_allocator() noexcept
> { return *static_cast<_Node_alloc_type*>(&_M_impl); }
>
> const _Node_alloc_type&
> _M_get_Node_allocator() const noexcept
> { return *static_cast<const _Node_alloc_type*>(&_M_impl); }
>
> _Tp_alloc_type
> _M_get_Tp_allocator() const noexcept
> { return _Tp_alloc_type(_M_get_Node_allocator()); }
>
> allocator_type
> get_allocator() const noexcept
> { 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(); }
>
>
> _List_base(_List_base&& __x)
> : _M_impl(std::move(__x._M_get_Node_allocator()))
> {
> _M_init();
> __detail::_List_node_base::swap(_M_impl._M_node, __x._M_impl._M_node);
> std::swap(_M_impl._M_size, __x._M_impl._M_size);
> }
>
>
>
> ~_List_base() noexcept
> { _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;
> }
> };
># 457 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
> 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_iterator> const_reverse_iterator;
> typedef std::reverse_iterator<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;
># 518 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename... _Args>
> _Node*
> _M_create_node(_Args&&... __args)
> {
> _Node* __p = this->_M_get_node();
> try
> {
> _M_get_Node_allocator().construct(__p,
> std::forward<_Args>(__args)...);
> }
> catch(...)
> {
> _M_put_node(__p);
> throw;
> }
> return __p;
> }
>
>
> public:
>
>
>
>
>
> list()
> : _Base() { }
>
>
>
>
>
> explicit
> list(const allocator_type& __a)
> : _Base(_Node_alloc_type(__a)) { }
># 562 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> explicit
> list(size_type __n)
> : _Base()
> { _M_default_initialize(__n); }
># 575 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> list(size_type __n, const value_type& __value,
> const allocator_type& __a = allocator_type())
> : _Base(_Node_alloc_type(__a))
> { _M_fill_initialize(__n, __value); }
># 602 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> list(const list& __x)
> : _Base(__x._M_get_Node_allocator())
> { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
># 614 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> list(list&& __x) noexcept
> : _Base(std::move(__x)) { }
># 625 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> list(initializer_list<value_type> __l,
> const allocator_type& __a = allocator_type())
> : _Base(_Node_alloc_type(__a))
> { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); }
># 641 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _InputIterator>
> 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());
> }
># 666 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> list&
> operator=(const list& __x);
># 677 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> list&
> operator=(list&& __x)
> {
>
>
> this->clear();
> this->swap(__x);
> return *this;
> }
># 694 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> list&
> operator=(initializer_list<value_type> __l)
> {
> this->assign(__l.begin(), __l.end());
> return *this;
> }
># 712 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> assign(size_type __n, const value_type& __val)
> { _M_fill_assign(__n, __val); }
># 728 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _InputIterator>
> void
> assign(_InputIterator __first, _InputIterator __last)
> {
>
> typedef typename std::__is_integer<_InputIterator>::__type _Integral;
> _M_assign_dispatch(__first, __last, _Integral());
> }
># 745 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> assign(initializer_list<value_type> __l)
> { this->assign(__l.begin(), __l.end()); }
>
>
>
> allocator_type
> get_allocator() const noexcept
> { return _Base::get_allocator(); }
>
>
>
>
>
>
> iterator
> begin() noexcept
> { return iterator(this->_M_impl._M_node._M_next); }
>
>
>
>
>
>
> const_iterator
> begin() const noexcept
> { return const_iterator(this->_M_impl._M_node._M_next); }
>
>
>
>
>
>
> iterator
> end() noexcept
> { return iterator(&this->_M_impl._M_node); }
>
>
>
>
>
>
> const_iterator
> end() const noexcept
> { return const_iterator(&this->_M_impl._M_node); }
>
>
>
>
>
>
> reverse_iterator
> rbegin() noexcept
> { return reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> rbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> reverse_iterator
> rend() noexcept
> { return reverse_iterator(begin()); }
>
>
>
>
>
>
> const_reverse_iterator
> rend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
>
>
>
> const_iterator
> cbegin() const noexcept
> { return const_iterator(this->_M_impl._M_node._M_next); }
>
>
>
>
>
>
> const_iterator
> cend() const noexcept
> { return const_iterator(&this->_M_impl._M_node); }
>
>
>
>
>
>
> const_reverse_iterator
> crbegin() const noexcept
> { return const_reverse_iterator(end()); }
>
>
>
>
>
>
> const_reverse_iterator
> crend() const noexcept
> { return const_reverse_iterator(begin()); }
>
>
>
>
>
>
>
> bool
> empty() const noexcept
> { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }
>
>
> size_type
> size() const noexcept
> {
>
> return this->_M_impl._M_size;
>
>
>
> }
>
>
> size_type
> max_size() const noexcept
> { return _M_get_Node_allocator().max_size(); }
># 900 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> resize(size_type __new_size);
># 913 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> resize(size_type __new_size, const value_type& __x);
># 935 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> 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;
> }
># 982 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> push_front(const value_type& __x)
> { this->_M_insert(begin(), __x); }
>
>
> void
> push_front(value_type&& __x)
> { this->_M_insert(begin(), std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace_front(_Args&&... __args)
> { this->_M_insert(begin(), std::forward<_Args>(__args)...); }
># 1009 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> pop_front()
> { this->_M_erase(begin()); }
># 1023 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> push_back(const value_type& __x)
> { this->_M_insert(end(), __x); }
>
>
> void
> push_back(value_type&& __x)
> { this->_M_insert(end(), std::move(__x)); }
>
> template<typename... _Args>
> void
> emplace_back(_Args&&... __args)
> { this->_M_insert(end(), std::forward<_Args>(__args)...); }
># 1049 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> pop_back()
> { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
># 1066 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename... _Args>
> iterator
> emplace(iterator __position, _Args&&... __args);
># 1082 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> iterator
> insert(iterator __position, const value_type& __x);
># 1097 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> iterator
> insert(iterator __position, value_type&& __x)
> { return emplace(__position, std::move(__x)); }
># 1114 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> insert(iterator __p, initializer_list<value_type> __l)
> { this->insert(__p, __l.begin(), __l.end()); }
># 1131 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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);
> }
># 1151 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _InputIterator>
> void
> insert(iterator __position, _InputIterator __first,
> _InputIterator __last)
> {
> list __tmp(__first, __last, get_allocator());
> splice(__position, __tmp);
> }
># 1175 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> iterator
> erase(iterator __position);
># 1196 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> iterator
> erase(iterator __first, iterator __last)
> {
> while (__first != __last)
> __first = erase(__first);
> return __last;
> }
># 1213 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> swap(list& __x)
> {
> __detail::_List_node_base::swap(this->_M_impl._M_node,
> __x._M_impl._M_node);
>
> std::swap(this->_M_impl._M_size, __x._M_impl._M_size);
>
>
>
>
> std::__alloc_swap<typename _Base::_Node_alloc_type>::
> _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator());
> }
>
>
>
>
>
>
>
> void
> clear() noexcept
> {
> _Base::_M_clear();
> _Base::_M_init();
> }
># 1253 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
>
> splice(iterator __position, list&& __x)
>
>
>
> {
> if (!__x.empty())
> {
> _M_check_equal_allocators(__x);
>
> this->_M_transfer(__position, __x.begin(), __x.end());
>
>
> this->_M_impl._M_size += __x.size();
> __x._M_impl._M_size = 0;
>
> }
> }
>
>
> void
> splice(iterator __position, list& __x)
> { splice(__position, std::move(__x)); }
># 1288 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
>
> splice(iterator __position, list&& __x, iterator __i)
>
>
>
> {
> iterator __j = __i;
> ++__j;
> if (__position == __i || __position == __j)
> return;
>
> if (this != &__x)
> {
> _M_check_equal_allocators(__x);
>
>
> ++this->_M_impl._M_size;
> --__x._M_impl._M_size;
>
> }
>
> this->_M_transfer(__position, __i, __j);
> }
>
>
> void
> splice(iterator __position, list& __x, iterator __i)
> { splice(__position, std::move(__x), __i); }
># 1331 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/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);
>
>
> const size_type __size = std::distance(__first, __last);
> this->_M_impl._M_size += __size;
> __x._M_impl._M_size -= __size;
>
> }
>
> this->_M_transfer(__position, __first, __last);
> }
> }
>
>
> void
> splice(iterator __position, list& __x, iterator __first, iterator __last)
> { splice(__position, std::move(__x), __first, __last); }
># 1374 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> remove(const _Tp& __value);
># 1388 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _Predicate>
> void
> remove_if(_Predicate);
># 1402 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> unique();
># 1417 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _BinaryPredicate>
> void
> unique(_BinaryPredicate);
># 1431 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> merge(list&& __x);
>
> void
> merge(list& __x)
> { merge(std::move(__x)); }
># 1456 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _StrictWeakOrdering>
> void
> merge(list&& __x, _StrictWeakOrdering __comp);
>
> template<typename _StrictWeakOrdering>
> void
> merge(list& __x, _StrictWeakOrdering __comp)
> { merge(std::move(__x), __comp); }
># 1475 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> void
> reverse() noexcept
> { this->_M_impl._M_node._M_reverse(); }
>
>
>
>
>
>
>
> void
> sort();
>
>
>
>
>
>
>
> template<typename _StrictWeakOrdering>
> void
> sort(_StrictWeakOrdering);
>
> protected:
>
>
>
>
>
>
> template<typename _Integer>
> void
> _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
> { _M_fill_initialize(static_cast<size_type>(__n), __x); }
>
>
> template<typename _InputIterator>
> 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);
> }
>
>
>
> void
> _M_default_initialize(size_type __n)
> {
> for (; __n; --__n)
> emplace_back();
> }
>
>
> void
> _M_default_append(size_type __n);
># 1549 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _Integer>
> void
> _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
> { _M_fill_assign(__n, __val); }
>
>
> template<typename _InputIterator>
> 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); }
># 1580 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename... _Args>
> void
> _M_insert(iterator __position, _Args&&... __args)
> {
> _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
> __tmp->_M_hook(__position._M_node);
> }
>
>
>
> void
> _M_erase(iterator __position)
> {
> __position._M_node->_M_unhook();
> _Node* __n = static_cast<_Node*>(__position._M_node);
>
> _M_get_Node_allocator().destroy(__n);
>
>
>
> _M_put_node(__n);
> }
>
>
> void
> _M_check_equal_allocators(list& __x)
> {
> if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
> _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
> __throw_runtime_error(("list::_M_check_equal_allocators"));
> }
> };
># 1623 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc>
> inline bool
> operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> {
>
> return (__x.size() == __y.size()
> && std::equal(__x.begin(), __x.end(), __y.begin()));
># 1644 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> }
># 1657 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/stl_list.h" 3
> template<typename _Tp, typename _Alloc>
> 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<typename _Tp, typename _Alloc>
> inline bool
> operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return !(__x == __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return __y < __x; }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return !(__y < __x); }
>
>
> template<typename _Tp, typename _Alloc>
> inline bool
> operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
> { return !(__x < __y); }
>
>
> template<typename _Tp, typename _Alloc>
> inline void
> swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
> { __x.swap(__y); }
>
>
>}
># 65 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/list" 2 3
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/list.tcc" 1 3
># 60 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/list.tcc" 3
>namespace std __attribute__ ((__visibility__ ("default")))
>{
>
>
> template<typename _Tp, typename _Alloc>
> void
> _List_base<_Tp, _Alloc>::
> _M_clear()
> {
> typedef _List_node<_Tp> _Node;
> _Node* __cur = static_cast<_Node*>(_M_impl._M_node._M_next);
> while (__cur != &_M_impl._M_node)
> {
> _Node* __tmp = __cur;
> __cur = static_cast<_Node*>(__cur->_M_next);
>
> _M_get_Node_allocator().destroy(__tmp);
>
>
>
> _M_put_node(__tmp);
> }
> }
>
>
> template<typename _Tp, typename _Alloc>
> template<typename... _Args>
> typename list<_Tp, _Alloc>::iterator
> list<_Tp, _Alloc>::
> emplace(iterator __position, _Args&&... __args)
> {
> _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
> __tmp->_M_hook(__position._M_node);
> return iterator(__tmp);
> }
>
>
> template<typename _Tp, typename _Alloc>
> 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_node);
> return iterator(__tmp);
> }
>
> template<typename _Tp, typename _Alloc>
> typename list<_Tp, _Alloc>::iterator
> list<_Tp, _Alloc>::
> erase(iterator __position)
> {
> iterator __ret = iterator(__position._M_node->_M_next);
> _M_erase(__position);
> return __ret;
> }
>
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> _M_default_append(size_type __n)
> {
> size_type __i = 0;
> try
> {
> for (; __i < __n; ++__i)
> emplace_back();
> }
> catch(...)
> {
> for (; __i; --__i)
> pop_back();
> throw;
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> resize(size_type __new_size)
> {
> if (__new_size > size())
> _M_default_append(__new_size - size());
> else if (__new_size < size())
> {
> iterator __i = begin();
> std::advance(__i, __new_size);
> erase(__i, end());
> }
> }
>
> template<typename _Tp, typename _Alloc>
> void
> list<_Tp, _Alloc>::
> resize(size_type __new_size, const value_type& __x)
> {
> if (__new_size > size())
> insert(end(), __new_size - size(), __x);
> else if (__new_size < size())
> {
> iterator __i = begin();
> std::advance(__i, __new_size);
> erase(__i, end());
> }
> }
># 183 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/bits/list.tcc" 3
> template<typename _Tp, typename _Alloc>
> 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<typename _Tp, typename _Alloc>
> 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<typename _Tp, typename _Alloc>
> template <typename _InputIterator>
> 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<typename _Tp, typename _Alloc>
> 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<typename _Tp, typename _Alloc>
> 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<typename _Tp, typename _Alloc>
> 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_impl._M_size += __x.size();
> __x._M_impl._M_size = 0;
>
> }
> }
>
> template<typename _Tp, typename _Alloc>
> template <typename _StrictWeakOrdering>
> 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_impl._M_size += __x.size();
> __x._M_impl._M_size = 0;
>
> }
> }
>
> template<typename _Tp, typename _Alloc>
> 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<typename _Tp, typename _Alloc>
> template <typename _Predicate>
> 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<typename _Tp, typename _Alloc>
> template <typename _BinaryPredicate>
> 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<typename _Tp, typename _Alloc>
> template <typename _StrictWeakOrdering>
> 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));
> }
> }
>
>
>}
># 66 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/../../../../include/c++/4.7.0/list" 2 3
># 51 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h" 2
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/limits.h" 1 3 4
># 34 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/limits.h" 3 4
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/syslimits.h" 1 3 4
>
>
>
>
>
>
># 1 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/limits.h" 1 3 4
># 169 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/limits.h" 3 4
># 1 "/usr/include/limits.h" 1 3 4
># 145 "/usr/include/limits.h" 3 4
># 1 "/usr/include/bits/posix1_lim.h" 1 3 4
># 157 "/usr/include/bits/posix1_lim.h" 3 4
># 1 "/usr/include/bits/local_lim.h" 1 3 4
># 39 "/usr/include/bits/local_lim.h" 3 4
># 1 "/usr/include/linux/limits.h" 1 3 4
># 40 "/usr/include/bits/local_lim.h" 2 3 4
># 158 "/usr/include/bits/posix1_lim.h" 2 3 4
># 146 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/posix2_lim.h" 1 3 4
># 150 "/usr/include/limits.h" 2 3 4
>
>
>
># 1 "/usr/include/bits/xopen_lim.h" 1 3 4
># 34 "/usr/include/bits/xopen_lim.h" 3 4
># 1 "/usr/include/bits/stdio_lim.h" 1 3 4
># 35 "/usr/include/bits/xopen_lim.h" 2 3 4
># 154 "/usr/include/limits.h" 2 3 4
># 170 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/limits.h" 2 3 4
># 8 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/syslimits.h" 2 3 4
># 35 "/usr/lib/gcc/x86_64-redhat-linux/4.7.0/include/limits.h" 2 3 4
># 58 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h" 2
>
>
>
>
>
>
>
>template <typename T> class QVector;
>template <typename T> class QSet;
>
>struct __attribute__((visibility("default"))) QListData {
> struct Data {
> QtPrivate::RefCount ref;
> int alloc, begin, end;
> void *array[1];
> };
> enum { DataHeaderSize = sizeof(Data) - sizeof(void *) };
>
> Data *detach(int alloc);
> Data *detach_grow(int *i, int n);
> void realloc(int alloc);
> static const Data shared_null;
> Data *d;
> void **erase(void **xi);
> void **append(int n);
> void **append();
> void **append(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 <typename T>
>class QList
>{
> struct Node { void *v;
>
>
>
> inline T &t()
> { return *reinterpret_cast<T*>(QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic
> ? v : this); }
>
> };
>
> union { QListData p; QListData::Data *d; };
>
>public:
> inline QList() : d(const_cast<QListData::Data *>(&QListData::shared_null)) { }
> QList(const QList<T> &l);
> ~QList();
> QList<T> &operator=(const QList<T> &l);
>
> inline QList(QList<T> &&other) : d(other.d) { other.d = const_cast<QListData::Data *>(&QListData::shared_null); }
> inline QList &operator=(QList<T> &&other)
> { qSwap(d, other.d); return *this; }
>
> inline void swap(QList<T> &other) { qSwap(d, other.d); }
>
> inline QList(std::initializer_list<T> args)
> : d(const_cast<QListData::Data *>(&QListData::shared_null))
> { qCopy(args.begin(), args.end(), std::back_inserter(*this)); }
>
> bool operator==(const QList<T> &l) const;
> inline bool operator!=(const QList<T> &l) const { return !(*this == l); }
>
> inline int size() const { return p.size(); }
>
> inline void detach() { if (d->ref.isShared()) detach_helper(); }
>
> inline void detachShared()
> {
>
> if (d->ref.isShared() && this->d != &QListData::shared_null)
> detach_helper();
> }
>
> inline bool isDetached() const { return !d->ref.isShared(); }
> inline void setSharable(bool sharable)
> {
> if (sharable == d->ref.isSharable())
> return;
> if (!sharable)
> detach();
> if (d != &QListData::shared_null)
> d->ref.setSharable(sharable);
> }
> inline bool isSharedWith(const QList<T> &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> &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;
> bool 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<Node *>(p.begin()); }
> inline const_iterator begin() const { return reinterpret_cast<Node *>(p.begin()); }
> inline const_iterator cbegin() const { return reinterpret_cast<Node *>(p.begin()); }
> inline const_iterator constBegin() const { return reinterpret_cast<Node *>(p.begin()); }
> inline iterator end() { detach(); return reinterpret_cast<Node *>(p.end()); }
> inline const_iterator end() const { return reinterpret_cast<Node *>(p.end()); }
> inline const_iterator cend() const { return reinterpret_cast<Node *>(p.end()); }
> inline const_iterator constEnd() const { return reinterpret_cast<Node *>(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() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",286) : qt_noop()); return *begin(); }
> inline const T& first() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",287) : qt_noop()); return at(0); }
> T& last() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",288) : qt_noop()); return *(--end()); }
> const T& last() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",289) : qt_noop()); return at(count() - 1); }
> inline void removeFirst() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",290) : qt_noop()); erase(begin()); }
> inline void removeLast() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",291) : 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<T> 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;
>
>
> QList<T> &operator+=(const QList<T> &l);
> inline QList<T> operator+(const QList<T> &l) const
> { QList n = *this; n += l; return n; }
> inline QList<T> &operator+=(const T &t)
> { append(t); return *this; }
> inline QList<T> &operator<< (const T &t)
> { append(t); return *this; }
> inline QList<T> &operator<<(const QList<T> &l)
> { *this += l; return *this; }
>
> QVector<T> toVector() const;
> QSet<T> toSet() const;
>
> static QList<T> fromVector(const QVector<T> &vector);
> static QList<T> fromSet(const QSet<T> &set);
>
> static inline QList<T> fromStdList(const std::list<T> &list)
> { QList<T> tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }
> inline std::list<T> toStdList() const
> { std::list<T> 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 dealloc(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 <typename T>
>inline void QList<T>::node_construct(Node *n, const T &t)
>{
> if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) n->v = new T(t);
> else if (QTypeInfo<T>::isComplex) new (n) T(t);
>
>
>
>
>
>
>
> else ::memcpy(n, &t, sizeof(T));
>
>}
>
>template <typename T>
>inline void QList<T>::node_destruct(Node *n)
>{
> if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) delete reinterpret_cast<T*>(n->v);
> else if (QTypeInfo<T>::isComplex) reinterpret_cast<T*>(n)->~T();
>}
>
>template <typename T>
>inline void QList<T>::node_copy(Node *from, Node *to, Node *src)
>{
> Node *current = from;
> if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
> try {
> while(current != to) {
> current->v = new T(*reinterpret_cast<T*>(src->v));
> ++current;
> ++src;
> }
> } catch (...) {
> while (current-- != from)
> delete reinterpret_cast<T*>(current->v);
> throw;
> }
>
> } else if (QTypeInfo<T>::isComplex) {
> try {
> while(current != to) {
> new (current) T(*reinterpret_cast<T*>(src));
> ++current;
> ++src;
> }
> } catch (...) {
> while (current-- != from)
> (reinterpret_cast<T*>(current))->~T();
> throw;
> }
> } else {
> if (src != from && to - from > 0)
> memcpy(from, src, (to - from) * sizeof(Node));
> }
>}
>
>template <typename T>
>inline void QList<T>::node_destruct(Node *from, Node *to)
>{
> if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic)
> while(from != to) --to, delete reinterpret_cast<T*>(to->v);
> else if (QTypeInfo<T>::isComplex)
> while (from != to) --to, reinterpret_cast<T*>(to)->~T();
>}
>
>template <typename T>
>inline QList<T> &QList<T>::operator=(const QList<T> &l)
>{
> if (d != l.d) {
> QList<T> tmp(l);
> tmp.swap(*this);
> }
> return *this;
>}
>template <typename T>
>inline typename QList<T>::iterator QList<T>::insert(iterator before, const T &t)
>{
> int iBefore = int(before.i - reinterpret_cast<Node *>(p.begin()));
> Node *n = reinterpret_cast<Node *>(p.insert(iBefore));
> try {
> node_construct(n, t);
> } catch (...) {
> p.remove(iBefore);
> throw;
> }
> return n;
>}
>template <typename T>
>inline typename QList<T>::iterator QList<T>::erase(iterator it)
>{ node_destruct(it.i);
> return reinterpret_cast<Node *>(p.erase(reinterpret_cast<void**>(it.i))); }
>template <typename T>
>inline const T &QList<T>::at(int i) const
>{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::at", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",452) : qt_noop());
> return reinterpret_cast<Node *>(p.at(i))->t(); }
>template <typename T>
>inline const T &QList<T>::operator[](int i) const
>{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::operator[]", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",456) : qt_noop());
> return reinterpret_cast<Node *>(p.at(i))->t(); }
>template <typename T>
>inline T &QList<T>::operator[](int i)
>{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::operator[]", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",460) : qt_noop());
> detach(); return reinterpret_cast<Node *>(p.at(i))->t(); }
>template <typename T>
>inline void QList<T>::removeAt(int i)
>{ if(i >= 0 && i < p.size()) { detach();
> node_destruct(reinterpret_cast<Node *>(p.at(i))); p.remove(i); } }
>template <typename T>
>inline T QList<T>::takeAt(int i)
>{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::take", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",468) : qt_noop());
> detach(); Node *n = reinterpret_cast<Node *>(p.at(i)); T t = n->t(); node_destruct(n);
> p.remove(i); return t; }
>template <typename T>
>inline T QList<T>::takeFirst()
>{ T t = first(); removeFirst(); return t; }
>template <typename T>
>inline T QList<T>::takeLast()
>{ T t = last(); removeLast(); return t; }
>
>template <typename T>
> void QList<T>::reserve(int alloc)
>{
> if (d->alloc < alloc) {
> if (d->ref.isShared())
> detach_helper(alloc);
> else
> p.realloc(alloc);
> }
>}
>
>template <typename T>
> void QList<T>::append(const T &t)
>{
> if (d->ref.isShared()) {
> Node *n = detach_helper_grow(2147483647, 1);
> try {
> node_construct(n, t);
> } catch (...) {
> --d->end;
> throw;
> }
> } else {
> if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
> Node *n = reinterpret_cast<Node *>(p.append());
> try {
> node_construct(n, t);
> } catch (...) {
> --d->end;
> throw;
> }
> } else {
> Node *n, copy;
> node_construct(&copy, t);
> try {
> n = reinterpret_cast<Node *>(p.append());;
> } catch (...) {
> node_destruct(&copy);
> throw;
> }
> *n = copy;
> }
> }
>}
>
>template <typename T>
>inline void QList<T>::prepend(const T &t)
>{
> if (d->ref.isShared()) {
> Node *n = detach_helper_grow(0, 1);
> try {
> node_construct(n, t);
> } catch (...) {
> ++d->begin;
> throw;
> }
> } else {
> if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
> Node *n = reinterpret_cast<Node *>(p.prepend());
> try {
> node_construct(n, t);
> } catch (...) {
> ++d->begin;
> throw;
> }
> } else {
> Node *n, copy;
> node_construct(&copy, t);
> try {
> n = reinterpret_cast<Node *>(p.prepend());;
> } catch (...) {
> node_destruct(&copy);
> throw;
> }
> *n = copy;
> }
> }
>}
>
>template <typename T>
>inline void QList<T>::insert(int i, const T &t)
>{
> if (d->ref.isShared()) {
> Node *n = detach_helper_grow(i, 1);
> try {
> node_construct(n, t);
> } catch (...) {
> p.remove(i);
> throw;
> }
> } else {
> if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
> Node *n = reinterpret_cast<Node *>(p.insert(i));
> try {
> node_construct(n, t);
> } catch (...) {
> p.remove(i);
> throw;
> }
> } else {
> Node *n, copy;
> node_construct(&copy, t);
> try {
> n = reinterpret_cast<Node *>(p.insert(i));;
> } catch (...) {
> node_destruct(&copy);
> throw;
> }
> *n = copy;
> }
> }
>}
>
>template <typename T>
>inline void QList<T>::replace(int i, const T &t)
>{
> ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::replace", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",594) : qt_noop());
> detach();
> reinterpret_cast<Node *>(p.at(i))->t() = t;
>}
>
>template <typename T>
>inline void QList<T>::swap(int i, int j)
>{
> ((!(i >= 0 && i < p.size() && j >= 0 && j < p.size())) ? qt_assert_x("QList<T>::swap", "index out of range",
> "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h"
># 602 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h"
> ,
> 603
># 602 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h"
> ) : 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 <typename T>
>inline void QList<T>::move(int from, int to)
>{
> ((!(from >= 0 && from < p.size() && to >= 0 && to < p.size())) ? qt_assert_x("QList<T>::move", "index out of range",
> "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h"
># 613 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h"
> ,
> 614
># 613 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h"
> ) : qt_noop())
> ;
> detach();
> p.move(from, to);
>}
>
>template<typename T>
> QList<T> QList<T>::mid(int pos, int alength) const
>{
> if (alength < 0 || pos + alength > size())
> alength = size() - pos;
> if (pos == 0 && alength == size())
> return *this;
> QList<T> cpy;
> if (alength <= 0)
> return cpy;
> cpy.reserve(alength);
> cpy.d->end = alength;
> try {
> cpy.node_copy(reinterpret_cast<Node *>(cpy.p.begin()),
> reinterpret_cast<Node *>(cpy.p.end()),
> reinterpret_cast<Node *>(p.begin() + pos));
> } catch (...) {
>
> cpy.d->end = 0;
> throw;
> }
> return cpy;
>}
>
>template<typename T>
> T QList<T>::value(int i) const
>{
> if (i < 0 || i >= p.size()) {
> return T();
> }
> return reinterpret_cast<Node *>(p.at(i))->t();
>}
>
>template<typename T>
> T QList<T>::value(int i, const T& defaultValue) const
>{
> return ((i < 0 || i >= p.size()) ? defaultValue : reinterpret_cast<Node *>(p.at(i))->t());
>}
>
>template <typename T>
> typename QList<T>::Node *QList<T>::detach_helper_grow(int i, int c)
>{
> Node *n = reinterpret_cast<Node *>(p.begin());
> QListData::Data *x = p.detach_grow(&i, c);
> try {
> node_copy(reinterpret_cast<Node *>(p.begin()),
> reinterpret_cast<Node *>(p.begin() + i), n);
> } catch (...) {
> free(d);
> d = x;
> throw;
> }
> try {
> node_copy(reinterpret_cast<Node *>(p.begin() + i + c),
> reinterpret_cast<Node *>(p.end()), n + i);
> } catch (...) {
> node_destruct(reinterpret_cast<Node *>(p.begin()),
> reinterpret_cast<Node *>(p.begin() + i));
> free(d);
> d = x;
> throw;
> }
>
> if (!x->ref.deref())
> dealloc(x);
>
> return reinterpret_cast<Node *>(p.begin() + i);
>}
>
>template <typename T>
> void QList<T>::detach_helper(int alloc)
>{
> Node *n = reinterpret_cast<Node *>(p.begin());
> QListData::Data *x = p.detach(alloc);
> try {
> node_copy(reinterpret_cast<Node *>(p.begin()), reinterpret_cast<Node *>(p.end()), n);
> } catch (...) {
> free(d);
> d = x;
> throw;
> }
>
> if (!x->ref.deref())
> dealloc(x);
>}
>
>template <typename T>
> void QList<T>::detach_helper()
>{
> detach_helper(d->alloc);
>}
>
>template <typename T>
> QList<T>::QList(const QList<T> &l)
> : d(l.d)
>{
> if (!d->ref.ref()) {
> p.detach(d->alloc);
>
> struct Cleanup
> {
> Cleanup(QListData::Data *d) : d_(d) {}
> ~Cleanup() { if (d_) free(d_); }
>
> QListData::Data *d_;
> } tryCatch(d);
>
> node_copy(reinterpret_cast<Node *>(p.begin()),
> reinterpret_cast<Node *>(p.end()),
> reinterpret_cast<Node *>(l.p.begin()));
> tryCatch.d_ = 0;
> }
>}
>
>template <typename T>
> QList<T>::~QList()
>{
> if (!d->ref.deref())
> dealloc(d);
>}
>
>template <typename T>
> bool QList<T>::operator==(const QList<T> &l) const
>{
> if (p.size() != l.p.size())
> return false;
> if (d == l.d)
> return true;
> Node *i = reinterpret_cast<Node *>(p.end());
> Node *b = reinterpret_cast<Node *>(p.begin());
> Node *li = reinterpret_cast<Node *>(l.p.end());
> while (i != b) {
> --i; --li;
> if (!(i->t() == li->t()))
> return false;
> }
> return true;
>}
>
>template <typename T>
> void QList<T>::dealloc(QListData::Data *data)
>{
> node_destruct(reinterpret_cast<Node *>(data->array + data->begin),
> reinterpret_cast<Node *>(data->array + data->end));
> free(data);
>}
>
>
>template <typename T>
> void QList<T>::clear()
>{
> *this = QList<T>();
>}
>
>template <typename T>
> int QList<T>::removeAll(const T &_t)
>{
> int index = indexOf(_t);
> if (index == -1)
> return 0;
>
> const T t = _t;
> detach();
>
> Node *i = reinterpret_cast<Node *>(p.at(index));
> Node *e = reinterpret_cast<Node *>(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 <typename T>
> bool QList<T>::removeOne(const T &_t)
>{
> int index = indexOf(_t);
> if (index != -1) {
> removeAt(index);
> return true;
> }
> return false;
>}
>
>template <typename T>
> typename QList<T>::iterator QList<T>::erase(typename QList<T>::iterator afirst,
> typename QList<T>::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 <typename T>
> QList<T> &QList<T>::operator+=(const QList<T> &l)
>{
> if (!l.isEmpty()) {
> if (isEmpty()) {
> *this = l;
> } else {
> Node *n = (d->ref.isShared())
> ? detach_helper_grow(2147483647, l.size())
> : reinterpret_cast<Node *>(p.append(l.p));
> try {
> node_copy(n, reinterpret_cast<Node *>(p.end()),
> reinterpret_cast<Node *>(l.p.begin()));
> } catch (...) {
>
> d->end -= int(reinterpret_cast<Node *>(p.end()) - n);
> throw;
> }
> }
> }
> return *this;
>}
>
>template <typename T>
>inline void QList<T>::append(const QList<T> &t)
>{
> *this += t;
>}
>
>template <typename T>
> int QList<T>::indexOf(const T &t, int from) const
>{
> if (from < 0)
> from = qMax(from + p.size(), 0);
> if (from < p.size()) {
> Node *n = reinterpret_cast<Node *>(p.at(from -1));
> Node *e = reinterpret_cast<Node *>(p.end());
> while (++n != e)
> if (n->t() == t)
> return int(n - reinterpret_cast<Node *>(p.begin()));
> }
> return -1;
>}
>
>template <typename T>
> int QList<T>::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<Node *>(p.begin());
> Node *n = reinterpret_cast<Node *>(p.at(from + 1));
> while (n-- != b) {
> if (n->t() == t)
> return n - b;
> }
> }
> return -1;
>}
>
>template <typename T>
> bool QList<T>::contains(const T &t) const
>{
> Node *b = reinterpret_cast<Node *>(p.begin());
> Node *i = reinterpret_cast<Node *>(p.end());
> while (i-- != b)
> if (i->t() == t)
> return true;
> return false;
>}
>
>template <typename T>
> int QList<T>::count(const T &t) const
>{
> int c = 0;
> Node *b = reinterpret_cast<Node *>(p.begin());
> Node *i = reinterpret_cast<Node *>(p.end());
> while (i-- != b)
> if (i->t() == t)
> ++c;
> return c;
>}
>
>template <class T> class QListIterator { typedef typename QList<T>::const_iterator const_iterator; QList<T> c; const_iterator i; public: inline QListIterator(const QList<T> &container) : c(container), i(c.constBegin()) {} inline QListIterator &operator=(const QList<T> &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 T> class QMutableListIterator { typedef typename QList<T>::iterator iterator; typedef typename QList<T>::const_iterator const_iterator; QList<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableListIterator(QList<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableListIterator() { c->setSharable(true); } inline QMutableListIterator &operator=(QList<T> &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() { ((!(item_exists())) ? qt_assert("item_exists()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",907) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qlist.h",907) : 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; } };
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qlist.h" 2
># 51 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h" 2
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qscopedpointer.h" 1
># 55 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qmetatype.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 1
># 42 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 43 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qbytearray.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qvarlengtharray.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qcontainerfwd.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qcontainerfwd.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qcontainerfwd.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qcontainerfwd.h" 2
>
>
>
>
>
>
>template <class Key, class T> class QCache;
>template <class Key, class T> class QHash;
>template <class T> class QLinkedList;
>template <class T> class QList;
>template <class Key, class T> class QMap;
>template <class Key, class T> class QMultiHash;
>template <class Key, class T> class QMultiMap;
>template <class T1, class T2> struct QPair;
>template <class T> class QQueue;
>template <class T> class QSet;
>template <class T> class QStack;
>template<class T, int Prealloc = 256> class QVarLengthArray;
>template <class T> class QVector;
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qcontainerfwd.h" 2
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qalgorithms.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h" 2
>
>
>
>
>
>
>
>
>
>
>template<class T, int Prealloc>
>class QPodList;
>
>
>template<class T, int Prealloc>
>class QVarLengthArray
>{
>public:
> inline explicit QVarLengthArray(int size = 0);
>
> inline QVarLengthArray(const QVarLengthArray<T, Prealloc> &other)
> : a(Prealloc), s(0), ptr(reinterpret_cast<T *>(array))
> {
> append(other.constData(), other.size());
> }
>
> inline ~QVarLengthArray() {
> if (QTypeInfo<T>::isComplex) {
> T *i = ptr + s;
> while (i-- != ptr)
> i->~T();
> }
> if (ptr != reinterpret_cast<T *>(array))
> free(ptr);
> }
> inline QVarLengthArray<T, Prealloc> &operator=(const QVarLengthArray<T, Prealloc> &other)
> {
> if (this != &other) {
> clear();
> append(other.constData(), other.size());
> }
> return *this;
> }
>
> inline void removeLast() {
> ((!(s > 0)) ? qt_assert("s > 0","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",93) : qt_noop());
> realloc(s - 1, a);
> }
> inline int size() const { return s; }
> inline int count() const { return s; }
> inline int length() const { return s; }
> inline T& first() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",99) : qt_noop()); return *begin(); }
> inline const T& first() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",100) : qt_noop()); return *begin(); }
> T& last() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",101) : qt_noop()); return *(end() - 1); }
> const T& last() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",102) : qt_noop()); return *(end() - 1); }
> inline bool isEmpty() const { return (s == 0); }
> inline void resize(int size);
> inline void clear() { resize(0); }
>
> inline int capacity() const { return a; }
> inline void reserve(int size);
>
> inline T &operator[](int idx) {
> ((!(idx >= 0 && idx < s)) ? qt_assert("idx >= 0 && idx < s","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",111) : qt_noop());
> return ptr[idx];
> }
> inline const T &operator[](int idx) const {
> ((!(idx >= 0 && idx < s)) ? qt_assert("idx >= 0 && idx < s","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",115) : qt_noop());
> return ptr[idx];
> }
> inline const T &at(int idx) const { return operator[](idx); }
>
> T value(int i) const;
> T value(int i, const T &defaultValue) const;
>
> inline void append(const T &t) {
> if (s == a)
> realloc(s, s<<1);
> const int idx = s++;
> if (QTypeInfo<T>::isComplex) {
> new (ptr + idx) T(t);
> } else {
> ptr[idx] = t;
> }
> }
> void append(const T *buf, int size);
> inline QVarLengthArray<T, Prealloc> &operator<<(const T &t)
> { append(t); return *this; }
> inline QVarLengthArray<T, Prealloc> &operator+=(const T &t)
> { append(t); return *this; }
>
> void prepend(const T &t);
> void insert(int i, const T &t);
> void insert(int i, int n, const T &t);
> void replace(int i, const T &t);
> void remove(int i);
> void remove(int i, int n);
>
>
> inline T *data() { return ptr; }
> inline const T *data() const { return ptr; }
> inline const T * constData() const { return ptr; }
> 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;
>
>
> typedef T* iterator;
> typedef const T* const_iterator;
>
> inline iterator begin() { return ptr; }
> inline const_iterator begin() const { return ptr; }
> inline const_iterator cbegin() const { return ptr; }
> inline const_iterator constBegin() const { return ptr; }
> inline iterator end() { return ptr + s; }
> inline const_iterator end() const { return ptr + s; }
> inline const_iterator cend() const { return ptr + s; }
> inline const_iterator constEnd() const { return ptr + s; }
> iterator insert(iterator before, int n, const T &x);
> inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); }
> iterator erase(iterator begin, iterator end);
> inline iterator erase(iterator pos) { return erase(pos, pos+1); }
>
>private:
> friend class QPodList<T, Prealloc>;
> void realloc(int size, int alloc);
>
> int a;
> int s;
> T *ptr;
> union {
> char array[Prealloc * sizeof(T)];
> qint64 q_for_alignment_1;
> double q_for_alignment_2;
> };
>};
>
>template <class T, int Prealloc>
>inline QVarLengthArray<T, Prealloc>::QVarLengthArray(int asize)
> : s(asize) {
> if (s > Prealloc) {
> ptr = reinterpret_cast<T *>(malloc(s * sizeof(T)));
> do { if (!(ptr)) qBadAlloc(); } while (0);
> a = s;
> } else {
> ptr = reinterpret_cast<T *>(array);
> a = Prealloc;
> }
> if (QTypeInfo<T>::isComplex) {
> T *i = ptr + s;
> while (i != ptr)
> new (--i) T;
> }
>}
>
>template <class T, int Prealloc>
>inline void QVarLengthArray<T, Prealloc>::resize(int asize)
>{ realloc(asize, qMax(asize, a)); }
>
>template <class T, int Prealloc>
>inline void QVarLengthArray<T, Prealloc>::reserve(int asize)
>{ if (asize > a) realloc(s, asize); }
>
>template <class T, int Prealloc>
> void QVarLengthArray<T, Prealloc>::append(const T *abuf, int increment)
>{
> ((!(abuf)) ? qt_assert("abuf","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",218) : qt_noop());
> if (increment <= 0)
> return;
>
> const int asize = s + increment;
>
> if (asize >= a)
> realloc(s, qMax(s*2, asize));
>
> if (QTypeInfo<T>::isComplex) {
>
> while (s < asize)
> new (ptr+(s++)) T(*abuf++);
> } else {
> memcpy(&ptr[s], abuf, increment * sizeof(T));
> s = asize;
> }
>}
>
>template <class T, int Prealloc>
> void QVarLengthArray<T, Prealloc>::realloc(int asize, int aalloc)
>{
> ((!(aalloc >= asize)) ? qt_assert("aalloc >= asize","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",240) : qt_noop());
> T *oldPtr = ptr;
> int osize = s;
>
> const int copySize = qMin(asize, osize);
> if (aalloc != a) {
> ptr = reinterpret_cast<T *>(malloc(aalloc * sizeof(T)));
> do { if (!(ptr)) qBadAlloc(); } while (0);
> if (ptr) {
> s = 0;
> a = aalloc;
>
> if (QTypeInfo<T>::isStatic) {
> try {
>
> while (s < copySize) {
> new (ptr+s) T(*(oldPtr+s));
> (oldPtr+s)->~T();
> s++;
> }
> } catch (...) {
>
> int sClean = s;
> while (sClean < osize)
> (oldPtr+(sClean++))->~T();
> if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
> free(oldPtr);
> throw;
> }
> } else {
> memcpy(ptr, oldPtr, copySize * sizeof(T));
> }
> } else {
> ptr = oldPtr;
> return;
> }
> }
> s = copySize;
>
> if (QTypeInfo<T>::isComplex) {
>
> while (osize > asize)
> (oldPtr+(--osize))->~T();
> }
>
> if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr)
> free(oldPtr);
>
> if (QTypeInfo<T>::isComplex) {
>
> while (s < asize)
> new (ptr+(s++)) T;
> } else {
> s = asize;
> }
>}
>
>template <class T, int Prealloc>
> T QVarLengthArray<T, Prealloc>::value(int i) const
>{
> if (i < 0 || i >= size()) {
> return T();
> }
> return at(i);
>}
>template <class T, int Prealloc>
> T QVarLengthArray<T, Prealloc>::value(int i, const T &defaultValue) const
>{
> return (i < 0 || i >= size()) ? defaultValue : at(i);
>}
>
>template <class T, int Prealloc>
>inline void QVarLengthArray<T, Prealloc>::insert(int i, const T &t)
>{ ((!(i >= 0 && i <= s)) ? qt_assert_x("QVarLengthArray::insert", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",313) : qt_noop());
> insert(begin() + i, 1, t); }
>template <class T, int Prealloc>
>inline void QVarLengthArray<T, Prealloc>::insert(int i, int n, const T &t)
>{ ((!(i >= 0 && i <= s)) ? qt_assert_x("QVarLengthArray::insert", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",317) : qt_noop());
> insert(begin() + i, n, t); }
>template <class T, int Prealloc>
>inline void QVarLengthArray<T, Prealloc>::remove(int i, int n)
>{ ((!(i >= 0 && n >= 0 && i + n <= s)) ? qt_assert_x("QVarLengthArray::remove", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",321) : qt_noop());
> erase(begin() + i, begin() + i + n); }
>template <class T, int Prealloc>
>inline void QVarLengthArray<T, Prealloc>::remove(int i)
>{ ((!(i >= 0 && i < s)) ? qt_assert_x("QVarLengthArray::remove", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",325) : qt_noop());
> erase(begin() + i, begin() + i + 1); }
>template <class T, int Prealloc>
>inline void QVarLengthArray<T, Prealloc>::prepend(const T &t)
>{ insert(begin(), 1, t); }
>
>template <class T, int Prealloc>
>inline void QVarLengthArray<T, Prealloc>::replace(int i, const T &t)
>{
> ((!(i >= 0 && i < s)) ? qt_assert_x("QVarLengthArray::replace", "index out of range","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qvarlengtharray.h",334) : qt_noop());
> const T copy(t);
> data()[i] = copy;
>}
>
>
>template <class T, int Prealloc>
> typename QVarLengthArray<T, Prealloc>::iterator QVarLengthArray<T, Prealloc>::insert(iterator before, size_type n, const T &t)
>{
> int offset = int(before - ptr);
> if (n != 0) {
> resize(s + n);
> const T copy(t);
> if (QTypeInfo<T>::isStatic) {
> T *b = ptr + offset;
> T *j = ptr + s;
> T *i = j - n;
> while (i != b)
> *--j = *--i;
> i = b + n;
> while (i != b)
> *--i = copy;
> } else {
> T *b = ptr + offset;
> T *i = b + n;
> memmove(i, b, (s - offset - n) * sizeof(T));
> while (i != b)
> new (--i) T(copy);
> }
> }
> return ptr + offset;
>}
>
>template <class T, int Prealloc>
> typename QVarLengthArray<T, Prealloc>::iterator QVarLengthArray<T, Prealloc>::erase(iterator abegin, iterator aend)
>{
> int f = int(abegin - ptr);
> int l = int(aend - ptr);
> int n = l - f;
> if (QTypeInfo<T>::isComplex) {
> qCopy(ptr + l, ptr + s, ptr + f);
> T *i = ptr + s;
> T *b = ptr + s - n;
> while (i != b) {
> --i;
> i->~T();
> }
> } else {
> memmove(ptr + f, ptr + l, (s - l) * sizeof(T));
> }
> s -= n;
> return ptr + f;
>}
>
>template <typename T, int Prealloc1, int Prealloc2>
>bool operator==(const QVarLengthArray<T, Prealloc1> &l, const QVarLengthArray<T, Prealloc2> &r)
>{
> if (l.size() != r.size())
> return false;
> for (int i = 0; i < l.size(); i++) {
> if (l.at(i) != r.at(i))
> return false;
> }
> return true;
>}
>
>template <typename T, int Prealloc1, int Prealloc2>
>bool operator!=(const QVarLengthArray<T, Prealloc1> &l, const QVarLengthArray<T, Prealloc2> &r)
>{
> return !(l == r);
>}
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qvarlengtharray.h" 2
># 49 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qisenum.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qisenum.h" 1
># 42 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qisenum.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 43 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/global/qisenum.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qisenum.h" 2
># 50 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
>
># 1 "../../../../qt5/qtbase/include/QtCore/qobjectdefs.h" 1
># 52 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
>
>
>
>
>
>
>
>
>
>
># 189 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h"
>class QDataStream;
>class QMetaTypeInterface;
>struct QMetaObject;
>
>class __attribute__((visibility("default"))) QMetaType {
> enum ExtensionFlag { NoExtensionFlags,
> CreateEx = 0x1, DestroyEx = 0x2,
> ConstructEx = 0x4, DestructEx = 0x8,
> NameEx = 0x10, SizeEx = 0x20,
> CtorEx = 0x40, DtorEx = 0x80,
> FlagsEx = 0x100
> };
>public:
>
>
> enum Type {
>
> Void = 43, Bool = 1, Int = 2, UInt = 3, LongLong = 4, ULongLong = 5, Double = 6, Long = 32, Short = 33, Char = 34, ULong = 35, UShort = 36, UChar = 37, Float = 38, SChar = 49, VoidStar = 31, QChar = 7, 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, QEasingCurve = 29, QUuid = 30, QVariant = 41, QModelIndex = 42, QRegularExpression = 44, QJsonValue = 45, QJsonObject = 46, QJsonArray = 47, QJsonDocument = 48, QObjectStar = 39, QWidgetStar = 40, QVariantMap = 8, QVariantList = 9, QVariantHash = 28, QFont = 64, QPixmap = 65, QBrush = 66, QColor = 67, QPalette = 68, QIcon = 69, QImage = 70, QPolygon = 71, QRegion = 72, QBitmap = 73, QCursor = 74, QKeySequence = 75, QPen = 76, QTextLength = 77, QTextFormat = 78, QMatrix = 79, QTransform = 80, QMatrix4x4 = 81, QVector2D = 82, QVector3D = 83, QVector4D = 84, QQuaternion = 85, QPolygonF = 86, QSizePolicy = 121,
>
> FirstCoreType = Bool,
> LastCoreType = SChar,
> FirstGuiType = QFont,
> LastGuiType = QPolygonF,
> FirstWidgetsType = QSizePolicy,
> LastWidgetsType = QSizePolicy,
> HighestInternalId = LastWidgetsType,
>
> QReal = sizeof(qreal) == sizeof(double) ? Double : Float,
>
> UnknownType = 0,
> User = 1024
> };
># 245 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h"
> enum TypeFlag {
> NeedsConstruction = 0x1,
> NeedsDestruction = 0x2,
> MovableType = 0x4,
> PointerToQObject = 0x8,
> IsEnumeration = 0x10
> };
> typedef QFlags<TypeFlag> TypeFlags;
>
> typedef void (*Deleter)(void *);
> typedef void *(*Creator)(const void *);
>
> typedef void (*Destructor)(void *);
> typedef void *(*Constructor)(void *, 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, Deleter deleter,
> Creator creator);
> static int registerType(const char *typeName, Deleter deleter,
> Creator creator,
> Destructor destructor,
> Constructor constructor,
> int size,
> QMetaType::TypeFlags flags,
> const QMetaObject *metaObject);
> static int registerNormalizedType(const ::QByteArray &normalizedTypeName, Deleter deleter,
> Creator creator,
> Destructor destructor,
> Constructor constructor,
> int size,
> QMetaType::TypeFlags flags,
> const QMetaObject *metaObject);
> static int registerTypedef(const char *typeName, int aliasId);
> static int registerNormalizedTypedef(const ::QByteArray &normalizedTypeName, int aliasId);
> static int type(const char *typeName);
> static const char *typeName(int type);
> static int sizeOf(int type);
> static TypeFlags typeFlags(int type);
> static bool isRegistered(int type);
> static void *create(int type, const void *copy = 0);
>
> static void *construct(int type, const void *copy = 0)
> { return create(type, copy); }
>
> static void destroy(int type, void *data);
> static void *construct(int type, void *where, const void *copy);
> static void destruct(int type, void *where);
>
>
> static bool save(QDataStream &stream, int type, const void *data);
> static bool load(QDataStream &stream, int type, void *data);
>
>
> explicit QMetaType(const int type);
> inline ~QMetaType();
>
> inline bool isValid() const;
> inline bool isRegistered() const;
> inline int sizeOf() const;
> inline TypeFlags flags() const;
>
> inline void *create(const void *copy = 0) const;
> inline void destroy(void *data) const;
> inline void *construct(void *where, const void *copy = 0) const;
> inline void destruct(void *data) const;
>private:
> static QMetaType typeInfo(const int type);
> inline QMetaType(const ExtensionFlag extensionFlags, const QMetaTypeInterface *info,
> Creator creator,
> Deleter deleter,
> SaveOperator saveOp,
> LoadOperator loadOp,
> Constructor constructor,
> Destructor destructor,
> uint sizeOf,
> uint theTypeFlags,
> int typeId,
> const QMetaObject *metaObject);
> QMetaType(const QMetaType &other);
> QMetaType &operator =(const QMetaType &);
> inline bool isExtended(const ExtensionFlag flag) const { return m_extensionFlags & flag; }
>
>
> void ctor(const QMetaTypeInterface *info);
> void dtor();
> uint sizeExtended() const;
> QMetaType::TypeFlags flagsExtended() const;
> void *createExtended(const void *copy = 0) const;
> void destroyExtended(void *data) const;
> void *constructExtended(void *where, const void *copy = 0) const;
> void destructExtended(void *data) const;
>
> Creator m_creator;
> Deleter m_deleter;
> SaveOperator m_saveOp;
> LoadOperator m_loadOp;
> Constructor m_constructor;
> Destructor m_destructor;
> void *m_extension;
> uint m_size;
> uint m_typeFlags;
> uint m_extensionFlags;
> int m_typeId;
> const QMetaObject *m_metaObject;
>};
>
>
>
>constexpr inline QFlags<QMetaType::TypeFlags::enum_type> operator|(QMetaType::TypeFlags::enum_type f1, QMetaType::TypeFlags::enum_type f2) { return QFlags<QMetaType::TypeFlags::enum_type>(f1) | f2; } constexpr inline QFlags<QMetaType::TypeFlags::enum_type> operator|(QMetaType::TypeFlags::enum_type f1, QFlags<QMetaType::TypeFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QMetaType::TypeFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>
>template <typename T>
>void qMetaTypeDeleteHelper(void *t)
>{
> delete static_cast<T*>(t);
>}
>template <> inline void qMetaTypeDeleteHelper<void>(void *) {}
>
>template <typename T>
>void *qMetaTypeCreateHelper(const void *t)
>{
> if (t)
> return new T(*static_cast<const T*>(t));
> return new T();
>}
>
>template <> inline void *qMetaTypeCreateHelper<void>(const void *) { return 0; }
>
>template <typename T>
>void qMetaTypeDestructHelper(void *t)
>{
> (void)t;
> static_cast<T*>(t)->~T();
>}
>
>template <> inline void qMetaTypeDestructHelper<void>(void *) {}
>
>template <typename T>
>void *qMetaTypeConstructHelper(void *where, const void *t)
>{
> if (t)
> return new (where) T(*static_cast<const T*>(t));
> return new (where) T;
>}
>
>template <> inline void *qMetaTypeConstructHelper<void>(void *, const void *) { return 0; }
>
>
>template <typename T>
>void qMetaTypeSaveHelper(QDataStream &stream, const void *t)
>{
> stream << *static_cast<const T*>(t);
>}
>
>template <> inline void qMetaTypeSaveHelper<void>(QDataStream &, const void *) {}
>
>template <typename T>
>void qMetaTypeLoadHelper(QDataStream &stream, void *t)
>{
> stream >> *static_cast<T*>(t);
>}
>
>template <> inline void qMetaTypeLoadHelper<void>(QDataStream &, void *) {}
>
>
>class QObject;
>class QWidget;
>
>namespace QtPrivate
>{
> template<typename T>
> struct IsPointerToTypeDerivedFromQObject
> {
> enum { Value = false };
> };
>
>
> template<>
> struct IsPointerToTypeDerivedFromQObject<void*>
> {
> enum { Value = false };
> };
> template<>
> struct IsPointerToTypeDerivedFromQObject<QObject*>
> {
> enum { Value = true };
> };
> template<>
> struct IsPointerToTypeDerivedFromQObject<QWidget*>
> {
> enum { Value = true };
> };
>
> template<typename T>
> struct IsPointerToTypeDerivedFromQObject<T*>
> {
> typedef qint8 yes_type;
> typedef qint64 no_type;
>
>
> static yes_type checkType(QObject* );
>
> static no_type checkType(...);
> static_assert(bool(sizeof(T)), "Type argument of Q_DECLARE_METATYPE(T*) must be fully defined");
> enum { Value = sizeof(checkType(static_cast<T*>(0))) == sizeof(yes_type) };
> };
>
> template<typename T, bool = IsPointerToTypeDerivedFromQObject<T>::Value>
> struct MetaObjectForType
> {
> static inline const QMetaObject *value() { return 0; }
> };
> template<typename T>
> struct MetaObjectForType<T*, true>
> {
> static inline const QMetaObject *value() { return &T::staticMetaObject; }
> };
>}
>
>template <typename T, bool = QtPrivate::IsPointerToTypeDerivedFromQObject<T>::Value>
>struct QMetaTypeIdQObject
>{
> enum {
> Defined = 0
> };
>};
>
>template <typename T>
>struct QMetaTypeId : public QMetaTypeIdQObject<T>
>{
>};
>
>template <typename T>
>struct QMetaTypeId2
>{
> enum { Defined = QMetaTypeId<T>::Defined };
> static inline int qt_metatype_id() { return QMetaTypeId<T>::qt_metatype_id(); }
>};
>
>namespace QtPrivate {
> template <typename T, bool Defined = QMetaTypeId2<T>::Defined>
> struct QMetaTypeIdHelper {
> static inline int qt_metatype_id()
> { return QMetaTypeId2<T>::qt_metatype_id(); }
> };
> template <typename T> struct QMetaTypeIdHelper<T, false> {
> static inline int qt_metatype_id()
> { return -1; }
> };
>
>
> template <class Result> struct IsPointerToTypeDerivedFromQObject<Result(*)()> { enum { Value = false }; };
> template <class Result, class Arg0> struct IsPointerToTypeDerivedFromQObject<Result(*)(Arg0)> { enum { Value = false }; };
> template <class Result, class Arg0, class Arg1> struct IsPointerToTypeDerivedFromQObject<Result(*)(Arg0, Arg1)> { enum { Value = false }; };
> template <class Result, class Arg0, class Arg1, class Arg2> struct IsPointerToTypeDerivedFromQObject<Result(*)(Arg0, Arg1, Arg2)> { enum { Value = false }; };
>
> template<typename T>
> struct QMetaTypeTypeFlags
> {
> enum { Flags = (!QTypeInfo<T>::isStatic ? QMetaType::MovableType : 0)
> | (QTypeInfo<T>::isComplex ? QMetaType::NeedsConstruction : 0)
> | (QTypeInfo<T>::isComplex ? QMetaType::NeedsDestruction : 0)
> | (IsPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::PointerToQObject : 0)
> | (__is_enum(T) ? QMetaType::IsEnumeration : 0)
> };
> };
>}
>
>template <typename T>
>int qRegisterNormalizedMetaType(const ::QByteArray &normalizedTypeName
>
> , T * dummy = 0
>
>)
>{
> const int typedefOf = dummy ? -1 : QtPrivate::QMetaTypeIdHelper<T>::qt_metatype_id();
> if (typedefOf != -1)
> return QMetaType::registerNormalizedTypedef(normalizedTypeName, typedefOf);
>
> QMetaType::TypeFlags flags(QtPrivate::QMetaTypeTypeFlags<T>::Flags);
> return QMetaType::registerNormalizedType(normalizedTypeName, qMetaTypeDeleteHelper<T>,
> qMetaTypeCreateHelper<T>,
> qMetaTypeDestructHelper<T>,
> qMetaTypeConstructHelper<T>,
> sizeof(T),
> flags,
> QtPrivate::MetaObjectForType<T>::value());
>}
>
>template <typename T>
>int qRegisterMetaType(const char *typeName
>
> , T * dummy = 0
>
>)
>{
>
>
>
> ::QByteArray normalizedTypeName = QMetaObject::normalizedType(typeName);
>
> return qRegisterNormalizedMetaType<T>(normalizedTypeName, dummy);
>}
>
>
>template <typename T>
>void qRegisterMetaTypeStreamOperators(const char *typeName
>
> , T * = 0
>
>)
>{
> qRegisterMetaType<T>(typeName);
> QMetaType::registerStreamOperators(typeName, qMetaTypeSaveHelper<T>, qMetaTypeLoadHelper<T>);
>}
>
>
>template <typename T>
>inline int qMetaTypeId(
>
> T * = 0
>
>)
>{
> static_assert(bool(QMetaTypeId2<T>::Defined), "Type is not registered, please use Q_DECLARE_METATYPE macro to make it know to Qt's meta-object system");
> return QMetaTypeId2<T>::qt_metatype_id();
>}
>
>template <typename T>
>inline int qRegisterMetaType(
>
> T * dummy = 0
>
>)
>{
>
>
>
> return qMetaTypeId(dummy);
>
>}
>
>template <typename T>
>struct QMetaTypeIdQObject<T*, true>
>{
> enum {
> Defined = 1
> };
>
> static int qt_metatype_id()
> {
> static QBasicAtomicInt metatype_id = { (0) };
> if (!metatype_id.load()) {
> const int len = int(strlen(T::staticMetaObject.className()));
> QVarLengthArray<char, 16> classNameStar;
> classNameStar.append(T::staticMetaObject.className(), len);
> classNameStar.append("*\0", 2);
> metatype_id.storeRelease(qRegisterMetaType<T*>(classNameStar.constData(),
> reinterpret_cast<T**>(quintptr(-1))));
> }
> return metatype_id.loadAcquire();
> }
>};
>
>
>template <typename T>
>inline int qRegisterMetaTypeStreamOperators()
>{
> register int id = qMetaTypeId<T>();
> QMetaType::registerStreamOperators(id, qMetaTypeSaveHelper<T>, qMetaTypeLoadHelper<T>);
> return id;
>}
># 664 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h"
>class QChar; class QString; class QStringList; class QByteArray; 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 QUuid; class QVariant; class QModelIndex; class QRegularExpression; class QJsonValue; class QJsonObject; class QJsonArray; class QJsonDocument;
>class QFont; class QPixmap; class QBrush; class QColor; class QPalette; class QIcon; class QImage; class QPolygon; class QRegion; class QBitmap; class QCursor; class QKeySequence; class QPen; class QTextLength; class QTextFormat; class QMatrix; class QTransform; class QMatrix4x4; class QVector2D; class QVector3D; class QVector4D; class QQuaternion; class QPolygonF;
>class QSizePolicy;
>
>
>
>template <class T> class QList;
>template <class T> class QLinkedList;
>template <class T> class QVector;
>template <class T> class QQueue;
>template <class T> class QStack;
>template <class T> class QSet;
>template <class T> class QSharedPointer;
>template <class T1, class T2> class QMap;
>template <class T1, class T2> class QHash;
>template <class T1, class T2> struct QPair;
>typedef QList<QVariant> QVariantList;
>typedef QMap<QString, QVariant> QVariantMap;
>typedef QHash<QString, QVariant> QVariantHash;
># 718 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qmetatype.h"
>template <typename T> struct QMetaTypeId< QList<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QList<T> >( QByteArray(QByteArray("QList" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ">").constData(), reinterpret_cast< QList<T> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>template <typename T> struct QMetaTypeId< QVector<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QVector<T> >( QByteArray(QByteArray("QVector" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ">").constData(), reinterpret_cast< QVector<T> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>template <typename T> struct QMetaTypeId< QQueue<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QQueue<T> >( QByteArray(QByteArray("QQueue" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ">").constData(), reinterpret_cast< QQueue<T> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>template <typename T> struct QMetaTypeId< QStack<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QStack<T> >( QByteArray(QByteArray("QStack" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ">").constData(), reinterpret_cast< QStack<T> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>template <typename T> struct QMetaTypeId< QSet<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QSet<T> >( QByteArray(QByteArray("QSet" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ">").constData(), reinterpret_cast< QSet<T> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>template <typename T> struct QMetaTypeId< QSharedPointer<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QSharedPointer<T> >( QByteArray(QByteArray("QSharedPointer" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ">").constData(), reinterpret_cast< QSharedPointer<T> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>template <typename T> struct QMetaTypeId< QLinkedList<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QLinkedList<T> >( QByteArray(QByteArray("QLinkedList" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ">").constData(), reinterpret_cast< QLinkedList<T> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>
>template<typename T, typename U> struct QMetaTypeId< QHash<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QHash<T, U> >( QByteArray(QByteArray("QHash" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ", " + QMetaType::typeName(qMetaTypeId()) + ">").constData(), reinterpret_cast< QHash<T, U> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>template<typename T, typename U> struct QMetaTypeId< QMap<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QMap<T, U> >( QByteArray(QByteArray("QMap" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ", " + QMetaType::typeName(qMetaTypeId()) + ">").constData(), reinterpret_cast< QMap<T, U> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>template<typename T, typename U> struct QMetaTypeId< QPair<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id.load()) metatype_id.storeRelease(qRegisterMetaType< QPair<T, U> >( QByteArray(QByteArray("QPair" "<") + QMetaType::typeName(qMetaTypeId<T>()) + ", " + QMetaType::typeName(qMetaTypeId()) + ">").constData(), reinterpret_cast< QPair<T, U> *>(quintptr(-1)))); return metatype_id.loadAcquire(); } };
>
>inline QMetaType::QMetaType(const ExtensionFlag extensionFlags, const QMetaTypeInterface *info,
> Creator creator,
> Deleter deleter,
> SaveOperator saveOp,
> LoadOperator loadOp,
> Constructor constructor,
> Destructor destructor,
> uint size,
> uint theTypeFlags,
> int typeId,
> const QMetaObject *metaObject)
> : m_creator(creator)
> , m_deleter(deleter)
> , m_saveOp(saveOp)
> , m_loadOp(loadOp)
> , m_constructor(constructor)
> , m_destructor(destructor)
> , m_extension(0)
> , m_size(size)
> , m_typeFlags(theTypeFlags)
> , m_extensionFlags(extensionFlags)
> , m_typeId(typeId)
> , m_metaObject(metaObject)
>{
> if (__builtin_expect(!!(isExtended(CtorEx) || typeId == QMetaType::Void), false))
> ctor(info);
>}
>
>inline QMetaType::~QMetaType()
>{
> if (__builtin_expect(!!(isExtended(DtorEx)), false))
> dtor();
>}
>
>inline bool QMetaType::isValid() const
>{
> return m_typeId != UnknownType;
>}
>
>inline bool QMetaType::isRegistered() const
>{
> return isValid();
>}
>
>inline void *QMetaType::create(const void *copy) const
>{
> if (__builtin_expect(!!(isExtended(CreateEx)), false))
> return createExtended(copy);
> return m_creator(copy);
>}
>
>inline void QMetaType::destroy(void *data) const
>{
> if (__builtin_expect(!!(isExtended(DestroyEx)), false))
> return destroyExtended(data);
> m_deleter(data);
>}
>
>inline void *QMetaType::construct(void *where, const void *copy) const
>{
> if (__builtin_expect(!!(isExtended(ConstructEx)), false))
> return constructExtended(where, copy);
> return m_constructor(where, copy);
>}
>
>inline void QMetaType::destruct(void *data) const
>{
> if (__builtin_expect(!!(isExtended(DestructEx)), false))
> return destructExtended(data);
> if (__builtin_expect(!!(!data), false))
> return;
> m_destructor(data);
>}
>
>inline int QMetaType::sizeOf() const
>{
> if (__builtin_expect(!!(isExtended(SizeEx)), false))
> return sizeExtended();
> return m_size;
>}
>
>inline QMetaType::TypeFlags QMetaType::flags() const
>{
> if (__builtin_expect(!!(isExtended(FlagsEx)), false))
> return flagsExtended();
> return QMetaType::TypeFlags(m_typeFlags);
>}
>
>
>
>
>
>
>
> template<> struct QMetaTypeId2<void> { enum { Defined = 1, MetaType = QMetaType::Void }; static inline int qt_metatype_id() { return QMetaType::Void; } }; template<> struct QMetaTypeId2<bool> { enum { Defined = 1, MetaType = QMetaType::Bool }; static inline int qt_metatype_id() { return QMetaType::Bool; } }; template<> struct QMetaTypeId2<int> { enum { Defined = 1, MetaType = QMetaType::Int }; static inline int qt_metatype_id() { return QMetaType::Int; } }; template<> struct QMetaTypeId2<uint> { enum { Defined = 1, MetaType = QMetaType::UInt }; static inline int qt_metatype_id() { return QMetaType::UInt; } }; template<> struct QMetaTypeId2<qlonglong> { enum { Defined = 1, MetaType = QMetaType::LongLong }; static inline int qt_metatype_id() { return QMetaType::LongLong; } }; template<> struct QMetaTypeId2<qulonglong> { enum { Defined = 1, MetaType = QMetaType::ULongLong }; static inline int qt_metatype_id() { return QMetaType::ULongLong; } }; template<> struct QMetaTypeId2<double> { enum { Defined = 1, MetaType = QMetaType::Double }; static inline int qt_metatype_id() { return QMetaType::Double; } }; template<> struct QMetaTypeId2<long> { enum { Defined = 1, MetaType = QMetaType::Long }; static inline int qt_metatype_id() { return QMetaType::Long; } }; template<> struct QMetaTypeId2<short> { enum { Defined = 1, MetaType = QMetaType::Short }; static inline int qt_metatype_id() { return QMetaType::Short; } }; template<> struct QMetaTypeId2<char> { enum { Defined = 1, MetaType = QMetaType::Char }; static inline int qt_metatype_id() { return QMetaType::Char; } }; template<> struct QMetaTypeId2<ulong> { enum { Defined = 1, MetaType = QMetaType::ULong }; static inline int qt_metatype_id() { return QMetaType::ULong; } }; template<> struct QMetaTypeId2<ushort> { enum { Defined = 1, MetaType = QMetaType::UShort }; static inline int qt_metatype_id() { return QMetaType::UShort; } }; template<> struct QMetaTypeId2<uchar> { enum { Defined = 1, MetaType = QMetaType::UChar }; static inline int qt_metatype_id() { return QMetaType::UChar; } }; template<> struct QMetaTypeId2<float> { enum { Defined = 1, MetaType = QMetaType::Float }; static inline int qt_metatype_id() { return QMetaType::Float; } }; template<> struct QMetaTypeId2<signed char> { enum { Defined = 1, MetaType = QMetaType::SChar }; static inline int qt_metatype_id() { return QMetaType::SChar; } }; template<> struct QMetaTypeId2<void*> { enum { Defined = 1, MetaType = QMetaType::VoidStar }; static inline int qt_metatype_id() { return QMetaType::VoidStar; } }; template<> struct QMetaTypeId2<QChar> { enum { Defined = 1, MetaType = QMetaType::QChar }; static inline int qt_metatype_id() { return QMetaType::QChar; } }; template<> struct QMetaTypeId2<QString> { enum { Defined = 1, MetaType = QMetaType::QString }; static inline int qt_metatype_id() { return QMetaType::QString; } }; template<> struct QMetaTypeId2<QStringList> { enum { Defined = 1, MetaType = QMetaType::QStringList }; static inline int qt_metatype_id() { return QMetaType::QStringList; } }; template<> struct QMetaTypeId2<QByteArray> { enum { Defined = 1, MetaType = QMetaType::QByteArray }; static inline int qt_metatype_id() { return QMetaType::QByteArray; } }; template<> struct QMetaTypeId2<QBitArray> { enum { Defined = 1, MetaType = QMetaType::QBitArray }; static inline int qt_metatype_id() { return QMetaType::QBitArray; } }; template<> struct QMetaTypeId2<QDate> { enum { Defined = 1, MetaType = QMetaType::QDate }; static inline int qt_metatype_id() { return QMetaType::QDate; } }; template<> struct QMetaTypeId2<QTime> { enum { Defined = 1, MetaType = QMetaType::QTime }; static inline int qt_metatype_id() { return QMetaType::QTime; } }; template<> struct QMetaTypeId2<QDateTime> { enum { Defined = 1, MetaType = QMetaType::QDateTime }; static inline int qt_metatype_id() { return QMetaType::QDateTime; } }; template<> struct QMetaTypeId2<QUrl> { enum { Defined = 1, MetaType = QMetaType::QUrl }; static inline int qt_metatype_id() { return QMetaType::QUrl; } }; template<> struct QMetaTypeId2<QLocale> { enum { Defined = 1, MetaType = QMetaType::QLocale }; static inline int qt_metatype_id() { return QMetaType::QLocale; } }; template<> struct QMetaTypeId2<QRect> { enum { Defined = 1, MetaType = QMetaType::QRect }; static inline int qt_metatype_id() { return QMetaType::QRect; } }; template<> struct QMetaTypeId2<QRectF> { enum { Defined = 1, MetaType = QMetaType::QRectF }; static inline int qt_metatype_id() { return QMetaType::QRectF; } }; template<> struct QMetaTypeId2<QSize> { enum { Defined = 1, MetaType = QMetaType::QSize }; static inline int qt_metatype_id() { return QMetaType::QSize; } }; template<> struct QMetaTypeId2<QSizeF> { enum { Defined = 1, MetaType = QMetaType::QSizeF }; static inline int qt_metatype_id() { return QMetaType::QSizeF; } }; template<> struct QMetaTypeId2<QLine> { enum { Defined = 1, MetaType = QMetaType::QLine }; static inline int qt_metatype_id() { return QMetaType::QLine; } }; template<> struct QMetaTypeId2<QLineF> { enum { Defined = 1, MetaType = QMetaType::QLineF }; static inline int qt_metatype_id() { return QMetaType::QLineF; } }; template<> struct QMetaTypeId2<QPoint> { enum { Defined = 1, MetaType = QMetaType::QPoint }; static inline int qt_metatype_id() { return QMetaType::QPoint; } }; template<> struct QMetaTypeId2<QPointF> { enum { Defined = 1, MetaType = QMetaType::QPointF }; static inline int qt_metatype_id() { return QMetaType::QPointF; } }; template<> struct QMetaTypeId2<QRegExp> { enum { Defined = 1, MetaType = QMetaType::QRegExp }; static inline int qt_metatype_id() { return QMetaType::QRegExp; } }; template<> struct QMetaTypeId2<QEasingCurve> { enum { Defined = 1, MetaType = QMetaType::QEasingCurve }; static inline int qt_metatype_id() { return QMetaType::QEasingCurve; } }; template<> struct QMetaTypeId2<QUuid> { enum { Defined = 1, MetaType = QMetaType::QUuid }; static inline int qt_metatype_id() { return QMetaType::QUuid; } }; template<> struct QMetaTypeId2<QVariant> { enum { Defined = 1, MetaType = QMetaType::QVariant }; static inline int qt_metatype_id() { return QMetaType::QVariant; } }; template<> struct QMetaTypeId2<QModelIndex> { enum { Defined = 1, MetaType = QMetaType::QModelIndex }; static inline int qt_metatype_id() { return QMetaType::QModelIndex; } }; template<> struct QMetaTypeId2<QRegularExpression> { enum { Defined = 1, MetaType = QMetaType::QRegularExpression }; static inline int qt_metatype_id() { return QMetaType::QRegularExpression; } }; template<> struct QMetaTypeId2<QJsonValue> { enum { Defined = 1, MetaType = QMetaType::QJsonValue }; static inline int qt_metatype_id() { return QMetaType::QJsonValue; } }; template<> struct QMetaTypeId2<QJsonObject> { enum { Defined = 1, MetaType = QMetaType::QJsonObject }; static inline int qt_metatype_id() { return QMetaType::QJsonObject; } }; template<> struct QMetaTypeId2<QJsonArray> { enum { Defined = 1, MetaType = QMetaType::QJsonArray }; static inline int qt_metatype_id() { return QMetaType::QJsonArray; } }; template<> struct QMetaTypeId2<QJsonDocument> { enum { Defined = 1, MetaType = QMetaType::QJsonDocument }; static inline int qt_metatype_id() { return QMetaType::QJsonDocument; } }; template<> struct QMetaTypeId2<QObject*> { enum { Defined = 1, MetaType = QMetaType::QObjectStar }; static inline int qt_metatype_id() { return QMetaType::QObjectStar; } }; template<> struct QMetaTypeId2<QWidget*> { enum { Defined = 1, MetaType = QMetaType::QWidgetStar }; static inline int qt_metatype_id() { return QMetaType::QWidgetStar; } }; template<> struct QMetaTypeId2<QVariantMap> { enum { Defined = 1, MetaType = QMetaType::QVariantMap }; static inline int qt_metatype_id() { return QMetaType::QVariantMap; } }; template<> struct QMetaTypeId2<QVariantList> { enum { Defined = 1, MetaType = QMetaType::QVariantList }; static inline int qt_metatype_id() { return QMetaType::QVariantList; } }; template<> struct QMetaTypeId2<QVariantHash> { enum { Defined = 1, MetaType = QMetaType::QVariantHash }; static inline int qt_metatype_id() { return QMetaType::QVariantHash; } }; template<> struct QMetaTypeId2<QFont> { enum { Defined = 1, MetaType = QMetaType::QFont }; static inline int qt_metatype_id() { return QMetaType::QFont; } }; template<> struct QMetaTypeId2<QPixmap> { enum { Defined = 1, MetaType = QMetaType::QPixmap }; static inline int qt_metatype_id() { return QMetaType::QPixmap; } }; template<> struct QMetaTypeId2<QBrush> { enum { Defined = 1, MetaType = QMetaType::QBrush }; static inline int qt_metatype_id() { return QMetaType::QBrush; } }; template<> struct QMetaTypeId2<QColor> { enum { Defined = 1, MetaType = QMetaType::QColor }; static inline int qt_metatype_id() { return QMetaType::QColor; } }; template<> struct QMetaTypeId2<QPalette> { enum { Defined = 1, MetaType = QMetaType::QPalette }; static inline int qt_metatype_id() { return QMetaType::QPalette; } }; template<> struct QMetaTypeId2<QIcon> { enum { Defined = 1, MetaType = QMetaType::QIcon }; static inline int qt_metatype_id() { return QMetaType::QIcon; } }; template<> struct QMetaTypeId2<QImage> { enum { Defined = 1, MetaType = QMetaType::QImage }; static inline int qt_metatype_id() { return QMetaType::QImage; } }; template<> struct QMetaTypeId2<QPolygon> { enum { Defined = 1, MetaType = QMetaType::QPolygon }; static inline int qt_metatype_id() { return QMetaType::QPolygon; } }; template<> struct QMetaTypeId2<QRegion> { enum { Defined = 1, MetaType = QMetaType::QRegion }; static inline int qt_metatype_id() { return QMetaType::QRegion; } }; template<> struct QMetaTypeId2<QBitmap> { enum { Defined = 1, MetaType = QMetaType::QBitmap }; static inline int qt_metatype_id() { return QMetaType::QBitmap; } }; template<> struct QMetaTypeId2<QCursor> { enum { Defined = 1, MetaType = QMetaType::QCursor }; static inline int qt_metatype_id() { return QMetaType::QCursor; } }; template<> struct QMetaTypeId2<QKeySequence> { enum { Defined = 1, MetaType = QMetaType::QKeySequence }; static inline int qt_metatype_id() { return QMetaType::QKeySequence; } }; template<> struct QMetaTypeId2<QPen> { enum { Defined = 1, MetaType = QMetaType::QPen }; static inline int qt_metatype_id() { return QMetaType::QPen; } }; template<> struct QMetaTypeId2<QTextLength> { enum { Defined = 1, MetaType = QMetaType::QTextLength }; static inline int qt_metatype_id() { return QMetaType::QTextLength; } }; template<> struct QMetaTypeId2<QTextFormat> { enum { Defined = 1, MetaType = QMetaType::QTextFormat }; static inline int qt_metatype_id() { return QMetaType::QTextFormat; } }; template<> struct QMetaTypeId2<QMatrix> { enum { Defined = 1, MetaType = QMetaType::QMatrix }; static inline int qt_metatype_id() { return QMetaType::QMatrix; } }; template<> struct QMetaTypeId2<QTransform> { enum { Defined = 1, MetaType = QMetaType::QTransform }; static inline int qt_metatype_id() { return QMetaType::QTransform; } }; template<> struct QMetaTypeId2<QMatrix4x4> { enum { Defined = 1, MetaType = QMetaType::QMatrix4x4 }; static inline int qt_metatype_id() { return QMetaType::QMatrix4x4; } }; template<> struct QMetaTypeId2<QVector2D> { enum { Defined = 1, MetaType = QMetaType::QVector2D }; static inline int qt_metatype_id() { return QMetaType::QVector2D; } }; template<> struct QMetaTypeId2<QVector3D> { enum { Defined = 1, MetaType = QMetaType::QVector3D }; static inline int qt_metatype_id() { return QMetaType::QVector3D; } }; template<> struct QMetaTypeId2<QVector4D> { enum { Defined = 1, MetaType = QMetaType::QVector4D }; static inline int qt_metatype_id() { return QMetaType::QVector4D; } }; template<> struct QMetaTypeId2<QQuaternion> { enum { Defined = 1, MetaType = QMetaType::QQuaternion }; static inline int qt_metatype_id() { return QMetaType::QQuaternion; } }; template<> struct QMetaTypeId2<QPolygonF> { enum { Defined = 1, MetaType = QMetaType::QPolygonF }; static inline int qt_metatype_id() { return QMetaType::QPolygonF; } }; template<> struct QMetaTypeId2<QSizePolicy> { enum { Defined = 1, MetaType = QMetaType::QSizePolicy }; static inline int qt_metatype_id() { return QMetaType::QSizePolicy; } };
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qmetatype.h" 2
># 56 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h" 2
>
># 1 "../../../../qt5/qtbase/include/QtCore/qobject_impl.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject_impl.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject_impl.h"
>
>
>
>
>
>namespace QtPrivate {
># 92 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject_impl.h"
> template <typename ArgList> struct TypesAreDeclaredMetaType { enum { Value = false }; };
> template <> struct TypesAreDeclaredMetaType<List<>> { enum { Value = true }; };
> template <typename Arg, typename... Tail> struct TypesAreDeclaredMetaType<List<Arg, Tail...> >
> { enum { Value = QMetaTypeId2<Arg>::Defined && TypesAreDeclaredMetaType<List<Tail...>>::Value }; };
>
> template <typename ArgList, bool Declared = TypesAreDeclaredMetaType<ArgList>::Value > struct ConnectionTypes
> { static const int *types() { return 0; } };
> template <typename... Args> struct ConnectionTypes<List<Args...>, true>
> { static const int *types() { static const int t[sizeof...(Args) + 1] = { (QtPrivate::QMetaTypeIdHelper<Args>::qt_metatype_id())..., 0 }; return t; } };
>
>}
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qobject_impl.h" 2
># 58 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h" 2
>
>
>
>
>
>
>class QEvent;
>class QTimerEvent;
>class QChildEvent;
>struct QMetaObject;
>class QVariant;
>class QObjectPrivate;
>class QObject;
>class QThread;
>class QWidget;
>
>class QRegExp;
>
>
>class QRegularExpression;
>
>
>class QObjectUserData;
>
>struct QDynamicMetaObjectData;
>
>typedef QList<QObject*> QObjectList;
>
>__attribute__((visibility("default"))) void qt_qFindChildren_helper(const QObject *parent, const QString &name,
> const QMetaObject &mo, QList<void *> *list, Qt::FindChildOptions options);
>__attribute__((visibility("default"))) void qt_qFindChildren_helper(const QObject *parent, const QRegExp &re,
> const QMetaObject &mo, QList<void *> *list, Qt::FindChildOptions options);
>__attribute__((visibility("default"))) void qt_qFindChildren_helper(const QObject *parent, const QRegularExpression &re,
> const QMetaObject &mo, QList<void *> *list, Qt::FindChildOptions options);
>__attribute__((visibility("default"))) QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo, Qt::FindChildOptions options);
>
>class __attribute__((visibility("default"))) QObjectData {
>public:
> virtual ~QObjectData() = 0;
> QObject *q_ptr;
> QObject *parent;
> QObjectList children;
>
> uint isWidget : 1;
> uint blockSig : 1;
> uint wasDeleted : 1;
> uint isDeletingChildren : 1;
> uint sendChildEvents : 1;
> uint receiveChildEvents : 1;
> uint isWindow : 1;
> uint unused : 25;
> int postedEvents;
> QDynamicMetaObjectData *metaObject;
> QMetaObject *dynamicMetaObject() const;
>};
>
>
>class __attribute__((visibility("default"))) QObject
>{
> public: template <typename T> 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, int n = -1) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c = 0, int n = -1) { return staticMetaObject.tr(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
> 
> inline QObjectPrivate* d_func() { return reinterpret_cast<QObjectPrivate *>(qGetPtrHelper(d_ptr)); } inline const QObjectPrivate* d_func() const { return reinterpret_cast<const QObjectPrivate *>(qGetPtrHelper(d_ptr)); } friend class QObjectPrivate;
>
>public:
> explicit QObject(QObject *parent=0);
> virtual ~QObject();
>
> virtual bool event(QEvent *);
> virtual bool eventFilter(QObject *, QEvent *);
># 143 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h"
> QString objectName() const;
> void setObjectName(const QString &name);
>
> inline bool isWidgetType() const { return d_ptr->isWidget; }
> inline bool isWindowType() const { return d_ptr->isWindow; }
>
> inline bool signalsBlocked() const { return d_ptr->blockSig; }
> bool blockSignals(bool b);
>
> QThread *thread() const;
> void moveToThread(QThread *thread);
>
> int startTimer(int interval, Qt::TimerType timerType = Qt::CoarseTimer);
> void killTimer(int id);
>
> template<typename T>
> inline T findChild(const QString &aName = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
> { return static_cast<T>(qt_qFindChild_helper(this, aName, reinterpret_cast<T>(0)->staticMetaObject, options)); }
>
> template<typename T>
> inline QList<T> findChildren(const QString &aName = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
> {
> QList<T> list;
> union {
> QList<T> *typedList;
> QList<void *> *voidList;
> } u;
> u.typedList = &list;
> qt_qFindChildren_helper(this, aName, reinterpret_cast<T>(0)->staticMetaObject, u.voidList, options);
> return list;
> }
>
>
> template<typename T>
> inline QList<T> findChildren(const QRegExp &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
> {
> QList<T> list;
> union {
> QList<T> *typedList;
> QList<void *> *voidList;
> } u;
> u.typedList = &list;
> qt_qFindChildren_helper(this, re, reinterpret_cast<T>(0)->staticMetaObject, u.voidList, options);
> return list;
> }
>
>
>
> template<typename T>
> inline QList<T> findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
> {
> QList<T> list;
> union {
> QList<T> *typedList;
> QList<void *> *voidList;
> } u;
> u.typedList = &list;
> qt_qFindChildren_helper(this, re, reinterpret_cast<T>(0)->staticMetaObject, u.voidList, options);
> return list;
> }
>
>
> inline const QObjectList &children() const { return d_ptr->children; }
>
> void setParent(QObject *);
> void installEventFilter(QObject *);
> void removeEventFilter(QObject *);
>
> static QMetaObject::Connection connect(const QObject *sender, const char *signal,
> const QObject *receiver, const char *member, Qt::ConnectionType = Qt::AutoConnection);
>
> static QMetaObject::Connection connect(const QObject *sender, const QMetaMethod &signal,
> const QObject *receiver, const QMetaMethod &method,
> Qt::ConnectionType type = Qt::AutoConnection);
>
> inline QMetaObject::Connection connect(const QObject *sender, const char *signal,
> const char *member, Qt::ConnectionType type = Qt::AutoConnection) const;
>
>
>
>
>
>
> template <typename Func1, typename Func2>
> static inline QMetaObject::Connection connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal,
> const typename QtPrivate::FunctionPointer<Func2>::Object *receiver, Func2 slot,
> Qt::ConnectionType type = Qt::AutoConnection)
> {
> typedef QtPrivate::FunctionPointer<Func1> SignalType;
> typedef QtPrivate::FunctionPointer<Func2> SlotType;
> reinterpret_cast<typename SignalType::Object *>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<typename SignalType::Object *>(0));
>
>
> static_assert(bool(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount)), "The slot requires more arguments than the signal provides.")
> ;
> static_assert(bool((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value)), "Signal and slot arguments are not compatible.")
> ;
> static_assert(bool((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value)), "Return type of the slot is not compatible with the return type of the signal.")
> ;
>
> const int *types = 0;
> if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
> types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types();
>
> return connectImpl(sender, reinterpret_cast<void **>(&signal),
> receiver, reinterpret_cast<void **>(&slot),
> new QSlotObject<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value,
> typename SignalType::ReturnType>(slot),
> type, types, &SignalType::Object::staticMetaObject);
> }
>
>
> template <typename Func1, typename Func2>
> static inline typename QtPrivate::QEnableIf<int(QtPrivate::FunctionPointer<Func2>::ArgumentCount) >= 0, QMetaObject::Connection>::Type
> connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, Func2 slot)
> {
> typedef QtPrivate::FunctionPointer<Func1> SignalType;
> typedef QtPrivate::FunctionPointer<Func2> SlotType;
>
>
> static_assert(bool(int(SignalType::ArgumentCount) >= int(SlotType::ArgumentCount)), "The slot requires more arguments than the signal provides.")
> ;
> static_assert(bool((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value)), "Signal and slot arguments are not compatible.")
> ;
> static_assert(bool((QtPrivate::AreArgumentsCompatible<typename SlotType::ReturnType, typename SignalType::ReturnType>::value)), "Return type of the slot is not compatible with the return type of the signal.")
> ;
>
> return connectImpl(sender, reinterpret_cast<void **>(&signal), sender, 0,
> new QStaticSlotObject<Func2,
> typename QtPrivate::List_Left<typename SignalType::Arguments, SlotType::ArgumentCount>::Value,
> typename SignalType::ReturnType>(slot),
> Qt::DirectConnection, 0, &SignalType::Object::staticMetaObject);
> }
>
>
> template <typename Func1, typename Func2>
> static inline typename QtPrivate::QEnableIf<QtPrivate::FunctionPointer<Func2>::ArgumentCount == -1, QMetaObject::Connection>::Type
> connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, Func2 slot)
> {
> typedef QtPrivate::FunctionPointer<Func1> SignalType;
>
> return connectImpl(sender, reinterpret_cast<void **>(&signal), sender, 0,
> new QFunctorSlotObject<Func2, SignalType::ArgumentCount, typename SignalType::Arguments, typename SignalType::ReturnType>(slot),
> Qt::DirectConnection, 0, &SignalType::Object::staticMetaObject);
> }
>
>
> 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) const
> { return disconnect(this, signal, receiver, member); }
> inline bool disconnect(const QObject *receiver, const char *member = 0) const
> { return disconnect(this, 0, receiver, member); }
> static bool disconnect(const QMetaObject::Connection &);
>
>
>
>
> template <typename Func1, typename Func2>
> static inline bool disconnect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal,
> const typename QtPrivate::FunctionPointer<Func2>::Object *receiver, Func2 slot)
> {
> typedef QtPrivate::FunctionPointer<Func1> SignalType;
> typedef QtPrivate::FunctionPointer<Func2> SlotType;
> reinterpret_cast<typename SignalType::Object *>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<typename SignalType::Object *>(0));
>
>
> static_assert(bool((QtPrivate::CheckCompatibleArguments<typename SignalType::Arguments, typename SlotType::Arguments>::value)), "Signal and slot arguments are not compatible.")
> ;
>
> return disconnectImpl(sender, reinterpret_cast<void **>(&signal), receiver, reinterpret_cast<void **>(&slot),
> &SignalType::Object::staticMetaObject);
> }
> template <typename Func1>
> static inline bool disconnect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal,
> const QObject *receiver, void **zero)
> {
>
>
>
> ((!(!zero)) ? qt_assert("!zero","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h",326) : qt_noop());
> typedef QtPrivate::FunctionPointer<Func1> SignalType;
> return disconnectImpl(sender, reinterpret_cast<void **>(&signal), receiver, zero,
> &SignalType::Object::staticMetaObject);
> }
>
>
>
> void dumpObjectTree();
> void dumpObjectInfo();
>
>
> bool setProperty(const char *name, const QVariant &value);
> QVariant property(const char *name) const;
> QList<QByteArray> dynamicPropertyNames() const;
>
>
>
> static uint registerUserData();
> void setUserData(uint id, QObjectUserData* data);
> QObjectUserData* userData(uint id) const;
>
>
>public:
> void destroyed(QObject * = 0);
> void objectNameChanged(const QString &objectName);
>
>public:
> inline QObject *parent() const { return d_ptr->parent; }
>
> inline bool inherits(const char *classname) const
> { return const_cast<QObject *>(this)->qt_metacast(classname) != 0; }
>
>public :
> void deleteLater();
>
>protected:
> QObject *sender() const;
> int senderSignalIndex() const;
> int receivers(const char* signal) const;
> bool isSignalConnected(const QMetaMethod &signal) const;
>
> virtual void timerEvent(QTimerEvent *);
> virtual void childEvent(QChildEvent *);
> virtual void customEvent(QEvent *);
>
> virtual void connectNotify(const QMetaMethod &signal);
> virtual void disconnectNotify(const QMetaMethod &signal);
>
>protected:
> QObject(QObjectPrivate &dd, QObject *parent = 0);
>
>protected:
> QScopedPointer<QObjectData> d_ptr;
>
> static const QMetaObject staticQtMetaObject;
>
> friend struct QMetaObject;
> friend struct QMetaObjectPrivate;
> friend class QMetaCallEvent;
> friend class QApplication;
> friend class QApplicationPrivate;
> friend class QCoreApplication;
> friend class QCoreApplicationPrivate;
> friend class QWidget;
> friend class QThreadData;
>
>private:
> QObject(const QObject &) = delete; QObject &operator=(const QObject &) = delete;
> 
>
> private:
>
> struct __attribute__((visibility("default"))) QSlotObjectBase {
> QAtomicInt ref;
> QSlotObjectBase() : ref(1) {}
> virtual ~QSlotObjectBase();
> virtual void call(QObject *receiver, void **a) = 0;
> virtual bool compare(void **);
> };
>
>
> template<typename Func, typename Args, typename R> struct QSlotObject : QSlotObjectBase
> {
> typedef QtPrivate::FunctionPointer<Func> FuncType;
> Func function;
> QSlotObject(Func f) : function(f) {}
> virtual void call(QObject *receiver, void **a) {
> FuncType::template call<Args, R>(function, static_cast<typename FuncType::Object *>(receiver), a);
> }
> virtual bool compare(void **f) {
> return *reinterpret_cast<Func *>(f) == function;
> }
> };
>
>
> template<typename Func, typename Args, typename R> struct QStaticSlotObject : QSlotObjectBase
> {
> typedef QtPrivate::FunctionPointer<Func> FuncType;
> Func function;
> QStaticSlotObject(Func f) : function(f) {}
> virtual void call(QObject *receiver, void **a) {
> FuncType::template call<Args, R>(function, receiver, a);
> }
> };
>
>
>
> template<typename Func, int N, typename Args, typename R> struct QFunctorSlotObject : QSlotObjectBase
> {
> typedef QtPrivate::Functor<Func, N> FuncType;
> Func function;
> QFunctorSlotObject(const Func &f) : function(f) {}
> virtual void call(QObject *receiver, void **a) {
> FuncType::template call<Args, R>(function, receiver, a);
> }
> };
>
> static QMetaObject::Connection connectImpl(const QObject *sender, void **signal,
> const QObject *receiver, void **slotPtr,
> QSlotObjectBase *slot, Qt::ConnectionType type,
> const int *types, const QMetaObject *senderMetaObject);
>
> static bool disconnectImpl(const QObject *sender, void **signal, const QObject *receiver, void **slot,
> const QMetaObject *senderMetaObject);
>
>};
>
>inline QMetaObject::Connection QObject::connect(const QObject *asender, const char *asignal,
> const char *amember, Qt::ConnectionType atype) const
>{ return connect(asender, asignal, this, amember, atype); }
>
>
>class __attribute__((visibility("default"))) QObjectUserData {
>public:
> virtual ~QObjectUserData();
>};
># 471 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h"
>template<typename T>
>inline T qFindChild(const QObject *o, const QString &name = QString())
>{ return o->findChild<T>(name); }
>
>template<typename T>
>inline QList<T> qFindChildren(const QObject *o, const QString &name = QString())
>{
> return o->findChildren<T>(name);
>}
>
>
>template<typename T>
>inline QList<T> qFindChildren(const QObject *o, const QRegExp &re)
>{
> return o->findChildren<T>(re);
>}
>
>
>
>
>template <class T>
>inline T qobject_cast(QObject *object)
>{
>
> reinterpret_cast<T>(object)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(object));
>
> return static_cast<T>(reinterpret_cast<T>(object)->staticMetaObject.cast(object));
>}
>
>template <class T>
>inline T qobject_cast(const QObject *object)
>{
>
> reinterpret_cast<T>(object)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(const_cast<QObject *>(object)));
>
> return static_cast<T>(reinterpret_cast<T>(object)->staticMetaObject.cast(object));
>}
>
>
>template <class T> inline const char * qobject_interface_iid()
>{ return 0; }
># 524 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/kernel/qobject.h"
>__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QObject *);
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qobject.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/io/qiodevice.h" 2
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qstring.h" 1
># 52 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/io/qiodevice.h" 2
>
>
>
>
>
>
>
>
>
>
>class QByteArray;
>class QIODevicePrivate;
>
>class __attribute__((visibility("default"))) QIODevice
>
> : public QObject
>
>{
>
> public: template <typename T> 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, int n = -1) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c = 0, int n = -1) { return staticMetaObject.tr(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: __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<OpenModeFlag> 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;
>
>
>public:
> 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<QIODevicePrivate *>(qGetPtrHelper(d_ptr)); } inline const QIODevicePrivate* d_func() const { return reinterpret_cast<const QIODevicePrivate *>(qGetPtrHelper(d_ptr)); } friend class QIODevicePrivate;
> QIODevice(const QIODevice &) = delete; QIODevice &operator=(const QIODevice &) = delete;
>};
>
>constexpr inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QIODevice::OpenMode::enum_type f2) { return QFlags<QIODevice::OpenMode::enum_type>(f1) | f2; } constexpr inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QFlags<QIODevice::OpenMode::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QIODevice::OpenMode::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
>
>
>class QDebug;
>__attribute__((visibility("default"))) QDebug operator<<(QDebug debug, QIODevice::OpenMode modes);
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qiodevice.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/io/qdatastream.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/io/qdatastream.h" 2
>
>
>
>
>
>
>
>
>
>
>class QByteArray;
>class QIODevice;
>
>template <typename T> class QList;
>template <typename T> class QLinkedList;
>template <typename T> class QVector;
>template <typename T> class QSet;
>template <class Key, class T> class QHash;
>template <class Key, class T> class QMap;
>
>
>class QDataStreamPrivate;
>class __attribute__((visibility("default"))) 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,
> Qt_4_9 = Qt_4_8,
> Qt_5_0 = 13
>
>
>
> };
>
> 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 &);
> ~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);
>
>private:
> QDataStream(const QDataStream &) = delete; QDataStream &operator=(const QDataStream &) = delete;
>
> QScopedPointer<QDataStreamPrivate> 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<qint8&>(i); }
>
>inline QDataStream &QDataStream::operator>>(quint16 &i)
>{ return *this >> reinterpret_cast<qint16&>(i); }
>
>inline QDataStream &QDataStream::operator>>(quint32 &i)
>{ return *this >> reinterpret_cast<qint32&>(i); }
>
>inline QDataStream &QDataStream::operator>>(quint64 &i)
>{ return *this >> reinterpret_cast<qint64&>(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 <typename T>
>QDataStream& operator>>(QDataStream& s, QList<T>& 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 <typename T>
>QDataStream& operator<<(QDataStream& s, const QList<T>& l)
>{
> s << quint32(l.size());
> for (int i = 0; i < l.size(); ++i)
> s << l.at(i);
> return s;
>}
>
>template <typename T>
>QDataStream& operator>>(QDataStream& s, QLinkedList<T>& 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 <typename T>
>QDataStream& operator<<(QDataStream& s, const QLinkedList<T>& l)
>{
> s << quint32(l.size());
> typename QLinkedList<T>::ConstIterator it = l.constBegin();
> for(; it != l.constEnd(); ++it)
> s << *it;
> return s;
>}
>
>template<typename T>
>QDataStream& operator>>(QDataStream& s, QVector<T>& 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<typename T>
>QDataStream& operator<<(QDataStream& s, const QVector<T>& v)
>{
> s << quint32(v.size());
> for (typename QVector<T>::const_iterator it = v.begin(); it != v.end(); ++it)
> s << *it;
> return s;
>}
>
>template <typename T>
>QDataStream &operator>>(QDataStream &in, QSet<T> &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 <typename T>
>QDataStream& operator<<(QDataStream &out, const QSet<T> &set)
>{
> out << quint32(set.size());
> typename QSet<T>::const_iterator i = set.constBegin();
> while (i != set.constEnd()) {
> out << *i;
> ++i;
> }
> return out;
>}
>
>template <class Key, class T>
> QDataStream &operator>>(QDataStream &in, QHash<Key, T> &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 <class Key, class T>
> QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
>{
> out << quint32(hash.size());
> typename QHash<Key, T>::ConstIterator it = hash.end();
> typename QHash<Key, T>::ConstIterator begin = hash.begin();
> while (it != begin) {
> --it;
> out << it.key() << it.value();
> }
> return out;
>}
>
>
>
>
>template <class aKey, class aT>
> QDataStream &operator>>(QDataStream &in, QMap<aKey, aT> &map)
>
>{
> QDataStream::Status oldStatus = in.status();
> in.resetStatus();
> map.clear();
>
> quint32 n;
> in >> n;
>
> map.detach();
> for (quint32 i = 0; i < n; ++i) {
> if (in.status() != QDataStream::Ok)
> break;
>
> aKey key;
> aT value;
> in >> key >> value;
> map.insertMulti(key, value);
> }
> if (in.status() != QDataStream::Ok)
> map.clear();
> if (oldStatus != QDataStream::Ok)
> in.setStatus(oldStatus);
> return in;
>}
>
>template <class Key, class T>
> QDataStream &operator<<(QDataStream &out, const QMap<Key, T> &map)
>{
> out << quint32(map.size());
> typename QMap<Key, T>::ConstIterator it = map.end();
> typename QMap<Key, T>::ConstIterator begin = map.begin();
> while (it != begin) {
> --it;
> out << it.key() << it.value();
> }
> return out;
>}
>
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qdatastream.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringlist.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qlist.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringlist.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qregexp.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qregexp.h" 1
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qregexp.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qstring.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qregexp.h" 2
>
>
>
>
>
>
>struct QRegExpPrivate;
>class QStringList;
>
>class __attribute__((visibility("default"))) QRegExp
>{
>public:
> enum PatternSyntax {
> RegExp,
> Wildcard,
> FixedString,
> RegExp2,
> WildcardUnix,
> W3CXmlSchema11 };
> enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch };
>
> QRegExp();
> explicit QRegExp(const QString &pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive,
> PatternSyntax syntax = RegExp);
> QRegExp(const QRegExp &rx);
> ~QRegExp();
> QRegExp &operator=(const QRegExp &rx);
>
> inline QRegExp &operator=(QRegExp &&other)
> { qSwap(priv,other.priv); return *this; }
>
> inline void swap(QRegExp &other) { qSwap(priv, other.priv); }
>
> bool operator==(const QRegExp &rx) const;
> inline bool operator!=(const QRegExp &rx) const { return !operator==(rx); }
>
> bool isEmpty() const;
> bool isValid() const;
> QString pattern() const;
> void setPattern(const QString &pattern);
> Qt::CaseSensitivity caseSensitivity() const;
> void setCaseSensitivity(Qt::CaseSensitivity cs);
> PatternSyntax patternSyntax() const;
> void setPatternSyntax(PatternSyntax syntax);
>
> bool isMinimal() const;
> void setMinimal(bool minimal);
>
> bool exactMatch(const QString &str) const;
>
> int indexIn(const QString &str, int offset = 0, CaretMode caretMode = CaretAtZero) const;
> int lastIndexIn(const QString &str, int offset = -1, CaretMode caretMode = CaretAtZero) const;
> int matchedLength() const;
>
> int captureCount() const;
> QStringList capturedTexts() const;
> QStringList capturedTexts();
> QString cap(int nth = 0) const;
> QString cap(int nth = 0);
> int pos(int nth = 0) const;
> int pos(int nth = 0);
> QString errorString() const;
> QString errorString();
>
>
> static QString escape(const QString &str);
>
>private:
> QRegExpPrivate *priv;
>};
>
>template<> class QTypeInfo<QRegExp > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRegExp)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QRegExp) }; static inline const char *name() { return "QRegExp"; } };
>
>
>__attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &out, const QRegExp &regExp);
>__attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &in, QRegExp &regExp);
>
>
>
>__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QRegExp &);
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qregexp.h" 2
># 49 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringlist.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qstring.h" 1
># 50 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringlist.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qstringmatcher.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringmatcher.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringmatcher.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qstring.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringmatcher.h" 2
>
>
>
>
>
>
>class QStringMatcherPrivate;
>
>class __attribute__((visibility("default"))) QStringMatcher
>{
>public:
> QStringMatcher();
> explicit QStringMatcher(const QString &pattern,
> Qt::CaseSensitivity cs = Qt::CaseSensitive);
> QStringMatcher(const QChar *uc, int len,
> Qt::CaseSensitivity cs = Qt::CaseSensitive);
> QStringMatcher(const QStringMatcher &other);
> ~QStringMatcher();
>
> QStringMatcher &operator=(const QStringMatcher &other);
>
> void setPattern(const QString &pattern);
> void setCaseSensitivity(Qt::CaseSensitivity cs);
>
> int indexIn(const QString &str, int from = 0) const;
> int indexIn(const QChar *str, int length, int from = 0) const;
> QString pattern() const;
> inline Qt::CaseSensitivity caseSensitivity() const { return q_cs; }
>
>private:
> QStringMatcherPrivate *d_ptr;
> QString q_pattern;
> Qt::CaseSensitivity q_cs;
>
>
>
>
>
> struct Data {
> uchar q_skiptable[256];
> const QChar *uc;
> int len;
> };
> union {
> uint q_data[256];
> Data p;
> };
>
>
>
>};
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qstringmatcher.h" 2
># 51 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qstringlist.h" 2
>
>
>
>
>
>
>class QRegExp;
>class QRegularExpression;
>
>typedef QListIterator<QString> QStringListIterator;
>typedef QMutableListIterator<QString> QMutableStringListIterator;
>
>class QStringList : public QList<QString>
>{
>public:
> inline QStringList() { }
> inline explicit QStringList(const QString &i) { append(i); }
> inline QStringList(const QStringList &l) : QList<QString>(l) { }
> inline QStringList(const QList<QString> &l) : QList<QString>(l) { }
>
> inline QStringList(std::initializer_list<QString> args) : QList<QString>(args) { }
>
>
> inline void sort(Qt::CaseSensitivity cs = Qt::CaseSensitive);
> inline int removeDuplicates();
>
> inline QString join(const QString &sep) const;
>
> inline QStringList filter(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
> inline bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
>
> inline QStringList &replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
>
> inline QStringList operator+(const QStringList &other) const
> { QStringList n = *this; n += other; return n; }
> inline QStringList &operator<<(const QString &str)
> { append(str); return *this; }
> inline QStringList &operator<<(const QStringList &l)
> { *this += l; return *this; }
>
>
> inline QStringList filter(const QRegExp &rx) const;
> inline QStringList &replaceInStrings(const QRegExp &rx, const QString &after);
> inline int indexOf(const QRegExp &rx, int from = 0) const;
> inline int lastIndexOf(const QRegExp &rx, int from = -1) const;
> inline int indexOf(QRegExp &rx, int from = 0) const;
> inline int lastIndexOf(QRegExp &rx, int from = -1) const;
>
>
>
>
> inline QStringList filter(const QRegularExpression &re) const;
> inline QStringList &replaceInStrings(const QRegularExpression &re, const QString &after);
> inline int indexOf(const QRegularExpression &re, int from = 0) const;
> inline int lastIndexOf(const QRegularExpression &re, int from = -1) const;
>
>
>
>
> using QList<QString>::indexOf;
> using QList<QString>::lastIndexOf;
>
>
>
>
>
>
>};
>
>template<> class QTypeInfo<QStringList > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QStringList)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QStringList) }; static inline const char *name() { return "QStringList"; } };
>
>namespace QtPrivate {
> void __attribute__((visibility("default"))) QStringList_sort(QStringList *that, Qt::CaseSensitivity cs);
> int __attribute__((visibility("default"))) QStringList_removeDuplicates(QStringList *that);
> QString __attribute__((visibility("default"))) QStringList_join(const QStringList *that, const QString &sep);
> QStringList __attribute__((visibility("default"))) QStringList_filter(const QStringList *that, const QString &str,
> Qt::CaseSensitivity cs);
>
> bool __attribute__((visibility("default"))) QStringList_contains(const QStringList *that, const QString &str, Qt::CaseSensitivity cs);
> void __attribute__((visibility("default"))) QStringList_replaceInStrings(QStringList *that, const QString &before, const QString &after,
> Qt::CaseSensitivity cs);
>
>
> void __attribute__((visibility("default"))) QStringList_replaceInStrings(QStringList *that, const QRegExp &rx, const QString &after);
> QStringList __attribute__((visibility("default"))) QStringList_filter(const QStringList *that, const QRegExp &re);
> int __attribute__((visibility("default"))) QStringList_indexOf(const QStringList *that, const QRegExp &rx, int from);
> int __attribute__((visibility("default"))) QStringList_lastIndexOf(const QStringList *that, const QRegExp &rx, int from);
> int __attribute__((visibility("default"))) QStringList_indexOf(const QStringList *that, QRegExp &rx, int from);
> int __attribute__((visibility("default"))) QStringList_lastIndexOf(const QStringList *that, QRegExp &rx, int from);
>
>
>
>
> void __attribute__((visibility("default"))) QStringList_replaceInStrings(QStringList *that, const QRegularExpression &rx, const QString &after);
> QStringList __attribute__((visibility("default"))) QStringList_filter(const QStringList *that, const QRegularExpression &re);
> int __attribute__((visibility("default"))) QStringList_indexOf(const QStringList *that, const QRegularExpression &re, int from);
> int __attribute__((visibility("default"))) QStringList_lastIndexOf(const QStringList *that, const QRegularExpression &re, int from);
>
>
>}
>
>inline void QStringList::sort(Qt::CaseSensitivity cs)
>{
> QtPrivate::QStringList_sort(this, cs);
>}
>
>inline int QStringList::removeDuplicates()
>{
> return QtPrivate::QStringList_removeDuplicates(this);
>}
>
>inline QString QStringList::join(const QString &sep) const
>{
> return QtPrivate::QStringList_join(this, sep);
>}
>
>inline QStringList QStringList::filter(const QString &str, Qt::CaseSensitivity cs) const
>{
> return QtPrivate::QStringList_filter(this, str, cs);
>}
>
>inline bool QStringList::contains(const QString &str, Qt::CaseSensitivity cs) const
>{
> return QtPrivate::QStringList_contains(this, str, cs);
>}
>
>inline QStringList &QStringList::replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs)
>{
> QtPrivate::QStringList_replaceInStrings(this, before, after, cs);
> return *this;
>}
>
>
>inline QStringList &QStringList::replaceInStrings(const QRegExp &rx, const QString &after)
>{
> QtPrivate::QStringList_replaceInStrings(this, rx, after);
> return *this;
>}
>
>inline QStringList QStringList::filter(const QRegExp &rx) const
>{
> return QtPrivate::QStringList_filter(this, rx);
>}
>
>inline int QStringList::indexOf(const QRegExp &rx, int from) const
>{
> return QtPrivate::QStringList_indexOf(this, rx, from);
>}
>
>inline int QStringList::lastIndexOf(const QRegExp &rx, int from) const
>{
> return QtPrivate::QStringList_lastIndexOf(this, rx, from);
>}
>
>inline int QStringList::indexOf(QRegExp &rx, int from) const
>{
> return QtPrivate::QStringList_indexOf(this, rx, from);
>}
>
>inline int QStringList::lastIndexOf(QRegExp &rx, int from) const
>{
> return QtPrivate::QStringList_lastIndexOf(this, rx, from);
>}
>
>
>
>
>inline QStringList &QStringList::replaceInStrings(const QRegularExpression &rx, const QString &after)
>{
> QtPrivate::QStringList_replaceInStrings(this, rx, after);
> return *this;
>}
>
>inline QStringList QStringList::filter(const QRegularExpression &rx) const
>{
> return QtPrivate::QStringList_filter(this, rx);
>}
>
>inline int QStringList::indexOf(const QRegularExpression &rx, int from) const
>{
> return QtPrivate::QStringList_indexOf(this, rx, from);
>}
>
>inline int QStringList::lastIndexOf(const QRegularExpression &rx, int from) const
>{
> return QtPrivate::QStringList_lastIndexOf(this, rx, from);
>}
>
>
>
>
>inline QDataStream &operator>>(QDataStream &in, QStringList &list)
>{
> return operator>>(in, static_cast<QList<QString> &>(list));
>}
>inline QDataStream &operator<<(QDataStream &out, const QStringList &list)
>{
> return operator<<(out, static_cast<const QList<QString> &>(list));
>}
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qstringlist.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/QStringList" 2
># 41 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/QList" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qlist.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/QList" 2
># 42 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/QHash" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qhash.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qchar.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qiterator.h" 1
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qlist.h" 1
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qpair.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qpair.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qpair.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qdatastream.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qpair.h" 2
>
>
>
>
>
>
>template <class T1, class T2>
>struct QPair
>{
> typedef T1 first_type;
> typedef T2 second_type;
>
> QPair() : first(), second() {}
> QPair(const T1 &t1, const T2 &t2) : first(t1), second(t2) {}
>
>
> T1 first;
> T2 second;
>};
>
>
>
>template<class T1, class T2>
>class QTypeInfo< QPair<T1, T2> >
>{
>public:
> enum {
> isComplex = QTypeInfo<T1>::isComplex || QTypeInfo<T2>::isComplex,
> isStatic = QTypeInfo<T1>::isStatic || QTypeInfo<T2>::isStatic,
> isLarge = sizeof(QPair<T1, T2>) > sizeof(void*),
> isPointer = false,
> isDummy = false,
> sizeOf = sizeof(QPair<T1, T2>)
> };
>};
>
>template <class T1, class T2>
>inline bool operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
>{ return p1.first == p2.first && p1.second == p2.second; }
>
>template <class T1, class T2>
>inline bool operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
>{ return !(p1 == p2); }
>
>template <class T1, class T2>
>inline bool operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
>{
> return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second);
>}
>
>template <class T1, class T2>
>inline bool operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
>{
> return p2 < p1;
>}
>
>template <class T1, class T2>
>inline bool operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
>{
> return !(p2 < p1);
>}
>
>template <class T1, class T2>
>inline bool operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
>{
> return !(p1 < p2);
>}
>
>template <class T1, class T2>
> QPair<T1, T2> qMakePair(const T1 &x, const T2 &y)
>{
> return QPair<T1, T2>(x, y);
>}
>
>
>template <class T1, class T2>
>inline QDataStream& operator>>(QDataStream& s, QPair<T1, T2>& p)
>{
> s >> p.first >> p.second;
> return s;
>}
>
>template <class T1, class T2>
>inline QDataStream& operator<<(QDataStream& s, const QPair<T1, T2>& p)
>{
> s << p.first << p.second;
> return s;
>}
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qpair.h" 2
># 49 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qrefcount.h" 1
># 50 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h" 2
>
>
>
>
>
>
>class QBitArray;
>class QByteArray;
>class QString;
>class QStringRef;
>
>inline uint qHash(char key, uint seed = 0) { return uint(key) ^ seed; }
>inline uint qHash(uchar key, uint seed = 0) { return uint(key) ^ seed; }
>inline uint qHash(signed char key, uint seed = 0) { return uint(key) ^ seed; }
>inline uint qHash(ushort key, uint seed = 0) { return uint(key) ^ seed; }
>inline uint qHash(short key, uint seed = 0) { return uint(key) ^ seed; }
>inline uint qHash(uint key, uint seed = 0) { return key ^ seed; }
>inline uint qHash(int key, uint seed = 0) { return uint(key) ^ seed; }
>inline uint qHash(ulong key, uint seed = 0)
>{
> if (sizeof(ulong) > sizeof(uint)) {
> return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)) ^ seed;
> } else {
> return uint(key & (~0U)) ^ seed;
> }
>}
>inline uint qHash(long key, uint seed = 0) { return qHash(ulong(key), seed); }
>inline uint qHash(quint64 key, uint seed = 0)
>{
> if (sizeof(quint64) > sizeof(uint)) {
> return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)) ^ seed;
> } else {
> return uint(key & (~0U)) ^ seed;
> }
>}
>inline uint qHash(qint64 key, uint seed = 0) { return qHash(quint64(key), seed); }
>inline uint qHash(QChar key, uint seed = 0) { return qHash(key.unicode(), seed); }
>__attribute__((visibility("default"))) uint qHash(const QByteArray &key, uint seed = 0);
>__attribute__((visibility("default"))) uint qHash(const QString &key, uint seed = 0);
>__attribute__((visibility("default"))) uint qHash(const QStringRef &key, uint seed = 0);
>__attribute__((visibility("default"))) uint qHash(const QBitArray &key, uint seed = 0);
>__attribute__((visibility("default"))) uint qHash(QLatin1String key, uint seed = 0);
>__attribute__((visibility("default"))) uint qt_hash(const QString &key);
>
>
>
>
>
>template <class T> inline uint qHash(const T *key, uint seed = 0)
>{
> return qHash(reinterpret_cast<quintptr>(key), seed);
>}
>
>
>
>
>template <typename T1, typename T2> inline uint qHash(const QPair<T1, T2> &key)
>{
> uint h1 = qHash(key.first);
> uint h2 = qHash(key.second);
> return ((h1 << 16) | (h1 >> 16)) ^ h2;
>}
>
>template<typename T> inline uint qHash(const T &t, uint seed) { return (qHash(t) ^ seed); }
>
>struct __attribute__((visibility("default"))) QHashData
>{
> struct Node {
> Node *next;
> uint h;
> };
>
> Node *fakeNext;
> Node **buckets;
> QtPrivate::RefCount ref;
> int size;
> int nodeSize;
> short userNumBits;
> short numBits;
> int numBuckets;
> uint seed;
> uint sharable : 1;
> uint strictAlignment : 1;
> uint reserved : 30;
>
> void *allocateNode(int nodeAlign);
> void freeNode(void *node);
> QHashData *detach_helper(void (*node_duplicate)(Node *, void *), void (*node_delete)(Node *),
> int nodeSize, int nodeAlign);
> bool willGrow();
> void hasShrunk();
> void rehash(int hint);
> void free_helper(void (*node_delete)(Node *));
> Node *firstNode();
>
>
>
>
> static Node *nextNode(Node *node);
> static Node *previousNode(Node *node);
>
> static const QHashData shared_null;
>};
>
>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<Node *>(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<QHashDummyValue > { 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), sizeOf = sizeof(QHashDummyValue) }; static inline const char *name() { return "QHashDummyValue"; } };
>
>template <class Key, class T>
>struct QHashNode
>{
> QHashNode *next;
> uint h;
> Key key;
> T value;
>
> inline QHashNode(const Key &key0, const T &value0, uint hash, QHashNode *n)
> : next(n), h(hash), key(key0), value(value0) {}
> inline bool same_key(uint h0, const Key &key0) { return h0 == h && key0 == key; }
>};
>
>template <class Key, class T>
>struct QHashDummyNode
>{
> QHashNode<Key, T> *next;
> uint h;
> Key key;
>
> inline QHashDummyNode(const Key &key0, uint hash, QHashNode<Key, T> *n) : next(n), h(hash), key(key0) {}
>};
># 265 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h"
>template <class Key, class T>
>class QHash
>{
> typedef QHashDummyNode<Key, T> DummyNode;
> typedef QHashNode<Key, T> Node;
>
> union {
> QHashData *d;
> QHashNode<Key, T> *e;
> };
>
> static inline Node *concrete(QHashData::Node *node) {
> return reinterpret_cast<Node *>(node);
> }
>
> static inline int alignOfNode() { return qMax<int>(sizeof(void*), __alignof__(Node)); }
> static inline int alignOfDummyNode() { return qMax<int>(sizeof(void*), __alignof__(DummyNode)); }
>
>public:
> inline QHash() : d(const_cast<QHashData *>(&QHashData::shared_null)) { }
> inline QHash(const QHash<Key, T> &other) : d(other.d) { d->ref.ref(); if (!d->sharable) detach(); }
> inline ~QHash() { if (!d->ref.deref()) freeData(d); }
>
> QHash<Key, T> &operator=(const QHash<Key, T> &other);
>
> inline QHash(QHash<Key, T> &&other) : d(other.d) { other.d = const_cast<QHashData *>(&QHashData::shared_null); }
> inline QHash<Key, T> &operator=(QHash<Key, T> &&other)
> { qSwap(d, other.d); return *this; }
>
> inline void swap(QHash<Key, T> &other) { qSwap(d, other.d); }
>
> bool operator==(const QHash<Key, T> &other) const;
> inline bool operator!=(const QHash<Key, T> &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.isShared()) detach_helper(); }
> inline bool isDetached() const { return !d->ref.isShared(); }
> inline void setSharable(bool sharable) { if (!sharable) detach(); if (d != &QHashData::shared_null) d->sharable = sharable; }
> inline bool isSharedWith(const QHash<Key, T> &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<Key> uniqueKeys() const;
> QList<Key> keys() const;
> QList<Key> keys(const T &value) const;
> QList<T> values() const;
> QList<T> values(const Key &key) const;
> int count(const Key &key) const;
>
> class const_iterator;
>
> class iterator
> {
> friend class const_iterator;
> friend class QHash<Key, T>;
> 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 iterator() : i(0) { }
> explicit inline iterator(void *node) : i(reinterpret_cast<QHashData::Node *>(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; }
>
> };
> 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 const_iterator() : i(0) { }
> explicit inline const_iterator(void *node)
> : i(reinterpret_cast<QHashData::Node *>(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; }
>
>
>
>
>
>
>
> };
> 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 cbegin() 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 cend() 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<Key, T> &unite(const QHash<Key, T> &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 <class Key, class T>
>inline void QHash<Key, T>::deleteNode(Node *node)
>{
> deleteNode2(reinterpret_cast<QHashData::Node*>(node));
> d->freeNode(node);
>}
>
>template <class Key, class T>
>inline void QHash<Key, T>::deleteNode2(QHashData::Node *node)
>{
>
>
>
> concrete(node)->~Node();
>
>}
>
>template <class Key, class T>
>inline void QHash<Key, T>::duplicateNode(QHashData::Node *node, void *newNode)
>{
> Node *concreteNode = concrete(node);
> if (QTypeInfo<T>::isDummy) {
> (void) new (newNode) DummyNode(concreteNode->key, concreteNode->h, 0);
> } else {
> (void) new (newNode) Node(concreteNode->key, concreteNode->value, concreteNode->h, 0);
> }
>}
>
>template <class Key, class T>
>inline typename QHash<Key, T>::Node *
>QHash<Key, T>::createNode(uint ah, const Key &akey, const T &avalue, Node **anextNode)
>{
> Node *node;
>
> if (QTypeInfo<T>::isDummy) {
> node = reinterpret_cast<Node *>(new (d->allocateNode(alignOfDummyNode())) DummyNode(akey, ah, *anextNode));
> } else {
> node = new (d->allocateNode(alignOfNode())) Node(akey, avalue, ah, *anextNode);
> }
>
> *anextNode = node;
> ++d->size;
> return node;
>}
>
>template <class Key, class T>
>inline QHash<Key, T> &QHash<Key, T>::unite(const QHash<Key, T> &other)
>{
> QHash<Key, T> copy(other);
> const_iterator it = copy.constEnd();
> while (it != copy.constBegin()) {
> --it;
> insertMulti(it.key(), it.value());
> }
> return *this;
>}
>
>template <class Key, class T>
> void QHash<Key, T>::freeData(QHashData *x)
>{
> x->free_helper(deleteNode2);
>}
>
>template <class Key, class T>
>inline void QHash<Key, T>::clear()
>{
> *this = QHash<Key,T>();
>}
>
>template <class Key, class T>
> void QHash<Key, T>::detach_helper()
>{
> QHashData *x = d->detach_helper(duplicateNode, deleteNode2,
> QTypeInfo<T>::isDummy ? sizeof(DummyNode) : sizeof(Node),
> QTypeInfo<T>::isDummy ? alignOfDummyNode() : alignOfNode());
> if (!d->ref.deref())
> freeData(d);
> d = x;
>}
>
>template <class Key, class T>
>inline QHash<Key, T> &QHash<Key, T>::operator=(const QHash<Key, T> &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 <class Key, class T>
>inline const T QHash<Key, T>::value(const Key &akey) const
>{
> Node *node;
> if (d->size == 0 || (node = *findNode(akey)) == e) {
> return T();
> } else {
> return node->value;
> }
>}
>
>template <class Key, class T>
>inline const T QHash<Key, T>::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 <class Key, class T>
> QList<Key> QHash<Key, T>::uniqueKeys() const
>{
> QList<Key> 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 <class Key, class T>
> QList<Key> QHash<Key, T>::keys() const
>{
> QList<Key> res;
> res.reserve(size());
> const_iterator i = begin();
> while (i != end()) {
> res.append(i.key());
> ++i;
> }
> return res;
>}
>
>template <class Key, class T>
> QList<Key> QHash<Key, T>::keys(const T &avalue) const
>{
> QList<Key> res;
> const_iterator i = begin();
> while (i != end()) {
> if (i.value() == avalue)
> res.append(i.key());
> ++i;
> }
> return res;
>}
>
>template <class Key, class T>
> const Key QHash<Key, T>::key(const T &avalue) const
>{
> return key(avalue, Key());
>}
>
>template <class Key, class T>
> const Key QHash<Key, T>::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 <class Key, class T>
> QList<T> QHash<Key, T>::values() const
>{
> QList<T> res;
> res.reserve(size());
> const_iterator i = begin();
> while (i != end()) {
> res.append(i.value());
> ++i;
> }
> return res;
>}
>
>template <class Key, class T>
> QList<T> QHash<Key, T>::values(const Key &akey) const
>{
> QList<T> res;
> Node *node = *findNode(akey);
> if (node != e) {
> do {
> res.append(node->value);
> } while ((node = node->next) != e && node->key == akey);
> }
> return res;
>}
>
>template <class Key, class T>
> int QHash<Key, T>::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 <class Key, class T>
>inline const T QHash<Key, T>::operator[](const Key &akey) const
>{
> return value(akey);
>}
>
>template <class Key, class T>
>inline T &QHash<Key, T>::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 <class Key, class T>
>inline typename QHash<Key, T>::iterator QHash<Key, T>::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<T>::isDummy)
> (*node)->value = avalue;
> return iterator(*node);
>}
>
>template <class Key, class T>
>inline typename QHash<Key, T>::iterator QHash<Key, T>::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 <class Key, class T>
> int QHash<Key, T>::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 <class Key, class T>
> T QHash<Key, T>::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 <class Key, class T>
> typename QHash<Key, T>::iterator QHash<Key, T>::erase(iterator it)
>{
> if (it == iterator(e))
> return it;
>
> iterator ret = it;
> ++ret;
>
> Node *node = concrete(it.i);
> Node **node_ptr = reinterpret_cast<Node **>(&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 <class Key, class T>
>inline void QHash<Key, T>::reserve(int asize)
>{
> detach();
> d->rehash(-qMax(asize, 1));
>}
>
>template <class Key, class T>
>inline typename QHash<Key, T>::const_iterator QHash<Key, T>::find(const Key &akey) const
>{
> return const_iterator(*findNode(akey));
>}
>
>template <class Key, class T>
>inline typename QHash<Key, T>::const_iterator QHash<Key, T>::constFind(const Key &akey) const
>{
> return const_iterator(*findNode(akey));
>}
>
>template <class Key, class T>
>inline typename QHash<Key, T>::iterator QHash<Key, T>::find(const Key &akey)
>{
> detach();
> return iterator(*findNode(akey));
>}
>
>template <class Key, class T>
>inline bool QHash<Key, T>::contains(const Key &akey) const
>{
> return *findNode(akey) != e;
>}
>
>template <class Key, class T>
> typename QHash<Key, T>::Node **QHash<Key, T>::findNode(const Key &akey,
> uint *ahp) const
>{
> Node **node;
> uint h = 0;
>
> if (d->numBuckets || ahp) {
> h = qHash(akey, d->seed);
> if (ahp)
> *ahp = h;
> }
> if (d->numBuckets) {
> node = reinterpret_cast<Node **>(&d->buckets[h % d->numBuckets]);
> ((!(*node == e || (*node)->next)) ? qt_assert("*node == e || (*node)->next","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h",881) : qt_noop());
> while (*node != e && !(*node)->same_key(h, akey))
> node = &(*node)->next;
> } else {
> node = const_cast<Node **>(reinterpret_cast<const Node * const *>(&e));
> }
> return node;
>}
>
>template <class Key, class T>
> bool QHash<Key, T>::operator==(const QHash<Key, T> &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<T>::isDummy && !(it.value() == it2.value()))
> return false;
> ++it;
> ++it2;
> } while (it != end() && it.key() == akey);
> }
> return true;
>}
>
>template <class Key, class T>
>class QMultiHash : public QHash<Key, T>
>{
>public:
> QMultiHash() {}
> QMultiHash(const QHash<Key, T> &other) : QHash<Key, T>(other) {}
> inline void swap(QMultiHash<Key, T> &other) { QHash<Key, T>::swap(other); }
>
> inline typename QHash<Key, T>::iterator replace(const Key &key, const T &value)
> { return QHash<Key, T>::insert(key, value); }
>
> inline typename QHash<Key, T>::iterator insert(const Key &key, const T &value)
> { return QHash<Key, T>::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<Key, T>::contains;
> using QHash<Key, T>::remove;
> using QHash<Key, T>::count;
> using QHash<Key, T>::find;
> using QHash<Key, T>::constFind;
># 959 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h"
> 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<Key, T>::iterator find(const Key &key, const T &value) {
> typename QHash<Key, T>::iterator i(find(key));
> typename QHash<Key, T>::iterator end(this->end());
> while (i != end && i.key() == key) {
> if (i.value() == value)
> return i;
> ++i;
> }
> return end;
> }
> typename QHash<Key, T>::const_iterator find(const Key &key, const T &value) const {
> typename QHash<Key, T>::const_iterator i(constFind(key));
> typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
> while (i != end && i.key() == key) {
> if (i.value() == value)
> return i;
> ++i;
> }
> return end;
> }
> typename QHash<Key, T>::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 <class Key, class T>
>inline bool QMultiHash<Key, T>::contains(const Key &key, const T &value) const
>{
> return constFind(key, value) != QHash<Key, T>::constEnd();
>}
>
>template <class Key, class T>
>inline int QMultiHash<Key, T>::remove(const Key &key, const T &value)
>{
> int n = 0;
> typename QHash<Key, T>::iterator i(find(key));
> typename QHash<Key, T>::iterator end(QHash<Key, T>::end());
> while (i != end && i.key() == key) {
> if (i.value() == value) {
> i = this->erase(i);
> ++n;
> } else {
> ++i;
> }
> }
> return n;
>}
>
>template <class Key, class T>
>inline int QMultiHash<Key, T>::count(const Key &key, const T &value) const
>{
> int n = 0;
> typename QHash<Key, T>::const_iterator i(constFind(key));
> typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
> while (i != end && i.key() == key) {
> if (i.value() == value)
> ++n;
> ++i;
> }
> return n;
>}
>
>template <class Key, class T> class QHashIterator { typedef typename QHash<Key,T>::const_iterator const_iterator; typedef const_iterator Item; QHash<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QHashIterator(const QHash<Key,T> &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QHashIterator &operator=(const QHash<Key,T> &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 { ((!(item_exists())) ? qt_assert("item_exists()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h",1029) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h",1029) : 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 Key, class T> class QMutableHashIterator { typedef typename QHash<Key,T>::iterator iterator; typedef typename QHash<Key,T>::const_iterator const_iterator; typedef iterator Item; QHash<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableHashIterator(QHash<Key,T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableHashIterator() { c->setSharable(true); } inline QMutableHashIterator &operator=(QHash<Key,T> &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() { ((!(item_exists())) ? qt_assert("item_exists()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h",1030) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h",1030) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qhash.h",1030) : 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; } };
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qhash.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/QHash" 2
># 43 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/QSharedPointer" 1
># 1 "../../../../qt5/qtbase/include/QtCore/qsharedpointer.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 1
># 42 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 43 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qshareddata.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qshareddata.h" 1
># 45 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qshareddata.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 46 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qshareddata.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 1
># 42 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 43 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 2
># 47 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qshareddata.h" 2
>
>
>
>
>
>
>template <class T> class QSharedDataPointer;
>
>class __attribute__((visibility("default"))) QSharedData
>{
>public:
> mutable QAtomicInt ref;
>
> inline QSharedData() : ref(0) { }
> inline QSharedData(const QSharedData &) : ref(0) { }
>
>private:
>
> QSharedData &operator=(const QSharedData &);
>};
>
>template <class T> class QSharedDataPointer
>{
>public:
> typedef T Type;
> typedef T *pointer;
>
> inline void detach() { if (d && d->ref.load() != 1) detach_helper(); }
> inline T &operator*() { detach(); return *d; }
> inline const T &operator*() const { return *d; }
> inline T *operator->() { detach(); return d; }
> inline const T *operator->() const { return d; }
> inline operator T *() { detach(); return d; }
> inline operator const T *() const { return d; }
> inline T *data() { detach(); return d; }
> inline const T *data() const { return d; }
> inline const T *constData() const { return d; }
>
> inline bool operator==(const QSharedDataPointer<T> &other) const { return d == other.d; }
> inline bool operator!=(const QSharedDataPointer<T> &other) const { return d != other.d; }
>
> inline QSharedDataPointer() { d = 0; }
> inline ~QSharedDataPointer() { if (d && !d->ref.deref()) delete d; }
>
> explicit QSharedDataPointer(T *data);
> inline QSharedDataPointer(const QSharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }
> inline QSharedDataPointer<T> & operator=(const QSharedDataPointer<T> &o) {
> if (o.d != d) {
> if (o.d)
> o.d->ref.ref();
> T *old = d;
> d = o.d;
> if (old && !old->ref.deref())
> delete old;
> }
> return *this;
> }
> inline QSharedDataPointer &operator=(T *o) {
> if (o != d) {
> if (o)
> o->ref.ref();
> T *old = d;
> d = o;
> if (old && !old->ref.deref())
> delete old;
> }
> return *this;
> }
>
> QSharedDataPointer(QSharedDataPointer &&o) : d(o.d) { o.d = 0; }
> inline QSharedDataPointer<T> &operator=(QSharedDataPointer<T> &&other)
> { qSwap(d, other.d); return *this; }
>
>
> inline bool operator!() const { return !d; }
>
> inline void swap(QSharedDataPointer &other)
> { qSwap(d, other.d); }
>
>protected:
> T *clone();
>
>private:
> void detach_helper();
>
> T *d;
>};
>
>template <class T> class QExplicitlySharedDataPointer
>{
>public:
> typedef T Type;
> typedef T *pointer;
>
> inline T &operator*() const { return *d; }
> inline T *operator->() { return d; }
> inline T *operator->() const { return d; }
> inline T *data() const { return d; }
> inline const T *constData() const { return d; }
>
> inline void detach() { if (d && d->ref.load() != 1) detach_helper(); }
>
> inline void reset()
> {
> if(d && !d->ref.deref())
> delete d;
>
> d = 0;
> }
>
> inline operator bool () const { return d != 0; }
>
> inline bool operator==(const QExplicitlySharedDataPointer<T> &other) const { return d == other.d; }
> inline bool operator!=(const QExplicitlySharedDataPointer<T> &other) const { return d != other.d; }
> inline bool operator==(const T *ptr) const { return d == ptr; }
> inline bool operator!=(const T *ptr) const { return d != ptr; }
>
> inline QExplicitlySharedDataPointer() { d = 0; }
> inline ~QExplicitlySharedDataPointer() { if (d && !d->ref.deref()) delete d; }
>
> explicit QExplicitlySharedDataPointer(T *data);
> inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }
>
> template<class X>
> inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o) : d(static_cast<T *>(o.data()))
> {
> if(d)
> d->ref.ref();
> }
>
> inline QExplicitlySharedDataPointer<T> & operator=(const QExplicitlySharedDataPointer<T> &o) {
> if (o.d != d) {
> if (o.d)
> o.d->ref.ref();
> T *old = d;
> d = o.d;
> if (old && !old->ref.deref())
> delete old;
> }
> return *this;
> }
> inline QExplicitlySharedDataPointer &operator=(T *o) {
> if (o != d) {
> if (o)
> o->ref.ref();
> T *old = d;
> d = o;
> if (old && !old->ref.deref())
> delete old;
> }
> return *this;
> }
>
> inline QExplicitlySharedDataPointer(QExplicitlySharedDataPointer &&o) : d(o.d) { o.d = 0; }
> inline QExplicitlySharedDataPointer<T> &operator=(QExplicitlySharedDataPointer<T> &&other)
> { qSwap(d, other.d); return *this; }
>
>
> inline bool operator!() const { return !d; }
>
> inline void swap(QExplicitlySharedDataPointer &other)
> { qSwap(d, other.d); }
>
>protected:
> T *clone();
>
>private:
> void detach_helper();
>
> T *d;
>};
>
>template <class T>
>inline QSharedDataPointer<T>::QSharedDataPointer(T *adata) : d(adata)
>{ if (d) d->ref.ref(); }
>
>template <class T>
>inline T *QSharedDataPointer<T>::clone()
>{
> return new T(*d);
>}
>
>template <class T>
> void QSharedDataPointer<T>::detach_helper()
>{
> T *x = clone();
> x->ref.ref();
> if (!d->ref.deref())
> delete d;
> d = x;
>}
>
>template <class T>
>inline T *QExplicitlySharedDataPointer<T>::clone()
>{
> return new T(*d);
>}
>
>template <class T>
> void QExplicitlySharedDataPointer<T>::detach_helper()
>{
> T *x = clone();
> x->ref.ref();
> if (!d->ref.deref())
> delete d;
> d = x;
>}
>
>template <class T>
>inline QExplicitlySharedDataPointer<T>::QExplicitlySharedDataPointer(T *adata) : d(adata)
>{ if (d) d->ref.ref(); }
>
>template <class T>
>inline void qSwap(QSharedDataPointer<T> &p1, QSharedDataPointer<T> &p2)
>{ p1.swap(p2); }
>
>template <class T>
>inline void qSwap(QExplicitlySharedDataPointer<T> &p1, QExplicitlySharedDataPointer<T> &p2)
>{ p1.swap(p2); }
>
>
>namespace std {
> template <class T>
> inline void swap(::QSharedDataPointer<T> &p1, ::QSharedDataPointer<T> &p2)
> { p1.swap(p2); }
>
> template <class T>
> inline void swap(::QExplicitlySharedDataPointer<T> &p1, ::QExplicitlySharedDataPointer<T> &p2)
> { p1.swap(p2); }
>}
>
>
>template<typename T> class QTypeInfo<QSharedDataPointer<T> > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSharedDataPointer<T>)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QSharedDataPointer<T>) }; static inline const char *name() { return "QSharedDataPointer<T>"; } };
>template<typename T> class QTypeInfo<QExplicitlySharedDataPointer<T> > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QExplicitlySharedDataPointer<T>)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QExplicitlySharedDataPointer<T>) }; static inline const char *name() { return "QExplicitlySharedDataPointer<T>"; } };
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qshareddata.h" 2
># 48 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer.h" 2
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qsharedpointer_impl.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h" 1
># 61 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 1
># 1 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 1
># 42 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h"
># 1 "../../../../qt5/qtbase/include/QtCore/qglobal.h" 1
># 43 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/thread/qatomic.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qatomic.h" 2
># 62 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qobject.h" 1
># 63 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qhash.h" 1
># 64 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h" 2
>
>
>
>
># 79 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h"
>template<typename T> inline void qt_sharedpointer_cast_check(T *) { }
>
>
>
>
>
>
>
>template <class T> class QWeakPointer;
>template <class T> class QSharedPointer;
>
>template <class X, class T>
>QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &ptr);
>template <class X, class T>
>QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &ptr);
>template <class X, class T>
>QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &ptr);
>
>
>template <class X, class T>
>QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &ptr);
>
>
>namespace QtSharedPointer {
> template <class T> class ExternalRefCount;
>
> template <class X, class Y> QSharedPointer<X> copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);
>
>
> __attribute__((visibility("default"))) void internalSafetyCheckAdd(const void *, const volatile void *);
> __attribute__((visibility("default"))) void internalSafetyCheckRemove(const void *);
>
> template <class T, typename Klass, typename RetVal>
> inline void executeDeleter(T *t, RetVal (Klass:: *memberDeleter)())
> { (t->*memberDeleter)(); }
> template <class T, typename Deleter>
> inline void executeDeleter(T *t, Deleter d)
> { d(t); }
> struct NormalDeleter {};
>
>
> template <class T> struct RemovePointer;
> template <class T> struct RemovePointer<T *> { typedef T Type; };
> template <class T> struct RemovePointer<QSharedPointer<T> > { typedef T Type; };
> template <class T> struct RemovePointer<QWeakPointer<T> > { typedef T Type; };
># 135 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h"
> struct ExternalRefCountData
> {
> typedef void (*DestroyerFn)(ExternalRefCountData *);
> QBasicAtomicInt weakref;
> QBasicAtomicInt strongref;
> DestroyerFn destroyer;
>
> inline ExternalRefCountData(DestroyerFn d)
> : destroyer(d)
> {
> strongref.store(1);
> weakref.store(1);
> }
> inline ExternalRefCountData(Qt::Initialization) { }
> ~ExternalRefCountData() { ((!(!weakref.load())) ? qt_assert("!weakref.load()","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h",149) : qt_noop()); ((!(strongref.load() <= 0)) ? qt_assert("strongref.load() <= 0","../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h",149) : qt_noop()); }
>
> void destroy() { destroyer(this); }
>
>
> __attribute__((visibility("default"))) static ExternalRefCountData *getAndRef(const QObject *);
> __attribute__((visibility("default"))) void setQObjectShared(const QObject *, bool enable);
> __attribute__((visibility("default"))) void checkQObjectShared(const QObject *);
>
> inline void checkQObjectShared(...) { }
> inline void setQObjectShared(...) { }
>
> inline void operator delete(void *ptr) { ::operator delete(ptr); }
> inline void operator delete(void *, void *) { }
> };
>
>
> template <class T, typename Deleter>
> struct CustomDeleter
> {
> Deleter deleter;
> T *ptr;
>
> CustomDeleter(T *p, Deleter d) : deleter(d), ptr(p) {}
> void execute() { executeDeleter(ptr, deleter); }
> };
># 183 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h"
> template <class T>
> struct CustomDeleter<T, NormalDeleter>
> {
> T *ptr;
>
> CustomDeleter(T *p, NormalDeleter) : ptr(p) {}
> void execute() { delete ptr; }
> };
>
>
>
>
>
>
> template <class T, typename Deleter>
> struct ExternalRefCountWithCustomDeleter: public ExternalRefCountData
> {
> typedef ExternalRefCountWithCustomDeleter Self;
> typedef ExternalRefCountData BaseClass;
> CustomDeleter<T, Deleter> extra;
>
> static inline void deleter(ExternalRefCountData *self)
> {
> Self *realself = static_cast<Self *>(self);
> realself->extra.execute();
>
>
> realself->extra.~CustomDeleter();
> }
> static void safetyCheckDeleter(ExternalRefCountData *self)
> {
> internalSafetyCheckRemove(self);
> deleter(self);
> }
>
> static inline Self *create(T *ptr, Deleter userDeleter)
> {
>
>
>
> DestroyerFn destroy = &deleter;
>
> Self *d = static_cast<Self *>(::operator new(sizeof(Self)));
>
>
> new (&d->extra) CustomDeleter<T, Deleter>(ptr, userDeleter);
> new (d) BaseClass(destroy);
>
> return d;
> }
> private:
>
> ExternalRefCountWithCustomDeleter() = delete;
> ~ExternalRefCountWithCustomDeleter() = delete;
> ExternalRefCountWithCustomDeleter(const ExternalRefCountWithCustomDeleter &) = delete; ExternalRefCountWithCustomDeleter &operator=(const ExternalRefCountWithCustomDeleter &) = delete;
> };
>
>
>
>
>
> template <class T>
> struct ExternalRefCountWithContiguousData: public ExternalRefCountData
> {
> typedef ExternalRefCountData Parent;
> T data;
>
> static void deleter(ExternalRefCountData *self)
> {
> ExternalRefCountWithContiguousData *that =
> static_cast<ExternalRefCountWithContiguousData *>(self);
> that->data.~T();
> }
> static void safetyCheckDeleter(ExternalRefCountData *self)
> {
> internalSafetyCheckRemove(self);
> deleter(self);
> }
>
> static inline ExternalRefCountData *create(T **ptr)
> {
>
>
>
> DestroyerFn destroy = &deleter;
>
> ExternalRefCountWithContiguousData *d =
> static_cast<ExternalRefCountWithContiguousData *>(::operator new(sizeof(ExternalRefCountWithContiguousData)));
>
>
>
> new (d) Parent(destroy);
>
> *ptr = &d->data;
> return d;
> }
>
> private:
>
> ExternalRefCountWithContiguousData() = delete;
> ~ExternalRefCountWithContiguousData() = delete;
> ExternalRefCountWithContiguousData(const ExternalRefCountWithContiguousData &) = delete; ExternalRefCountWithContiguousData &operator=(const ExternalRefCountWithContiguousData &) = delete;
> };
>}
>
>template <class T> class QSharedPointer
>{
> typedef T *QSharedPointer:: *RestrictedBool;
> typedef QtSharedPointer::ExternalRefCountData Data;
>public:
> typedef T Type;
> typedef T element_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;
>
> inline T *data() const { return value; }
> inline bool isNull() const { return !data(); }
> inline operator RestrictedBool() const { return isNull() ? 0 : &QSharedPointer::value; }
> inline bool operator !() const { return isNull(); }
> inline T &operator*() const { return *data(); }
> inline T *operator->() const { return data(); }
>
> QSharedPointer() : value(0), d(0) { }
> ~QSharedPointer() { deref(); }
>
> inline explicit QSharedPointer(T *ptr) : value(ptr)
> { internalConstruct(ptr, QtSharedPointer::NormalDeleter()); }
>
> template <typename Deleter>
> inline QSharedPointer(T *ptr, Deleter deleter) : value(ptr)
> { internalConstruct(ptr, deleter); }
>
> inline QSharedPointer(const QSharedPointer<T> &other) : value(other.value), d(other.d)
> { if (d) ref(); }
> inline QSharedPointer<T> &operator=(const QSharedPointer<T> &other)
> {
> QSharedPointer copy(other);
> swap(copy);
> return *this;
> }
>
> inline QSharedPointer<T> &operator=(QSharedPointer<T> &&other)
> {
> swap(other);
> return *this;
> }
>
>
> template <class X>
> inline QSharedPointer(const QSharedPointer<X> &other) : value(other.value), d(other.d)
> { if (d) ref(); }
>
> template <class X>
> inline QSharedPointer<T> &operator=(const QSharedPointer<X> &other)
> {
> qt_sharedpointer_cast_check<T>(static_cast<X *>(0));
> internalCopy(other);
> return *this;
> }
>
> template <class X>
> inline QSharedPointer(const QWeakPointer<X> &other) : value(0), d(0)
> { *this = other; }
>
> template <class X>
> inline QSharedPointer<T> &operator=(const QWeakPointer<X> &other)
> { internalSet(other.d, other.value); return *this; }
>
> inline void swap(QSharedPointer &other)
> { QSharedPointer<T>::internalSwap(other); }
>
> inline void reset() { clear(); }
> inline void reset(T *t)
> { QSharedPointer copy(t); swap(copy); }
> template <typename Deleter>
> inline void reset(T *t, Deleter deleter)
> { QSharedPointer copy(t, deleter); swap(copy); }
>
> template <class X>
> QSharedPointer<X> staticCast() const
> {
> return qSharedPointerCast<X, T>(*this);
> }
>
> template <class X>
> QSharedPointer<X> dynamicCast() const
> {
> return qSharedPointerDynamicCast<X, T>(*this);
> }
>
> template <class X>
> QSharedPointer<X> constCast() const
> {
> return qSharedPointerConstCast<X, T>(*this);
> }
>
>
> template <class X>
> QSharedPointer<X> objectCast() const
> {
> return qSharedPointerObjectCast<X, T>(*this);
> }
>
>
> inline void clear() { QSharedPointer copy; swap(copy); }
>
> QWeakPointer<T> toWeakRef() const;
>
>
> template <typename... Args>
> static QSharedPointer<T> create(Args && ...arguments)
> {
> QSharedPointer<T> result(Qt::Uninitialized);
> result.d = QtSharedPointer::ExternalRefCountWithContiguousData<T>::create(&result.value);
>
>
> new (result.data()) T(std::forward<Args>(arguments)...);
> result.internalFinishConstruction(result.data());
> return result;
> }
># 420 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer_impl.h"
>private:
> explicit QSharedPointer(Qt::Initialization) {}
>
> inline void deref()
> { deref(d); }
> static inline void deref(Data *d)
> {
> if (!d) return;
> if (!d->strongref.deref()) {
> d->destroy();
> }
> if (!d->weakref.deref())
> delete d;
> }
>
> template <typename Deleter>
> inline void internalConstruct(T *ptr, Deleter deleter)
> {
> if (ptr)
> d = QtSharedPointer::ExternalRefCountWithCustomDeleter<T, Deleter>::create(ptr, deleter);
> else
> d = 0;
> internalFinishConstruction(ptr);
> }
>
> inline void internalFinishConstruction(T *ptr)
> {
> d->setQObjectShared(ptr, true);
>
>
>
> }
>
> template <class X>
> inline void internalCopy(const QSharedPointer<X> &other)
> {
> Data *o = other.d;
> T *actual = other.value;
> if (o)
> other.ref();
> qSwap(d, o);
> qSwap(this->value, actual);
> deref(o);
> }
>
> inline void internalSwap(QSharedPointer &other)
> {
> qSwap(d, other.d);
> qSwap(this->value, other.value);
> }
>
>
>
>
> template <class X> friend class QSharedPointer;
> template <class X> friend class QWeakPointer;
> template <class X, class Y> friend QSharedPointer<X> QtSharedPointer::copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);
>
> inline void ref() const { d->weakref.ref(); d->strongref.ref(); }
>
> inline void internalSet(Data *o, T *actual)
> {
> if (o) {
>
>
> register int tmp = o->strongref.load();
> while (tmp > 0) {
>
> if (o->strongref.testAndSetRelaxed(tmp, tmp + 1))
> break;
> tmp = o->strongref.load();
> }
>
> if (tmp > 0) {
> o->weakref.ref();
> } else {
> o->checkQObjectShared(actual);
> o = 0;
> }
> }
>
> qSwap(d, o);
> qSwap(this->value, actual);
> if (!d || d->strongref.load() == 0)
> this->value = 0;
>
>
> deref(o);
> }
>
> Type *value;
> Data *d;
>};
>
>template <class T>
>class QWeakPointer
>{
> typedef T *QWeakPointer:: *RestrictedBool;
> typedef QtSharedPointer::ExternalRefCountData Data;
>
>public:
> typedef T element_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;
>
> inline bool isNull() const { return d == 0 || d->strongref.load() == 0 || value == 0; }
> inline operator RestrictedBool() const { return isNull() ? 0 : &QWeakPointer::value; }
> inline bool operator !() const { return isNull(); }
> inline T *data() const { return d == 0 || d->strongref.load() == 0 ? 0 : value; }
>
> inline QWeakPointer() : d(0), value(0) { }
> inline ~QWeakPointer() { if (d && !d->weakref.deref()) delete d; }
>
>
>
> template <class X>
> inline QWeakPointer(X *ptr) : d(ptr ? d->getAndRef(ptr) : 0), value(ptr)
> { }
>
> template <class X>
> inline QWeakPointer &operator=(X *ptr)
> { return *this = QWeakPointer(ptr); }
>
> inline QWeakPointer(const QWeakPointer<T> &o) : d(o.d), value(o.value)
> { if (d) d->weakref.ref(); }
> inline QWeakPointer<T> &operator=(const QWeakPointer<T> &o)
> {
> internalSet(o.d, o.value);
> return *this;
> }
>
> inline QWeakPointer(const QSharedPointer<T> &o) : d(o.d), value(o.data())
> { if (d) d->weakref.ref();}
> inline QWeakPointer<T> &operator=(const QSharedPointer<T> &o)
> {
> internalSet(o.d, o.value);
> return *this;
> }
>
> template <class X>
> inline QWeakPointer(const QWeakPointer<X> &o) : d(0), value(0)
> { *this = o; }
>
> template <class X>
> inline QWeakPointer<T> &operator=(const QWeakPointer<X> &o)
> {
>
>
> *this = o.toStrongRef();
> return *this;
> }
>
> template <class X>
> inline bool operator==(const QWeakPointer<X> &o) const
> { return d == o.d && value == static_cast<const T *>(o.value); }
>
> template <class X>
> inline bool operator!=(const QWeakPointer<X> &o) const
> { return !(*this == o); }
>
> template <class X>
> inline QWeakPointer(const QSharedPointer<X> &o) : d(0), value(0)
> { *this = o; }
>
> template <class X>
> inline QWeakPointer<T> &operator=(const QSharedPointer<X> &o)
> {
> qt_sharedpointer_cast_check<T>(static_cast<X *>(0));
> internalSet(o.d, o.data());
> return *this;
> }
>
> template <class X>
> inline bool operator==(const QSharedPointer<X> &o) const
> { return d == o.d; }
>
> template <class X>
> inline bool operator!=(const QSharedPointer<X> &o) const
> { return !(*this == o); }
>
> inline void clear() { *this = QWeakPointer<T>(); }
>
> inline QSharedPointer<T> toStrongRef() const { return QSharedPointer<T>(*this); }
>
>
>
>
>
>private:
>
>
>
>
> template <class X> friend class QSharedPointer;
>
>
> inline void internalSet(Data *o, T *actual)
> {
> if (d == o) return;
> if (o)
> o->weakref.ref();
> if (d && !d->weakref.deref())
> delete d;
> d = o;
> value = actual;
> }
>
> Data *d;
> T *value;
>};
>
>
>
>
>template <class T, class X>
>bool operator==(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
>{
> return ptr1.data() == ptr2.data();
>}
>template <class T, class X>
>bool operator!=(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
>{
> return ptr1.data() != ptr2.data();
>}
>
>template <class T, class X>
>bool operator==(const QSharedPointer<T> &ptr1, const X *ptr2)
>{
> return ptr1.data() == ptr2;
>}
>template <class T, class X>
>bool operator==(const T *ptr1, const QSharedPointer<X> &ptr2)
>{
> return ptr1 == ptr2.data();
>}
>template <class T, class X>
>bool operator!=(const QSharedPointer<T> &ptr1, const X *ptr2)
>{
> return !(ptr1 == ptr2);
>}
>template <class T, class X>
>bool operator!=(const T *ptr1, const QSharedPointer<X> &ptr2)
>{
> return !(ptr2 == ptr1);
>}
>
>template <class T, class X>
>bool operator==(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2)
>{
> return ptr2 == ptr1;
>}
>template <class T, class X>
>bool operator!=(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2)
>{
> return ptr2 != ptr1;
>}
>
>
>
>
>template <class T, class X>
>inline typename QSharedPointer<T>::difference_type operator-(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
>{
> return ptr1.data() - ptr2.data();
>}
>template <class T, class X>
>inline typename QSharedPointer<T>::difference_type operator-(const QSharedPointer<T> &ptr1, X *ptr2)
>{
> return ptr1.data() - ptr2;
>}
>template <class T, class X>
>inline typename QSharedPointer<X>::difference_type operator-(T *ptr1, const QSharedPointer<X> &ptr2)
>{
> return ptr1 - ptr2.data();
>}
>
>
>
>
>template <class T, class X>
>inline bool operator<(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
>{
> return ptr1.data() < ptr2.data();
>}
>template <class T, class X>
>inline bool operator<(const QSharedPointer<T> &ptr1, X *ptr2)
>{
> return ptr1.data() < ptr2;
>}
>template <class T, class X>
>inline bool operator<(T *ptr1, const QSharedPointer<X> &ptr2)
>{
> return ptr1 < ptr2.data();
>}
>
>
>
>
>template <class T>
>inline uint qHash(const QSharedPointer<T> &ptr, uint seed = 0)
>{
> return ::qHash(ptr.data(), seed);
>}
>
>
>template <class T>
>inline QWeakPointer<T> QSharedPointer<T>::toWeakRef() const
>{
> return QWeakPointer<T>(*this);
>}
>
>template <class T>
>inline void qSwap(QSharedPointer<T> &p1, QSharedPointer<T> &p2)
>{
> p1.swap(p2);
>}
>
>
>namespace std {
> template <class T>
> inline void swap(::QSharedPointer<T> &p1, ::QSharedPointer<T> &p2)
> { p1.swap(p2); }
>}
>
>
>namespace QtSharedPointer {
>
> template <class X, class T>
> inline QSharedPointer<X> copyAndSetPointer(X *ptr, const QSharedPointer<T> &src)
> {
> QSharedPointer<X> result;
> result.internalSet(src.d, ptr);
> return result;
> }
>}
>
>
>template <class X, class T>
>inline QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &src)
>{
> register X *ptr = static_cast<X *>(src.data());
> return QtSharedPointer::copyAndSetPointer(ptr, src);
>}
>template <class X, class T>
>inline QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &src)
>{
> return qSharedPointerCast<X, T>(src.toStrongRef());
>}
>
>template <class X, class T>
>inline QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
>{
> register X *ptr = dynamic_cast<X *>(src.data());
> return QtSharedPointer::copyAndSetPointer(ptr, src);
>}
>template <class X, class T>
>inline QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
>{
> return qSharedPointerDynamicCast<X, T>(src.toStrongRef());
>}
>
>template <class X, class T>
>inline QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
>{
> register X *ptr = const_cast<X *>(src.data());
> return QtSharedPointer::copyAndSetPointer(ptr, src);
>}
>template <class X, class T>
>inline QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
>{
> return qSharedPointerConstCast<X, T>(src.toStrongRef());
>}
>
>template <class X, class T>
>inline
>QWeakPointer<X> qWeakPointerCast(const QSharedPointer<T> &src)
>{
> return qSharedPointerCast<X, T>(src).toWeakRef();
>}
>
>
>template <class X, class T>
>inline QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
>{
> register X *ptr = qobject_cast<X *>(src.data());
> return QtSharedPointer::copyAndSetPointer(ptr, src);
>}
>template <class X, class T>
>inline QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
>{
> return qSharedPointerObjectCast<X>(src.toStrongRef());
>}
>
>template <class X, class T>
>inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
>qobject_cast(const QSharedPointer<T> &src)
>{
> return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
>}
>template <class X, class T>
>inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
>qobject_cast(const QWeakPointer<T> &src)
>{
> return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
>}
>
>
>
>template<typename T> class QTypeInfo<QWeakPointer<T> > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QWeakPointer<T>)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QWeakPointer<T>) }; static inline const char *name() { return "QWeakPointer<T>"; } };
>template<typename T> class QTypeInfo<QSharedPointer<T> > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSharedPointer<T>)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QSharedPointer<T>) }; static inline const char *name() { return "QSharedPointer<T>"; } };
>
>
>
>
>
># 1 "../../../../qt5/qtbase/include/QtCore/qsharedpointer_impl.h" 2
># 51 "../../../../qt5/qtbase/include/QtCore/../../../../../../src/qt/qt5/qtbase/src/corelib/tools/qsharedpointer.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/qsharedpointer.h" 2
># 1 "../../../../qt5/qtbase/include/QtCore/QSharedPointer" 2
># 44 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.h" 2
>
>namespace LanguageUtils {
>
>class __attribute__((visibility("protected"))) FakeMetaEnum {
> QString m_name;
> QStringList m_keys;
> QList<int> m_values;
>
>public:
> FakeMetaEnum();
> explicit FakeMetaEnum(const QString &name);
>
> bool isValid() const;
>
> QString name() const;
> void setName(const QString &name);
>
> void addKey(const QString &key, int value);
> QString key(int index) const;
> int keyCount() const;
> QStringList keys() const;
> bool hasKey(const QString &key) const;
>};
>
>class __attribute__((visibility("protected"))) FakeMetaMethod {
>public:
> enum {
> Signal,
> Slot,
> Method
> };
>
> enum {
> Private,
> Protected,
> Public
> };
>
>public:
> FakeMetaMethod();
> explicit FakeMetaMethod(const QString &name, const QString &returnType = QString());
>
> QString methodName() const;
> void setMethodName(const QString &name);
>
> void setReturnType(const QString &type);
>
> QStringList parameterNames() const;
> QStringList parameterTypes() const;
> void addParameter(const QString &name, const QString &type);
>
> int methodType() const;
> void setMethodType(int methodType);
>
> int access() const;
>
> int revision() const;
> void setRevision(int r);
>
>private:
> QString m_name;
> QString m_returnType;
> QStringList m_paramNames;
> QStringList m_paramTypes;
> int m_methodTy;
> int m_methodAccess;
> int m_revision;
>};
>
>class __attribute__((visibility("protected"))) FakeMetaProperty {
> QString m_propertyName;
> QString m_type;
> bool m_isList;
> bool m_isWritable;
> bool m_isPointer;
> int m_revision;
>
>public:
> FakeMetaProperty(const QString &name, const QString &type, bool isList, bool isWritable, bool isPointer, int revision);
>
> QString name() const;
> QString typeName() const;
>
> bool isList() const;
> bool isWritable() const;
> bool isPointer() const;
> int revision() const;
>};
>
>class __attribute__((visibility("protected"))) FakeMetaObject {
> FakeMetaObject(const FakeMetaObject &) = delete; FakeMetaObject &operator=(const FakeMetaObject &) = delete;;
>
>public:
> typedef QSharedPointer<FakeMetaObject> Ptr;
> typedef QSharedPointer<const FakeMetaObject> ConstPtr;
>
> class __attribute__((visibility("protected"))) Export {
> public:
> Export();
>
> QString package;
> QString type;
> ComponentVersion version;
> int metaObjectRevision;
>
> bool isValid() const;
> };
>
>private:
> QString m_className;
> QList<Export> m_exports;
> QString m_superName;
> QList<FakeMetaEnum> m_enums;
> QHash<QString, int> m_enumNameToIndex;
> QList<FakeMetaProperty> m_props;
> QHash<QString, int> m_propNameToIdx;
> QList<FakeMetaMethod> m_methods;
> QString m_defaultPropertyName;
> QString m_attachedTypeName;
>
>public:
> FakeMetaObject();
>
> QString className() const;
> void setClassName(const QString &name);
>
> void addExport(const QString &name, const QString &package, ComponentVersion version);
> void setExportMetaObjectRevision(int exportIndex, int metaObjectRevision);
> QList<Export> exports() const;
> Export exportInPackage(const QString &package) const;
>
> void setSuperclassName(const QString &superclass);
> QString superclassName() const;
>
> void addEnum(const FakeMetaEnum &fakeEnum);
> int enumeratorCount() const;
> int enumeratorOffset() const;
> FakeMetaEnum enumerator(int index) const;
> int enumeratorIndex(const QString &name) const;
>
> void addProperty(const FakeMetaProperty &property);
> int propertyCount() const;
> int propertyOffset() const;
> FakeMetaProperty property(int index) const;
> int propertyIndex(const QString &name) const;
>
> void addMethod(const FakeMetaMethod &method);
> int methodCount() const;
> int methodOffset() const;
> FakeMetaMethod method(int index) const;
>
> QString defaultPropertyName() const;
> void setDefaultPropertyName(const QString &defaultPropertyName);
>
> QString attachedTypeName() const;
> void setAttachedTypeName(const QString &name);
>};
>
>}
># 34 "../../../../../../src/qt/creator/src/libs/languageutils/fakemetaobject.cpp" 2
>
>using namespace LanguageUtils;
>
>FakeMetaEnum::FakeMetaEnum()
>{}
>
>FakeMetaEnum::FakeMetaEnum(const QString &name)
> : m_name(name)
>{}
>
>bool FakeMetaEnum::isValid() const
>{ return !m_name.isEmpty(); }
>
>QString FakeMetaEnum::name() const
>{ return m_name; }
>
>void FakeMetaEnum::setName(const QString &name)
>{ m_name = name; }
>
>void FakeMetaEnum::addKey(const QString &key, int value)
>{ m_keys.append(key); m_values.append(value); }
>
>QString FakeMetaEnum::key(int index) const
>{ return m_keys.at(index); }
>
>int FakeMetaEnum::keyCount() const
>{ return m_keys.size(); }
>
>QStringList FakeMetaEnum::keys() const
>{ return m_keys; }
>
>bool FakeMetaEnum::hasKey(const QString &key) const
>{ return m_keys.contains(key); }
>
>FakeMetaMethod::FakeMetaMethod(const QString &name, const QString &returnType)
> : m_name(name)
> , m_returnType(returnType)
> , m_methodTy(FakeMetaMethod::Method)
> , m_methodAccess(FakeMetaMethod::Public)
> , m_revision(0)
>{}
>
>FakeMetaMethod::FakeMetaMethod()
> : m_methodTy(FakeMetaMethod::Method)
> , m_methodAccess(FakeMetaMethod::Public)
> , m_revision(0)
>{}
>
>QString FakeMetaMethod::methodName() const
>{ return m_name; }
>
>void FakeMetaMethod::setMethodName(const QString &name)
>{ m_name = name; }
>
>void FakeMetaMethod::setReturnType(const QString &type)
>{ m_returnType = type; }
>
>QStringList FakeMetaMethod::parameterNames() const
>{ return m_paramNames; }
>
>QStringList FakeMetaMethod::parameterTypes() const
>{ return m_paramTypes; }
>
>void FakeMetaMethod::addParameter(const QString &name, const QString &type)
>{ m_paramNames.append(name); m_paramTypes.append(type); }
>
>int FakeMetaMethod::methodType() const
>{ return m_methodTy; }
>
>void FakeMetaMethod::setMethodType(int methodType)
>{ m_methodTy = methodType; }
>
>int FakeMetaMethod::access() const
>{ return m_methodAccess; }
>
>int FakeMetaMethod::revision() const
>{ return m_revision; }
>
>void FakeMetaMethod::setRevision(int r)
>{ m_revision = r; }
>
>
>FakeMetaProperty::FakeMetaProperty(const QString &name, const QString &type, bool isList,
> bool isWritable, bool isPointer, int revision)
> : m_propertyName(name)
> , m_type(type)
> , m_isList(isList)
> , m_isWritable(isWritable)
> , m_isPointer(isPointer)
> , m_revision(revision)
>{}
>
>QString FakeMetaProperty::name() const
>{ return m_propertyName; }
>
>QString FakeMetaProperty::typeName() const
>{ return m_type; }
>
>bool FakeMetaProperty::isList() const
>{ return m_isList; }
>
>bool FakeMetaProperty::isWritable() const
>{ return m_isWritable; }
>
>bool FakeMetaProperty::isPointer() const
>{ return m_isPointer; }
>
>int FakeMetaProperty::revision() const
>{ return m_revision; }
>
>
>FakeMetaObject::FakeMetaObject()
>{
>}
>
>QString FakeMetaObject::className() const
>{ return m_className; }
>void FakeMetaObject::setClassName(const QString &name)
>{ m_className = name; }
>
>void FakeMetaObject::addExport(const QString &name, const QString &package, ComponentVersion version)
>{
> Export exp;
> exp.type = name;
> exp.package = package;
> exp.version = version;
> m_exports.append(exp);
>}
>
>void FakeMetaObject::setExportMetaObjectRevision(int exportIndex, int metaObjectRevision)
>{
> m_exports[exportIndex].metaObjectRevision = metaObjectRevision;
>}
>
>QList<FakeMetaObject::Export> FakeMetaObject::exports() const
>{ return m_exports; }
>FakeMetaObject::Export FakeMetaObject::exportInPackage(const QString &package) const
>{
> for (QForeachContainer<__typeof__(m_exports)> _container_(m_exports); !_container_.brk && _container_.i != _container_.e; __extension__ ({ ++_container_.brk; ++_container_.i; })) for (const Export &exp = *_container_.i;; __extension__ ({--_container_.brk; break;})) {
> if (exp.package == package)
> return exp;
> }
> return Export();
>}
>
>void FakeMetaObject::setSuperclassName(const QString &superclass)
>{ m_superName = superclass; }
>QString FakeMetaObject::superclassName() const
>{ return m_superName; }
>
>void FakeMetaObject::addEnum(const FakeMetaEnum &fakeEnum)
>{ m_enumNameToIndex.insert(fakeEnum.name(), m_enums.size()); m_enums.append(fakeEnum); }
>int FakeMetaObject::enumeratorCount() const
>{ return m_enums.size(); }
>int FakeMetaObject::enumeratorOffset() const
>{ return 0; }
>FakeMetaEnum FakeMetaObject::enumerator(int index) const
>{ return m_enums.at(index); }
>int FakeMetaObject::enumeratorIndex(const QString &name) const
>{ return m_enumNameToIndex.value(name, -1); }
>
>void FakeMetaObject::addProperty(const FakeMetaProperty &property)
>{ m_propNameToIdx.insert(property.name(), m_props.size()); m_props.append(property); }
>int FakeMetaObject::propertyCount() const
>{ return m_props.size(); }
>int FakeMetaObject::propertyOffset() const
>{ return 0; }
>FakeMetaProperty FakeMetaObject::property(int index) const
>{ return m_props.at(index); }
>int FakeMetaObject::propertyIndex(const QString &name) const
>{ return m_propNameToIdx.value(name, -1); }
>
>void FakeMetaObject::addMethod(const FakeMetaMethod &method)
>{ m_methods.append(method); }
>int FakeMetaObject::methodCount() const
>{ return m_methods.size(); }
>int FakeMetaObject::methodOffset() const
>{ return 0; }
>FakeMetaMethod FakeMetaObject::method(int index) const
>{ return m_methods.at(index); }
>
>QString FakeMetaObject::defaultPropertyName() const
>{ return m_defaultPropertyName; }
>void FakeMetaObject::setDefaultPropertyName(const QString &defaultPropertyName)
>{ m_defaultPropertyName = defaultPropertyName; }
>
>QString FakeMetaObject::attachedTypeName() const
>{ return m_attachedTypeName; }
>void FakeMetaObject::setAttachedTypeName(const QString &name)
>{ m_attachedTypeName = name; }
>
>FakeMetaObject::Export::Export()
> : metaObjectRevision(0)
>{}
>bool FakeMetaObject::Export::isValid() const
>{ return version.isValid() || !package.isEmpty() || !type.isEmpty(); }

Actions: View

Attachments on bug 829247: 589811 | 589813