bug-2185: New test.ok-for-regtest-with-gcc-linaro-6.2-2016.11

Change-Id: I0bb21cf05d79576a8ca25f53db3570d0d3d5428c

3 files changed, 80343 insertions, 0 deletions

diff --git a/bug-2185/Makefile b/bug-2185/Makefile
new file mode 100644
index 0000000..23f8a8f
--- /dev/null
+++ b/bug-2185/Makefile
@@ -0,0 +1 @@
+include ../common.mk
diff --git a/bug-2185/build.sh b/bug-2185/build.sh
new file mode 100755
index 0000000..c7fac20
--- /dev/null
+++ b/bug-2185/build.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+set -e
+
+case ${TARGET} in
+    aarch64*)
+	CXXFLAGS="-march=armv8-a -mtune=cortex-a53 -pthread -O3 -std=c++1z -fvisibility=hidden -fvisibility-inlines-hidden -Wall -W -Wvla -Wdate-time -fPIC"
+	;;
+    *)
+	echo "$(basename $(pwd)): SKIP" > result.txt
+	exit 0
+	;;
+esac
+
+echo "$(basename $(pwd)): FAIL" > result.txt
+set -x
+${CXX} -c -o /dev/null preprocessed.cpp ${CXXFLAGS}
+set +x
+echo "$(basename $(pwd)): PASS" > result.txt
diff --git a/bug-2185/preprocessed.cpp b/bug-2185/preprocessed.cpp
new file mode 100644
index 0000000..100589c
--- /dev/null
+++ b/bug-2185/preprocessed.cpp
@@ -0,0 +1,80324 @@
+# 1 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "/mnt/odroid-c2/usr/include/stdc-predef.h" 1 3 4
+# 1 "<command-line>" 2
+# 1 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+# 40 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+# 1 "../../include/QtCore/qjsonobject.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonobject.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonobject.h"
+# 1 "../../include/QtCore/qjsonvalue.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonvalue.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonvalue.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstddef" 1 3
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstddef" 3
+       
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstddef" 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++config.h" 1 3
+# 194 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++config.h" 3
+
+# 194 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++config.h" 3
+namespace std
+{
+  typedef long unsigned int size_t;
+  typedef long int ptrdiff_t;
+
+
+  typedef decltype(nullptr) nullptr_t;
+
+}
+# 216 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++config.h" 3
+namespace std
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+namespace __gnu_cxx
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+# 482 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++config.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/os_defines.h" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/os_defines.h" 3
+# 1 "/mnt/odroid-c2/usr/include/features.h" 1 3 4
+# 367 "/mnt/odroid-c2/usr/include/features.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/cdefs.h" 1 3 4
+# 410 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/cdefs.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4
+# 411 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/cdefs.h" 2 3 4
+# 368 "/mnt/odroid-c2/usr/include/features.h" 2 3 4
+# 391 "/mnt/odroid-c2/usr/include/features.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/gnu/stubs.h" 1 3 4
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4
+# 6 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/gnu/stubs.h" 2 3 4
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/gnu/stubs-lp64.h" 1 3 4
+# 9 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/gnu/stubs.h" 2 3 4
+# 392 "/mnt/odroid-c2/usr/include/features.h" 2 3 4
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/os_defines.h" 2 3
+# 483 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++config.h" 2 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/cpu_defines.h" 1 3
+# 486 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++config.h" 2 3
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstddef" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 149 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 3 4
+typedef long int ptrdiff_t;
+# 216 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 3 4
+typedef long unsigned int size_t;
+# 426 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/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;
+
+
+
+
+
+
+  typedef decltype(nullptr) nullptr_t;
+# 46 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstddef" 2 3
+
+
+namespace std
+{
+
+  using ::max_align_t;
+}
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 60 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+# 1 "../../include/QtCore/qconfig.h" 1
+# 1 "../../include/QtCore/../../src/corelib/global/qconfig.h" 1
+# 1 "../../include/QtCore/qconfig.h" 2
+# 61 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 1 "../../include/QtCore/qfeatures.h" 1
+# 1 "../../include/QtCore/../../src/corelib/global/qfeatures.h" 1
+# 1 "../../include/QtCore/qfeatures.h" 2
+# 62 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 78 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+# 1 "../../include/QtCore/qsystemdetection.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qsystemdetection.h" 1
+# 1 "../../include/QtCore/qsystemdetection.h" 2
+# 79 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 1 "../../include/QtCore/qprocessordetection.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qprocessordetection.h" 1
+# 1 "../../include/QtCore/qprocessordetection.h" 2
+# 80 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 1 "../../include/QtCore/qcompilerdetection.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qcompilerdetection.h" 1
+# 985 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qcompilerdetection.h"
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/utility" 1 3
+# 58 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/utility" 3
+       
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/utility" 3
+# 69 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/utility" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_relops.h" 1 3
+# 67 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_relops.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  namespace rel_ops
+  {
+ 
+# 85 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator!=(const _Tp& __x, const _Tp& __y)
+      { return !(__x == __y); }
+# 98 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>(const _Tp& __x, const _Tp& __y)
+      { return __y < __x; }
+# 111 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator<=(const _Tp& __x, const _Tp& __y)
+      { return !(__y < __x); }
+# 124 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>=(const _Tp& __x, const _Tp& __y)
+      { return !(__x < __y); }
+
+ 
+  }
+
+}
+# 70 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/utility" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_pair.h" 1 3
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_pair.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/move.h" 1 3
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/move.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/concept_check.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/concept_check.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/concept_check.h" 3
+# 35 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/type_traits" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/type_traits" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/type_traits" 3
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/type_traits" 3
+namespace std
+{
+  typedef short unsigned int uint_least16_t;
+  typedef unsigned int uint_least32_t;
+}
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 68 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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() const { return value; }
+
+
+
+
+      constexpr value_type operator()() const { return value; }
+
+    };
+
+  template<typename _Tp, _Tp __v>
+    constexpr _Tp integral_constant<_Tp, __v>::value;
+
+
+  typedef integral_constant<bool, true> true_type;
+
+
+  typedef integral_constant<bool, false> false_type;
+
+  template<bool __v>
+    using __bool_constant = integral_constant<bool, __v>;
+
+
+
+  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>
+    { };
+
+
+
+
+
+
+  template<typename _Tp>
+    struct __success_type
+    { typedef _Tp type; };
+
+  struct __failure_type
+  { };
+
+
+
+  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 __is_void_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  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 { };
+# 288 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/type_traits" 3
+  template<typename _Tp>
+    struct is_integral
+    : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+  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 { };
+# 316 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/type_traits" 3
+  template<typename _Tp>
+    struct is_floating_point
+    : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+
+  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 __is_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+
+  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 __is_member_object_pointer_helper<
+    typename remove_cv<_Tp>::type>::type
+    { };
+
+  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 __is_member_function_pointer_helper<
+    typename remove_cv<_Tp>::type>::type
+    { };
+
+
+  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...) &&>
+    : 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......) &>
+    : 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...) 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......) 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...) 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......) 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 _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 _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_null_pointer_helper
+    : public false_type { };
+
+  template<>
+    struct __is_null_pointer_helper<std::nullptr_t>
+    : public true_type { };
+
+
+  template<typename _Tp>
+    struct is_null_pointer
+    : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_nullptr_t
+    : public is_null_pointer<_Tp>
+    { };
+
+
+
+
+  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>,
+     is_null_pointer<_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_null_pointer<_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 __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
+    { };
+
+
+
+  template<typename _Tp>
+    struct __is_referenceable
+    : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
+    { };
+
+  template<typename _Res, typename... _Args>
+    struct __is_referenceable<_Res(_Args...)>
+    : public true_type
+    { };
+
+  template<typename _Res, typename... _Args>
+    struct __is_referenceable<_Res(_Args......)>
+    : public true_type
+    { };
+
+
+
+
+  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_trivially_copyable
+    : public integral_constant<bool, __is_trivially_copyable(_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_final
+    : public integral_constant<bool, __is_final(_Tp)>
+    { };
+
+
+
+  template<typename _Tp>
+    struct is_abstract
+    : public integral_constant<bool, __is_abstract(_Tp)>
+    { };
+
+  template<typename _Tp,
+    bool = is_arithmetic<_Tp>::value>
+    struct __is_signed_helper
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_signed_helper<_Tp, true>
+    : public integral_constant<bool, _Tp(-1) < _Tp(0)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_signed
+    : public __is_signed_helper<_Tp>::type
+    { };
+
+
+  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
+  {
+    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
+    : public __do_is_destructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp,
+           bool = __or_<is_void<_Tp>,
+                        __is_array_unknown_bounds<_Tp>,
+                        is_function<_Tp>>::value,
+           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+    struct __is_destructible_safe;
+
+  template<typename _Tp>
+    struct __is_destructible_safe<_Tp, false, false>
+    : public __is_destructible_impl<typename
+               remove_all_extents<_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 __is_destructible_safe<_Tp>::type
+    { };
+
+
+
+
+
+  struct __do_is_nt_destructible_impl
+  {
+    template<typename _Tp>
+      static integral_constant<bool, noexcept(declval<_Tp&>().~_Tp())>
+        __test(int);
+
+    template<typename>
+      static false_type __test(...);
+  };
+
+  template<typename _Tp>
+    struct __is_nt_destructible_impl
+    : public __do_is_nt_destructible_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp,
+           bool = __or_<is_void<_Tp>,
+                        __is_array_unknown_bounds<_Tp>,
+                        is_function<_Tp>>::value,
+           bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+    struct __is_nt_destructible_safe;
+
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, false, false>
+    : public __is_nt_destructible_impl<typename
+               remove_all_extents<_Tp>::type>::type
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, true, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nt_destructible_safe<_Tp, false, true>
+    : public true_type { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_destructible
+    : public __is_nt_destructible_safe<_Tp>::type
+    { };
+
+  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 __is_default_constructible_safe<_Tp>::type
+    { };
+# 900 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 __is_direct_constructible_new<_Tp, _Arg>::type
+    { };
+
+
+
+
+
+
+  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 __is_constructible_impl<_Tp, _Args...>::type
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_copy_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_copy_constructible_impl<_Tp, true>
+    : public is_constructible<_Tp, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_copy_constructible
+    : public __is_copy_constructible_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_move_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_move_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_move_constructible_impl<_Tp, true>
+    : 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_referenceable<_Tp>::value>
+    struct __is_nothrow_copy_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_nothrow_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nothrow_copy_constructible_impl<_Tp, true>
+    : 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_referenceable<_Tp>::value>
+    struct __is_nothrow_move_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_nothrow_move_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nothrow_move_constructible_impl<_Tp, true>
+    : 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
+    {
+      template<typename _Tp1, typename _Up1,
+        typename = decltype(declval<_Tp1>() = declval<_Up1>())>
+ static true_type
+ __test(int);
+
+      template<typename, typename>
+ static false_type
+ __test(...);
+
+    public:
+      typedef decltype(__test<_Tp, _Up>(0)) type;
+    };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_assignable
+      : public __is_assignable_helper<_Tp, _Up>::type
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_copy_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_copy_assignable_impl<_Tp, true>
+    : public is_assignable<_Tp&, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_copy_assignable
+    : public __is_copy_assignable_impl<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_move_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_move_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_move_assignable_impl<_Tp, true>
+    : 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_referenceable<_Tp>::value>
+    struct __is_nt_copy_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_nt_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nt_copy_assignable_impl<_Tp, true>
+    : 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_referenceable<_Tp>::value>
+    struct __is_nt_move_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_nt_move_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_nt_move_assignable_impl<_Tp, true>
+    : public is_nothrow_assignable<_Tp&, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_move_assignable
+    : public __is_nt_move_assignable_impl<_Tp>
+    { };
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_trivially_constructible
+    : public __and_<is_constructible<_Tp, _Args...>, integral_constant<bool,
+   __is_trivially_constructible(_Tp, _Args...)>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_default_constructible
+    : public is_trivially_constructible<_Tp>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_copy_constructible
+    : public __and_<is_copy_constructible<_Tp>,
+      integral_constant<bool,
+   __is_trivially_constructible(_Tp, const _Tp&)>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_move_constructible
+    : public __and_<is_move_constructible<_Tp>,
+      integral_constant<bool,
+   __is_trivially_constructible(_Tp, _Tp&&)>>::type
+    { };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_trivially_assignable
+    : public __and_<is_assignable<_Tp, _Up>,
+      integral_constant<bool,
+   __is_trivially_assignable(_Tp, _Up)>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_copy_assignable
+    : public __and_<is_copy_assignable<_Tp>,
+      integral_constant<bool,
+   __is_trivially_assignable(_Tp&, const _Tp&)>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_move_assignable
+    : public __and_<is_move_assignable<_Tp>,
+      integral_constant<bool,
+   __is_trivially_assignable(_Tp&, _Tp&&)>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_destructible
+    : public __and_<is_destructible<_Tp>, integral_constant<bool,
+         __has_trivial_destructor(_Tp)>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct has_trivial_default_constructor
+    : public integral_constant<bool, __has_trivial_constructor(_Tp)>
+    { } __attribute__ ((__deprecated__));
+
+
+  template<typename _Tp>
+    struct has_trivial_copy_constructor
+    : public integral_constant<bool, __has_trivial_copy(_Tp)>
+    { } __attribute__ ((__deprecated__));
+
+
+  template<typename _Tp>
+    struct has_trivial_copy_assign
+    : public integral_constant<bool, __has_trivial_assign(_Tp)>
+    { } __attribute__ ((__deprecated__));
+
+
+  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
+    { typedef typename is_void<_To>::type type; };
+
+  template<typename _From, typename _To>
+    class __is_convertible_helper<_From, _To, false>
+    {
+       template<typename _To1>
+ static void __test_aux(_To1);
+
+      template<typename _From1, typename _To1,
+        typename = decltype(__test_aux<_To1>(std::declval<_From1>()))>
+ static true_type
+ __test(int);
+
+      template<typename, typename>
+ static false_type
+ __test(...);
+
+    public:
+      typedef decltype(__test<_From, _To>(0)) type;
+    };
+
+
+
+  template<typename _From, typename _To>
+    struct is_convertible
+    : public __is_convertible_helper<_From, _To>::type
+    { };
+
+
+
+
+
+  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>
+    using remove_const_t = typename remove_const<_Tp>::type;
+
+
+  template<typename _Tp>
+    using remove_volatile_t = typename remove_volatile<_Tp>::type;
+
+
+  template<typename _Tp>
+    using remove_cv_t = typename remove_cv<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_const_t = typename add_const<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_volatile_t = typename add_volatile<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_cv_t = typename add_cv<_Tp>::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 = __is_referenceable<_Tp>::value>
+    struct __add_lvalue_reference_helper
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct __add_lvalue_reference_helper<_Tp, true>
+    { typedef _Tp& type; };
+
+
+  template<typename _Tp>
+    struct add_lvalue_reference
+    : public __add_lvalue_reference_helper<_Tp>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_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 _Tp>
+    using remove_reference_t = typename remove_reference<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
+
+
+
+
+
+  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; };
+# 1718 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; };
+
+
+  template<>
+    struct __make_signed<wchar_t> : __make_signed<unsigned int>
+    { };
+
+
+
+  template<>
+    struct __make_signed<char16_t> : __make_signed<uint_least16_t>
+    { };
+  template<>
+    struct __make_signed<char32_t> : __make_signed<uint_least32_t>
+    { };
+# 1830 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>
+    using make_signed_t = typename make_signed<_Tp>::type;
+
+
+  template<typename _Tp>
+    using make_unsigned_t = typename make_unsigned<_Tp>::type;
+
+
+
+
+
+  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>
+    using remove_extent_t = typename remove_extent<_Tp>::type;
+
+
+  template<typename _Tp>
+    using remove_all_extents_t = typename remove_all_extents<_Tp>::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, bool = __or_<__is_referenceable<_Tp>,
+          is_void<_Tp>>::value>
+    struct __add_pointer_helper
+    { typedef _Tp type; };
+
+  template<typename _Tp>
+    struct __add_pointer_helper<_Tp, true>
+    { typedef typename remove_reference<_Tp>::type* type; };
+
+  template<typename _Tp>
+    struct add_pointer
+    : public __add_pointer_helper<_Tp>
+    { };
+
+
+
+  template<typename _Tp>
+    using remove_pointer_t = typename remove_pointer<_Tp>::type;
+
+
+  template<typename _Tp>
+    using add_pointer_t = typename add_pointer<_Tp>::type;
+
+
+  template<std::size_t _Len>
+    struct __aligned_storage_msa
+    {
+      union __type
+      {
+ unsigned char __data[_Len];
+ struct __attribute__((__aligned__)) { } __align;
+      };
+    };
+# 1984 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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... _Types>
+    struct __strictest_alignment
+    {
+      static const size_t _S_alignment = 0;
+      static const size_t _S_size = 0;
+    };
+
+  template <typename _Tp, typename... _Types>
+    struct __strictest_alignment<_Tp, _Types...>
+    {
+      static const size_t _S_alignment =
+        alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
+ ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
+      static const size_t _S_size =
+        sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
+ ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
+    };
+# 2023 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/type_traits" 3
+  template <size_t _Len, typename... _Types>
+    struct aligned_union
+    {
+    private:
+      static_assert(sizeof...(_Types) != 0, "At least one type is required");
+
+      using __strictest = __strictest_alignment<_Types...>;
+      static const size_t _S_len = _Len > __strictest::_S_size
+ ? _Len : __strictest::_S_size;
+    public:
+
+      static const size_t alignment_value = __strictest::_S_alignment;
+
+      typedef typename aligned_storage<_S_len, alignment_value>::type type;
+    };
+
+  template <size_t _Len, typename... _Types>
+    const size_t aligned_union<_Len, _Types...>::alignment_value;
+
+
+
+  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 __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<typename... _Cond>
+    using _Require = typename enable_if<__and_<_Cond...>::value>::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;
+
+
+
+  struct __do_common_type_impl
+  {
+    template<typename _Tp, typename _Up>
+      static __success_type<typename decay<decltype
+       (true ? std::declval<_Tp>()
+        : std::declval<_Up>())>::type> _S_test(int);
+
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _Tp, typename _Up>
+    struct __common_type_impl
+    : private __do_common_type_impl
+    {
+      typedef decltype(_S_test<_Tp, _Up>(0)) type;
+    };
+
+  struct __do_member_type_wrapper
+  {
+    template<typename _Tp>
+      static __success_type<typename _Tp::type> _S_test(int);
+
+    template<typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _Tp>
+    struct __member_type_wrapper
+    : private __do_member_type_wrapper
+    {
+      typedef decltype(_S_test<_Tp>(0)) type;
+    };
+
+  template<typename _CTp, typename... _Args>
+    struct __expanded_common_type_wrapper
+    {
+      typedef common_type<typename _CTp::type, _Args...> type;
+    };
+
+  template<typename... _Args>
+    struct __expanded_common_type_wrapper<__failure_type, _Args...>
+    { typedef __failure_type type; };
+
+  template<typename _Tp>
+    struct common_type<_Tp>
+    { typedef typename decay<_Tp>::type type; };
+
+  template<typename _Tp, typename _Up>
+    struct common_type<_Tp, _Up>
+    : public __common_type_impl<_Tp, _Up>::type
+    { };
+
+  template<typename _Tp, typename _Up, typename... _Vp>
+    struct common_type<_Tp, _Up, _Vp...>
+    : public __expanded_common_type_wrapper<typename __member_type_wrapper<
+               common_type<_Tp, _Up>>::type, _Vp...>::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;
+
+
+
+
+
+
+  struct __result_of_memfun_ref_impl
+  {
+    template<typename _Fp, typename _Tp1, typename... _Args>
+      static __success_type<decltype(
+      (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
+      )> _S_test(int);
+
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun_ref
+    : private __result_of_memfun_ref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
+    };
+
+
+  struct __result_of_memfun_deref_impl
+  {
+    template<typename _Fp, typename _Tp1, typename... _Args>
+      static __success_type<decltype(
+      ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
+      )> _S_test(int);
+
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun_deref
+    : private __result_of_memfun_deref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
+    };
+
+
+  struct __result_of_memobj_ref_impl
+  {
+    template<typename _Fp, typename _Tp1>
+      static __success_type<decltype(
+      std::declval<_Tp1>().*std::declval<_Fp>()
+      )> _S_test(int);
+
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj_ref
+    : private __result_of_memobj_ref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
+    };
+
+
+  struct __result_of_memobj_deref_impl
+  {
+    template<typename _Fp, typename _Tp1>
+      static __success_type<decltype(
+      (*std::declval<_Tp1>()).*std::declval<_Fp>()
+      )> _S_test(int);
+
+    template<typename, typename>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj_deref
+    : private __result_of_memobj_deref_impl
+    {
+      typedef decltype(_S_test<_MemPtr, _Arg>(0)) type;
+    };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_memobj;
+
+  template<typename _Res, typename _Class, typename _Arg>
+    struct __result_of_memobj<_Res _Class::*, _Arg>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _Arg>::type>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<__or_<is_same<_Argval, _Class>,
+        is_base_of<_Class, _Argval>>::value,
+        __result_of_memobj_ref<_MemPtr, _Arg>,
+        __result_of_memobj_deref<_MemPtr, _Arg>
+      >::type::type type;
+    };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_memfun;
+
+  template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+    struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
+    {
+      typedef typename remove_cv<typename remove_reference<
+        _Arg>::type>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<__or_<is_same<_Argval, _Class>,
+        is_base_of<_Class, _Argval>>::value,
+        __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
+        __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
+      >::type::type type;
+    };
+
+  template<bool, bool, typename _Functor, typename... _ArgTypes>
+    struct __result_of_impl
+    {
+      typedef __failure_type type;
+    };
+
+  template<typename _MemPtr, typename _Arg>
+    struct __result_of_impl<true, false, _MemPtr, _Arg>
+    : public __result_of_memobj<typename decay<_MemPtr>::type, _Arg>
+    { };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
+    : public __result_of_memfun<typename decay<_MemPtr>::type, _Arg, _Args...>
+    { };
+
+
+  struct __result_of_other_impl
+  {
+    template<typename _Fn, typename... _Args>
+      static __success_type<decltype(
+      std::declval<_Fn>()(std::declval<_Args>()...)
+      )> _S_test(int);
+
+    template<typename...>
+      static __failure_type _S_test(...);
+  };
+
+  template<typename _Functor, typename... _ArgTypes>
+    struct __result_of_impl<false, false, _Functor, _ArgTypes...>
+    : private __result_of_other_impl
+    {
+      typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
+    };
+
+  template<typename _Functor, typename... _ArgTypes>
+    struct result_of<_Functor(_ArgTypes...)>
+    : public __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
+    { };
+
+
+
+  template<size_t _Len, size_t _Align =
+     __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
+
+  template <size_t _Len, typename... _Types>
+    using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
+
+
+  template<typename _Tp>
+    using decay_t = typename decay<_Tp>::type;
+
+
+  template<bool _Cond, typename _Tp = void>
+    using enable_if_t = typename enable_if<_Cond, _Tp>::type;
+
+
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
+
+
+  template<typename... _Tp>
+    using common_type_t = typename common_type<_Tp...>::type;
+
+
+  template<typename _Tp>
+    using underlying_type_t = typename underlying_type<_Tp>::type;
+
+
+  template<typename _Tp>
+    using result_of_t = typename result_of<_Tp>::type;
+
+
+  template<typename...> using __void_t = void;
+# 2425 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/type_traits" 3
+
+}
+# 58 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/move.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 74 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 { };
+# 118 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/move.h" 3
+  template<typename _Tp>
+    constexpr typename
+    conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type
+    move_if_noexcept(_Tp& __x) noexcept
+    { return std::move(__x); }
+# 133 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/move.h" 3
+  template<typename _Tp>
+    inline _Tp*
+    addressof(_Tp& __r) noexcept
+    { return std::__addressof(__r); }
+
+
+  template <typename _Tp, typename _Up = _Tp>
+    inline _Tp
+    __exchange(_Tp& __obj, _Up&& __new_val)
+    {
+      _Tp __old_val = std::move(__obj);
+      __obj = std::forward<_Up>(__new_val);
+      return __old_val;
+    }
+
+
+
+}
+# 159 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/move.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 174 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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]);
+    }
+
+
+
+}
+# 60 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_pair.h" 2 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 76 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_pair.h" 3
+  struct piecewise_construct_t { };
+
+
+  constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
+
+
+  template<typename...>
+    class tuple;
+
+  template<std::size_t...>
+    struct _Index_tuple;
+# 95 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_pair.h" 3
+  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;
+      constexpr pair(pair&&) = default;
+
+
+      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); }
+# 273 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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));
+    }
+# 292 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_pair.h" 3
+
+}
+# 71 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/utility" 2 3
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/initializer_list" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/initializer_list" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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
+# 76 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+
+
+
+
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Tp, _Up>& __p) noexcept
+    { return __p.first; }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Tp, _Up>&& __p) noexcept
+    { return std::move(__p.first); }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&
+    get(pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+
+  template <typename _Tp, typename _Up>
+    constexpr const _Tp&
+    get(const pair<_Up, _Tp>& __p) noexcept
+    { return __p.second; }
+
+  template <typename _Tp, typename _Up>
+    constexpr _Tp&&
+    get(pair<_Up, _Tp>&& __p) noexcept
+    { return std::move(__p.second); }
+
+
+
+
+  template <typename _Tp, typename _Up = _Tp>
+    inline _Tp
+    exchange(_Tp& __obj, _Up&& __new_val)
+    { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
+
+
+
+
+  template<size_t... _Indexes>
+    struct _Index_tuple
+    {
+      typedef _Index_tuple<_Indexes..., sizeof...(_Indexes)> __next;
+    };
+
+
+  template<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<typename _Tp, _Tp... _Idx>
+    struct integer_sequence
+    {
+      typedef _Tp value_type;
+      static constexpr size_t size() { return sizeof...(_Idx); }
+    };
+
+  template<typename _Tp, _Tp _Num,
+    typename _ISeq = typename _Build_index_tuple<_Num>::__type>
+    struct _Make_integer_sequence;
+
+  template<typename _Tp, _Tp _Num, size_t... _Idx>
+    struct _Make_integer_sequence<_Tp, _Num, _Index_tuple<_Idx...>>
+    {
+      static_assert( _Num >= 0,
+       "Cannot make integer sequence of negative length" );
+
+      typedef integer_sequence<_Tp, static_cast<_Tp>(_Idx)...> __type;
+    };
+
+
+  template<typename _Tp, _Tp _Num>
+    using make_integer_sequence
+      = typename _Make_integer_sequence<_Tp, _Num>::__type;
+
+
+  template<size_t... _Idx>
+    using index_sequence = integer_sequence<size_t, _Idx...>;
+
+
+  template<size_t _Num>
+    using make_index_sequence = make_integer_sequence<size_t, _Num>;
+
+
+  template<typename... _Types>
+    using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+
+
+
+}
+# 986 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qcompilerdetection.h" 2
+# 1 "../../include/QtCore/qcompilerdetection.h" 2
+# 81 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 91 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/algorithm" 1 3
+# 58 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/algorithm" 3
+       
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/algorithm" 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 1 3
+# 60 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/functexcept.h" 1 3
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/functexcept.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/exception_defines.h" 1 3
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/functexcept.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  void
+  __throw_bad_exception(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_alloc(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_cast(void) __attribute__((__noreturn__));
+
+  void
+  __throw_bad_typeid(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_logic_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_domain_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_length_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_out_of_range(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__))
+    __attribute__((__format__(__gnu_printf__, 1, 2)));
+
+  void
+  __throw_runtime_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_range_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_overflow_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_underflow_error(const char*) __attribute__((__noreturn__));
+
+
+  void
+  __throw_ios_failure(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_system_error(int) __attribute__((__noreturn__));
+
+  void
+  __throw_future_error(int) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_function_call() __attribute__((__noreturn__));
+
+
+}
+# 61 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/cpp_type_traits.h" 1 3
+# 35 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/cpp_type_traits.h" 3
+       
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/cpp_type_traits.h" 3
+# 68 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    };
+# 287 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/cpp_type_traits.h" 3
+  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_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;
+    };
+
+
+
+}
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/type_traits.h" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/type_traits.h" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+
+
+  inline bool
+  __is_null_pointer(std::nullptr_t)
+  { return true; }
+
+
+
+  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;
+    };
+
+
+}
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/numeric_traits.h" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/numeric_traits.h" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/numeric_traits.h" 3
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+# 54 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 : 113) * 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 : 33);
+      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
+    { };
+
+
+}
+# 64 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 2 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator_base_types.h" 1 3
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator_base_types.h" 3
+       
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator_base_types.h" 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 89 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator_base_types.h" 3
+  struct input_iterator_tag { };
+
+
+  struct output_iterator_tag { };
+
+
+  struct forward_iterator_tag : public input_iterator_tag { };
+
+
+
+  struct bidirectional_iterator_tag : public forward_iterator_tag { };
+
+
+
+  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
+# 116 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator_base_types.h" 3
+  template<typename _Iterator, typename = __void_t<>>
+    struct __iterator_traits { };
+
+  template<typename _Iterator>
+    struct __iterator_traits<_Iterator,
+        __void_t<typename _Iterator::iterator_category,
+          typename _Iterator::value_type,
+          typename _Iterator::difference_type,
+          typename _Iterator::pointer,
+          typename _Iterator::reference>>
+    {
+      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> { };
+# 177 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(); }
+    };
+
+
+  template<typename _InIter>
+    using _RequireInputIter = typename
+      enable_if<is_convertible<typename
+  iterator_traits<_InIter>::iterator_category,
+          input_iterator_tag>::value>::type;
+
+
+
+}
+# 66 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator_base_funcs.h" 1 3
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator_base_funcs.h" 3
+       
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator_base_funcs.h" 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/debug/debug.h" 1 3
+# 46 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/debug/debug.h" 3
+namespace std
+{
+  namespace __debug { }
+}
+
+
+
+
+namespace __gnu_debug
+{
+  using namespace std::__debug;
+}
+# 66 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator_base_funcs.h" 2 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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 171 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+
+
+
+
+}
+# 67 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator.h" 1 3
+# 66 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ptr_traits.h" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ptr_traits.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+template<typename _Tp, typename = __void_t<>> struct __has_element_type : false_type { }; template<typename _Tp> struct __has_element_type<_Tp, __void_t<typename _Tp::element_type>> : true_type { };
+template<typename _Tp, typename = __void_t<>> struct __has_difference_type : false_type { }; template<typename _Tp> struct __has_difference_type<_Tp, __void_t<typename _Tp::difference_type>> : true_type { };
+
+  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 true_type
+ _S_chk(typename _Ptr2::template rebind<_Up2>*);
+
+      template<typename, typename>
+ static constexpr false_type
+ _S_chk(...);
+
+    public:
+      using __type = decltype(_S_chk<_Ptr, _Up>(nullptr));
+    };
+
+  template<typename _Tp, typename _Up,
+           bool = __ptrtr_rebind_helper<_Tp, _Up>::__type::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); }
+    };
+
+
+}
+# 67 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 96 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+# 160 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator.h" 3
+      reference
+      operator*() const
+      {
+ _Iterator __tmp = current;
+ return *--__tmp;
+      }
+
+
+
+
+
+
+      pointer
+      operator->() const
+      { return &(operator*()); }
+
+
+
+
+
+
+      reverse_iterator&
+      operator++()
+      {
+ --current;
+ return *this;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator++(int)
+      {
+ reverse_iterator __tmp = *this;
+ --current;
+ return __tmp;
+      }
+
+
+
+
+
+
+      reverse_iterator&
+      operator--()
+      {
+ ++current;
+ return *this;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator--(int)
+      {
+ reverse_iterator __tmp = *this;
+ ++current;
+ return __tmp;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator+(difference_type __n) const
+      { return reverse_iterator(current - __n); }
+
+
+
+
+
+
+
+      reverse_iterator&
+      operator+=(difference_type __n)
+      {
+ current -= __n;
+ return *this;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator-(difference_type __n) const
+      { return reverse_iterator(current + __n); }
+
+
+
+
+
+
+
+      reverse_iterator&
+      operator-=(difference_type __n)
+      {
+ current += __n;
+ return *this;
+      }
+
+
+
+
+
+
+      reference
+      operator[](difference_type __n) const
+      { return *(*this + __n); }
+    };
+# 290 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(); }
+# 397 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    inline reverse_iterator<_Iterator>
+    make_reverse_iterator(_Iterator __i)
+    { return reverse_iterator<_Iterator>(__i); }
+# 414 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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) { }
+# 448 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+    };
+# 490 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator.h" 3
+  template<typename _Container>
+    inline back_insert_iterator<_Container>
+    back_inserter(_Container& __x)
+    { return back_insert_iterator<_Container>(__x); }
+# 505 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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) { }
+# 538 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+    };
+# 580 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator.h" 3
+  template<typename _Container>
+    inline front_insert_iterator<_Container>
+    front_inserter(_Container& __x)
+    { return front_insert_iterator<_Container>(__x); }
+# 599 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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) {}
+# 650 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+    };
+# 694 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator.h" 3
+  template<typename _Container, typename _Iterator>
+    inline insert_iterator<_Container>
+    inserter(_Container& __x, _Iterator __i)
+    {
+      return insert_iterator<_Container>(__x,
+      typename _Container::iterator(__i));
+    }
+
+
+
+
+}
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+# 718 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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() noexcept
+      : _M_current(_Iterator()) { }
+
+      explicit
+      __normal_iterator(const _Iterator& __i) noexcept
+      : _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) noexcept
+        : _M_current(__i.base()) { }
+
+
+      reference
+      operator*() const noexcept
+      { return *_M_current; }
+
+      pointer
+      operator->() const noexcept
+      { return _M_current; }
+
+      __normal_iterator&
+      operator++() noexcept
+      {
+ ++_M_current;
+ return *this;
+      }
+
+      __normal_iterator
+      operator++(int) noexcept
+      { return __normal_iterator(_M_current++); }
+
+
+      __normal_iterator&
+      operator--() noexcept
+      {
+ --_M_current;
+ return *this;
+      }
+
+      __normal_iterator
+      operator--(int) noexcept
+      { return __normal_iterator(_M_current--); }
+
+
+      reference
+      operator[](difference_type __n) const noexcept
+      { return _M_current[__n]; }
+
+      __normal_iterator&
+      operator+=(difference_type __n) noexcept
+      { _M_current += __n; return *this; }
+
+      __normal_iterator
+      operator+(difference_type __n) const noexcept
+      { return __normal_iterator(_M_current + __n); }
+
+      __normal_iterator&
+      operator-=(difference_type __n) noexcept
+      { _M_current -= __n; return *this; }
+
+      __normal_iterator
+      operator-(difference_type __n) const noexcept
+      { return __normal_iterator(_M_current - __n); }
+
+      const _Iterator&
+      base() const noexcept
+      { return _M_current; }
+    };
+# 818 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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)
+    noexcept
+    { 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) noexcept
+    -> 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)
+    noexcept
+    { 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)
+    noexcept
+    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
+
+
+}
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 958 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    class move_iterator
+    {
+    protected:
+      _Iterator _M_current;
+
+      typedef iterator_traits<_Iterator> __traits_type;
+      typedef typename __traits_type::reference __base_ref;
+
+    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 typename conditional<is_reference<__base_ref>::value,
+    typename remove_reference<__base_ref>::type&&,
+    __base_ref>::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 static_cast<reference>(*_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); }
+
+
+
+
+}
+# 68 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 2 3
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/predefined_ops.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/predefined_ops.h" 3
+namespace __gnu_cxx
+{
+namespace __ops
+{
+  struct _Iter_less_iter
+  {
+    template<typename _Iterator1, typename _Iterator2>
+      constexpr
+      bool
+      operator()(_Iterator1 __it1, _Iterator2 __it2) const
+      { return *__it1 < *__it2; }
+  };
+  constexpr
+  inline _Iter_less_iter
+  __iter_less_iter()
+  { return _Iter_less_iter(); }
+
+  struct _Iter_less_val
+  {
+    template<typename _Iterator, typename _Value>
+      bool
+      operator()(_Iterator __it, _Value& __val) const
+      { return *__it < __val; }
+    };
+
+  inline _Iter_less_val
+  __iter_less_val()
+  { return _Iter_less_val(); }
+
+  inline _Iter_less_val
+  __iter_comp_val(_Iter_less_iter)
+  { return _Iter_less_val(); }
+
+  struct _Val_less_iter
+  {
+    template<typename _Value, typename _Iterator>
+      bool
+      operator()(_Value& __val, _Iterator __it) const
+      { return __val < *__it; }
+    };
+
+  inline _Val_less_iter
+  __val_less_iter()
+  { return _Val_less_iter(); }
+
+  inline _Val_less_iter
+  __val_comp_iter(_Iter_less_iter)
+  { return _Val_less_iter(); }
+
+  struct _Iter_equal_to_iter
+  {
+    template<typename _Iterator1, typename _Iterator2>
+      bool
+      operator()(_Iterator1 __it1, _Iterator2 __it2) const
+      { return *__it1 == *__it2; }
+    };
+
+  inline _Iter_equal_to_iter
+  __iter_equal_to_iter()
+  { return _Iter_equal_to_iter(); }
+
+  struct _Iter_equal_to_val
+  {
+    template<typename _Iterator, typename _Value>
+      bool
+      operator()(_Iterator __it, _Value& __val) const
+      { return *__it == __val; }
+    };
+
+  inline _Iter_equal_to_val
+  __iter_equal_to_val()
+  { return _Iter_equal_to_val(); }
+
+  inline _Iter_equal_to_val
+  __iter_comp_val(_Iter_equal_to_iter)
+  { return _Iter_equal_to_val(); }
+
+  template<typename _Compare>
+    struct _Iter_comp_iter
+    {
+      _Compare _M_comp;
+      constexpr
+      _Iter_comp_iter(_Compare __comp)
+ : _M_comp(__comp)
+      { }
+
+      template<typename _Iterator1, typename _Iterator2>
+        constexpr
+        bool
+        operator()(_Iterator1 __it1, _Iterator2 __it2)
+        { return bool(_M_comp(*__it1, *__it2)); }
+    };
+
+  template<typename _Compare>
+    constexpr
+    inline _Iter_comp_iter<_Compare>
+    __iter_comp_iter(_Compare __comp)
+    { return _Iter_comp_iter<_Compare>(__comp); }
+
+  template<typename _Compare>
+    struct _Iter_comp_val
+    {
+      _Compare _M_comp;
+
+      _Iter_comp_val(_Compare __comp)
+ : _M_comp(__comp)
+      { }
+
+      template<typename _Iterator, typename _Value>
+ bool
+ operator()(_Iterator __it, _Value& __val)
+ { return bool(_M_comp(*__it, __val)); }
+    };
+
+  template<typename _Compare>
+   inline _Iter_comp_val<_Compare>
+    __iter_comp_val(_Compare __comp)
+    { return _Iter_comp_val<_Compare>(__comp); }
+
+  template<typename _Compare>
+    inline _Iter_comp_val<_Compare>
+    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
+    { return _Iter_comp_val<_Compare>(__comp._M_comp); }
+
+  template<typename _Compare>
+    struct _Val_comp_iter
+    {
+      _Compare _M_comp;
+
+      _Val_comp_iter(_Compare __comp)
+ : _M_comp(__comp)
+      { }
+
+      template<typename _Value, typename _Iterator>
+ bool
+ operator()(_Value& __val, _Iterator __it)
+ { return bool(_M_comp(__val, *__it)); }
+    };
+
+  template<typename _Compare>
+    inline _Val_comp_iter<_Compare>
+    __val_comp_iter(_Compare __comp)
+    { return _Val_comp_iter<_Compare>(__comp); }
+
+  template<typename _Compare>
+    inline _Val_comp_iter<_Compare>
+    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
+    { return _Val_comp_iter<_Compare>(__comp._M_comp); }
+
+  template<typename _Value>
+    struct _Iter_equals_val
+    {
+      _Value& _M_value;
+
+      _Iter_equals_val(_Value& __value)
+ : _M_value(__value)
+      { }
+
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return *__it == _M_value; }
+    };
+
+  template<typename _Value>
+    inline _Iter_equals_val<_Value>
+    __iter_equals_val(_Value& __val)
+    { return _Iter_equals_val<_Value>(__val); }
+
+  template<typename _Iterator1>
+    struct _Iter_equals_iter
+    {
+      typename std::iterator_traits<_Iterator1>::reference _M_ref;
+
+      _Iter_equals_iter(_Iterator1 __it1)
+ : _M_ref(*__it1)
+      { }
+
+      template<typename _Iterator2>
+ bool
+ operator()(_Iterator2 __it2)
+ { return *__it2 == _M_ref; }
+    };
+
+  template<typename _Iterator>
+    inline _Iter_equals_iter<_Iterator>
+    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
+    { return _Iter_equals_iter<_Iterator>(__it); }
+
+  template<typename _Predicate>
+    struct _Iter_pred
+    {
+      _Predicate _M_pred;
+
+      _Iter_pred(_Predicate __pred)
+ : _M_pred(__pred)
+      { }
+
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return bool(_M_pred(*__it)); }
+    };
+
+  template<typename _Predicate>
+    inline _Iter_pred<_Predicate>
+    __pred_iter(_Predicate __pred)
+    { return _Iter_pred<_Predicate>(__pred); }
+
+  template<typename _Compare, typename _Value>
+    struct _Iter_comp_to_val
+    {
+      _Compare _M_comp;
+      _Value& _M_value;
+
+      _Iter_comp_to_val(_Compare __comp, _Value& __value)
+ : _M_comp(__comp), _M_value(__value)
+      { }
+
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return bool(_M_comp(*__it, _M_value)); }
+    };
+
+  template<typename _Compare, typename _Value>
+    _Iter_comp_to_val<_Compare, _Value>
+    __iter_comp_val(_Compare __comp, _Value &__val)
+    { return _Iter_comp_to_val<_Compare, _Value>(__comp, __val); }
+
+  template<typename _Compare, typename _Iterator1>
+    struct _Iter_comp_to_iter
+    {
+      _Compare _M_comp;
+      typename std::iterator_traits<_Iterator1>::reference _M_ref;
+
+      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
+ : _M_comp(__comp), _M_ref(*__it1)
+      { }
+
+      template<typename _Iterator2>
+ bool
+ operator()(_Iterator2 __it2)
+ { return bool(_M_comp(*__it2, _M_ref)); }
+    };
+
+  template<typename _Compare, typename _Iterator>
+    inline _Iter_comp_to_iter<_Compare, _Iterator>
+    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
+    { return _Iter_comp_to_iter<_Compare, _Iterator>(__comp._M_comp, __it); }
+
+  template<typename _Predicate>
+    struct _Iter_negate
+    {
+      _Predicate _M_pred;
+
+      _Iter_negate(_Predicate __pred)
+ : _M_pred(__pred)
+      { }
+
+      template<typename _Iterator>
+ bool
+ operator()(_Iterator __it)
+ { return !bool(_M_pred(*__it)); }
+    };
+
+  template<typename _Predicate>
+    inline _Iter_negate<_Predicate>
+    __negate(_Iter_pred<_Predicate> __pred)
+    { return _Iter_negate<_Predicate>(__pred._M_pred); }
+
+}
+}
+# 72 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 118 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline void
+    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+    {
+
+     
+
+     
+# 148 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+      swap(*__a, *__b);
+
+    }
+# 164 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator2
+    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+  _ForwardIterator2 __first2)
+    {
+
+     
+
+     
+
+      ;
+
+      for (; __first1 != __last1; ++__first1, ++__first2)
+ std::iter_swap(__first1, __first2);
+      return __first2;
+    }
+# 192 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _Tp>
+    constexpr
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b)
+    {
+
+     
+
+      if (__b < __a)
+ return __b;
+      return __a;
+    }
+# 216 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _Tp>
+    constexpr
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b)
+    {
+
+     
+
+      if (__a < __b)
+ return __b;
+      return __a;
+    }
+# 240 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+
+      if (__comp(__b, __a))
+ return __b;
+      return __a;
+    }
+# 262 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _Tp, typename _Compare>
+    constexpr
+    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)
+        {
+
+
+   static_assert( is_copy_assignable<_Tp>::value,
+                  "type is not assignable" );
+
+   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)));
+    }
+# 458 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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));
+    }
+# 491 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+        {
+
+
+   static_assert( is_copy_assignable<_Tp>::value,
+                  "type is not assignable" );
+
+   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)));
+    }
+# 632 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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));
+    }
+# 668 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+      if (const size_t __len = __last - __first)
+ __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
+    }
+# 734 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 794 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+        {
+   if (const size_t __len = (__last1 - __first1))
+     return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) * __len);
+   return true;
+ }
+    };
+
+  template<typename _II1, typename _II2>
+    inline bool
+    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple = ((__is_integer<_ValueType1>::__value
+         || __is_pointer<_ValueType1>::__value)
+                      && __is_pointer<_II1>::__value
+                      && __is_pointer<_II2>::__value
+        && __are_same<_ValueType1, _ValueType2>::__value);
+
+      return std::__equal<__simple>::equal(__first1, __last1, __first2);
+    }
+
+  template<typename, typename>
+    struct __lc_rai
+    {
+      template<typename _II1, typename _II2>
+        static _II1
+        __newlast1(_II1, _II1 __last1, _II2, _II2)
+        { return __last1; }
+
+      template<typename _II>
+        static bool
+        __cnd2(_II __first, _II __last)
+        { return __first != __last; }
+    };
+
+  template<>
+    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
+    {
+      template<typename _RAI1, typename _RAI2>
+        static _RAI1
+        __newlast1(_RAI1 __first1, _RAI1 __last1,
+     _RAI2 __first2, _RAI2 __last2)
+        {
+   const typename iterator_traits<_RAI1>::difference_type
+     __diff1 = __last1 - __first1;
+   const typename iterator_traits<_RAI2>::difference_type
+     __diff2 = __last2 - __first2;
+   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
+ }
+
+      template<typename _RAI>
+        static bool
+        __cnd2(_RAI, _RAI)
+        { return true; }
+    };
+
+  template<typename _II1, typename _II2, typename _Compare>
+    bool
+    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_II1>::iterator_category _Category1;
+      typedef typename iterator_traits<_II2>::iterator_category _Category2;
+      typedef std::__lc_rai<_Category1, _Category2> __rai_type;
+
+      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
+      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
+    ++__first1, ++__first2)
+ {
+   if (__comp(__first1, __first2))
+     return true;
+   if (__comp(__first2, __first1))
+     return false;
+ }
+      return __first1 == __last1 && __first2 != __last2;
+    }
+
+  template<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)
+      {
+ return std::__lexicographical_compare_impl(__first1, __last1,
+         __first2, __last2,
+     __gnu_cxx::__ops::__iter_less_iter());
+      }
+
+  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;
+   if (const size_t __len = std::min(__len1, __len2))
+     if (int __result = __builtin_memcmp(__first1, __first2, __len))
+       return __result < 0;
+   return __len1 < __len2;
+ }
+    };
+
+  template<typename _II1, typename _II2>
+    inline bool
+    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
+      _II2 __first2, _II2 __last2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple =
+ (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
+  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
+  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
+  && __is_pointer<_II1>::__value
+  && __is_pointer<_II2>::__value);
+
+      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
+           __first2, __last2);
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+# 994 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+
+      return std::__lower_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_less_val());
+    }
+
+
+
+  inline constexpr int
+  __lg(int __n)
+  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+
+  inline constexpr unsigned
+  __lg(unsigned __n)
+  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+
+  inline constexpr long
+  __lg(long __n)
+  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+
+  inline constexpr unsigned long
+  __lg(unsigned long __n)
+  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+
+  inline constexpr long long
+  __lg(long long __n)
+  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+
+  inline constexpr unsigned long long
+  __lg(unsigned long long __n)
+  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+
+
+
+
+# 1051 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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));
+    }
+# 1083 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 1116 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      using _RATag = random_access_iterator_tag;
+      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
+      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
+      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
+      if (_RAIters())
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+   return std::equal(__first1, __last1, __first2);
+ }
+
+      for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
+ if (!(*__first1 == *__first2))
+   return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+# 1164 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+   _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+      ;
+      ;
+
+      using _RATag = random_access_iterator_tag;
+      using _Cat1 = typename iterator_traits<_IIter1>::iterator_category;
+      using _Cat2 = typename iterator_traits<_IIter2>::iterator_category;
+      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
+      if (_RAIters())
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+   return std::equal(__first1, __last1, __first2,
+           __binary_pred);
+ }
+
+      for (; __first1 != __last1 && __first2 != __last2; ++__first1, ++__first2)
+ if (!bool(__binary_pred(*__first1, *__first2)))
+   return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+# 1211 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2)
+    {
+
+
+
+
+
+     
+     
+     
+     
+      ;
+      ;
+
+      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
+      std::__niter_base(__last1),
+      std::__niter_base(__first2),
+      std::__niter_base(__last2));
+    }
+# 1247 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2, typename _Compare>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2, _Compare __comp)
+    {
+
+     
+     
+      ;
+      ;
+
+      return std::__lexicographical_compare_impl
+ (__first1, __last1, __first2, __last2,
+  __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+      while (__first1 != __last1 && __binary_pred(__first1, __first2))
+        {
+   ++__first1;
+   ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+# 1290 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__mismatch(__first1, __last1, __first2,
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 1323 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+      ;
+
+      return std::__mismatch(__first1, __last1, __first2,
+ __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _BinaryPredicate __binary_pred)
+    {
+      while (__first1 != __last1 && __first2 != __last2
+      && __binary_pred(__first1, __first2))
+        {
+   ++__first1;
+   ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+# 1370 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__mismatch(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 1405 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    inline pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2,
+      _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+      ;
+      ;
+
+      return std::__mismatch(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+
+
+}
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/algorithm" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 1 3
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+# 72 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+# 1 "/mnt/odroid-c2/usr/include/stdlib.h" 1 3 4
+# 32 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 33 "/mnt/odroid-c2/usr/include/stdlib.h" 2 3 4
+
+extern "C" {
+
+
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/waitflags.h" 1 3 4
+# 50 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/waitflags.h" 3 4
+typedef enum
+{
+  P_ALL,
+  P_PID,
+  P_PGID
+} idtype_t;
+# 42 "/mnt/odroid-c2/usr/include/stdlib.h" 2 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/waitstatus.h" 1 3 4
+# 64 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/waitstatus.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/endian.h" 1 3 4
+# 36 "/mnt/odroid-c2/usr/include/endian.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/endian.h" 1 3 4
+# 37 "/mnt/odroid-c2/usr/include/endian.h" 2 3 4
+# 60 "/mnt/odroid-c2/usr/include/endian.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/byteswap.h" 1 3 4
+# 27 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/byteswap.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/types.h" 1 3 4
+# 27 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/types.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4
+# 28 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/types.h" 2 3 4
+
+
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+
+
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+
+typedef signed long int __int64_t;
+typedef unsigned long int __uint64_t;
+
+
+
+
+
+
+
+typedef long int __quad_t;
+typedef unsigned long int __u_quad_t;
+# 121 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/types.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/typesizes.h" 1 3 4
+# 122 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/types.h" 2 3 4
+
+
+typedef unsigned long int __dev_t;
+typedef unsigned int __uid_t;
+typedef unsigned int __gid_t;
+typedef unsigned long int __ino_t;
+typedef unsigned long int __ino64_t;
+typedef unsigned int __mode_t;
+typedef unsigned int __nlink_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef int __pid_t;
+typedef struct { int __val[2]; } __fsid_t;
+typedef long int __clock_t;
+typedef unsigned long int __rlim_t;
+typedef unsigned long int __rlim64_t;
+typedef unsigned int __id_t;
+typedef long int __time_t;
+typedef unsigned int __useconds_t;
+typedef long int __suseconds_t;
+
+typedef int __daddr_t;
+typedef int __key_t;
+
+
+typedef int __clockid_t;
+
+
+typedef void * __timer_t;
+
+
+typedef int __blksize_t;
+
+
+
+
+typedef long int __blkcnt_t;
+typedef long int __blkcnt64_t;
+
+
+typedef unsigned long int __fsblkcnt_t;
+typedef unsigned long int __fsblkcnt64_t;
+
+
+typedef unsigned long int __fsfilcnt_t;
+typedef unsigned long int __fsfilcnt64_t;
+
+
+typedef long int __fsword_t;
+
+typedef long int __ssize_t;
+
+
+typedef long int __syscall_slong_t;
+
+typedef unsigned long int __syscall_ulong_t;
+
+
+
+typedef __off64_t __loff_t;
+typedef __quad_t *__qaddr_t;
+typedef char *__caddr_t;
+
+
+typedef long int __intptr_t;
+
+
+typedef unsigned int __socklen_t;
+# 28 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/byteswap.h" 2 3 4
+
+
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/byteswap-16.h" 1 3 4
+# 35 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/byteswap.h" 2 3 4
+# 43 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/byteswap.h" 3 4
+static __inline unsigned int
+__bswap_32 (unsigned int __bsx)
+{
+  return __builtin_bswap32 (__bsx);
+}
+# 74 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/byteswap.h" 3 4
+static __inline __uint64_t
+__bswap_64 (__uint64_t __bsx)
+{
+  return __builtin_bswap64 (__bsx);
+}
+# 61 "/mnt/odroid-c2/usr/include/endian.h" 2 3 4
+# 65 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/waitstatus.h" 2 3 4
+
+union wait
+  {
+    int w_status;
+    struct
+      {
+
+ unsigned int __w_termsig:7;
+ unsigned int __w_coredump:1;
+ unsigned int __w_retcode:8;
+ unsigned int:16;
+
+
+
+
+
+
+
+      } __wait_terminated;
+    struct
+      {
+
+ unsigned int __w_stopval:8;
+ unsigned int __w_stopsig:8;
+ unsigned int:16;
+
+
+
+
+
+
+      } __wait_stopped;
+  };
+# 43 "/mnt/odroid-c2/usr/include/stdlib.h" 2 3 4
+# 95 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+
+
+typedef struct
+  {
+    int quot;
+    int rem;
+  } div_t;
+
+
+
+typedef struct
+  {
+    long int quot;
+    long int rem;
+  } ldiv_t;
+
+
+
+
+
+
+
+__extension__ typedef struct
+  {
+    long long int quot;
+    long long int rem;
+  } lldiv_t;
+
+
+# 139 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern size_t __ctype_get_mb_cur_max (void) throw () ;
+
+
+
+
+extern double atof (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern int atoi (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern long int atol (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+__extension__ extern long long int atoll (const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+extern double strtod (const char *__restrict __nptr,
+        char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern float strtof (const char *__restrict __nptr,
+       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
+
+extern long double strtold (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern long int strtol (const char *__restrict __nptr,
+   char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern unsigned long int strtoul (const char *__restrict __nptr,
+      char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+__extension__
+extern long long int strtoq (const char *__restrict __nptr,
+        char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtouq (const char *__restrict __nptr,
+           char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+__extension__
+extern long long int strtoll (const char *__restrict __nptr,
+         char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtoull (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+# 235 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/xlocale.h" 1 3 4
+# 27 "/mnt/odroid-c2/usr/include/xlocale.h" 3 4
+typedef struct __locale_struct
+{
+
+  struct __locale_data *__locales[13];
+
+
+  const unsigned short int *__ctype_b;
+  const int *__ctype_tolower;
+  const int *__ctype_toupper;
+
+
+  const char *__names[13];
+} *__locale_t;
+
+
+typedef __locale_t locale_t;
+# 236 "/mnt/odroid-c2/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__)) 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);
+}
+
+# 305 "/mnt/odroid-c2/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 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 1 3 4
+# 27 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 3 4
+extern "C" {
+
+
+
+
+
+typedef __u_char u_char;
+typedef __u_short u_short;
+typedef __u_int u_int;
+typedef __u_long u_long;
+typedef __quad_t quad_t;
+typedef __u_quad_t u_quad_t;
+typedef __fsid_t fsid_t;
+
+
+
+
+typedef __loff_t loff_t;
+
+
+
+typedef __ino_t ino_t;
+
+
+
+
+
+
+typedef __ino64_t ino64_t;
+
+
+
+
+typedef __dev_t dev_t;
+
+
+
+
+typedef __gid_t gid_t;
+
+
+
+
+typedef __mode_t mode_t;
+
+
+
+
+typedef __nlink_t nlink_t;
+
+
+
+
+typedef __uid_t uid_t;
+
+
+
+
+
+typedef __off_t off_t;
+
+
+
+
+
+
+typedef __off64_t off64_t;
+
+
+
+
+typedef __pid_t pid_t;
+
+
+
+
+
+typedef __id_t id_t;
+
+
+
+
+typedef __ssize_t ssize_t;
+
+
+
+
+
+typedef __daddr_t daddr_t;
+typedef __caddr_t caddr_t;
+
+
+
+
+
+typedef __key_t key_t;
+# 132 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/time.h" 1 3 4
+# 57 "/mnt/odroid-c2/usr/include/time.h" 3 4
+
+
+typedef __clock_t clock_t;
+
+
+
+# 73 "/mnt/odroid-c2/usr/include/time.h" 3 4
+
+
+typedef __time_t time_t;
+
+
+
+# 91 "/mnt/odroid-c2/usr/include/time.h" 3 4
+typedef __clockid_t clockid_t;
+# 103 "/mnt/odroid-c2/usr/include/time.h" 3 4
+typedef __timer_t timer_t;
+# 133 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4
+
+
+
+typedef __useconds_t useconds_t;
+
+
+
+typedef __suseconds_t suseconds_t;
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 147 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4
+
+
+
+typedef unsigned long int ulong;
+typedef unsigned short int ushort;
+typedef unsigned int uint;
+# 194 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 3 4
+typedef int int8_t __attribute__ ((__mode__ (__QI__)));
+typedef int int16_t __attribute__ ((__mode__ (__HI__)));
+typedef int int32_t __attribute__ ((__mode__ (__SI__)));
+typedef int int64_t __attribute__ ((__mode__ (__DI__)));
+
+
+typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
+typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
+typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
+typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
+
+typedef int register_t __attribute__ ((__mode__ (__word__)));
+# 219 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 1 3 4
+# 30 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/select.h" 1 3 4
+# 31 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 2 3 4
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/sigset.h" 1 3 4
+# 22 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/sigset.h" 3 4
+typedef int __sig_atomic_t;
+
+
+
+
+typedef struct
+  {
+    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
+  } __sigset_t;
+# 34 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 2 3 4
+
+
+
+typedef __sigset_t sigset_t;
+
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/time.h" 1 3 4
+# 120 "/mnt/odroid-c2/usr/include/time.h" 3 4
+struct timespec
+  {
+    __time_t tv_sec;
+    __syscall_slong_t tv_nsec;
+  };
+# 44 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 2 3 4
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/time.h" 1 3 4
+# 30 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/time.h" 3 4
+struct timeval
+  {
+    __time_t tv_sec;
+    __suseconds_t tv_usec;
+  };
+# 46 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 2 3 4
+# 54 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 3 4
+typedef long int __fd_mask;
+# 64 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 3 4
+typedef struct
+  {
+
+
+
+    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
+
+
+
+
+
+  } fd_set;
+
+
+
+
+
+
+typedef __fd_mask fd_mask;
+# 96 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 3 4
+extern "C" {
+# 106 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 3 4
+extern int select (int __nfds, fd_set *__restrict __readfds,
+     fd_set *__restrict __writefds,
+     fd_set *__restrict __exceptfds,
+     struct timeval *__restrict __timeout);
+# 118 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 3 4
+extern int pselect (int __nfds, fd_set *__restrict __readfds,
+      fd_set *__restrict __writefds,
+      fd_set *__restrict __exceptfds,
+      const struct timespec *__restrict __timeout,
+      const __sigset_t *__restrict __sigmask);
+# 131 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/select.h" 3 4
+}
+# 220 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/sysmacros.h" 1 3 4
+# 24 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/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));
+}
+
+}
+# 223 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4
+
+
+
+
+
+typedef __blksize_t blksize_t;
+
+
+
+
+
+
+typedef __blkcnt_t blkcnt_t;
+
+
+
+typedef __fsblkcnt_t fsblkcnt_t;
+
+
+
+typedef __fsfilcnt_t fsfilcnt_t;
+# 262 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 3 4
+typedef __blkcnt64_t blkcnt64_t;
+typedef __fsblkcnt64_t fsblkcnt64_t;
+typedef __fsfilcnt64_t fsfilcnt64_t;
+
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/pthreadtypes.h" 1 3 4
+# 38 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/pthreadtypes.h" 3 4
+typedef unsigned long int pthread_t;
+
+
+union pthread_attr_t
+{
+  char __size[64];
+  long int __align;
+};
+
+typedef union pthread_attr_t pthread_attr_t;
+
+
+
+typedef struct __pthread_internal_list
+{
+  struct __pthread_internal_list *__prev;
+  struct __pthread_internal_list *__next;
+} __pthread_list_t;
+
+
+
+
+typedef union
+{
+  struct __pthread_mutex_s
+  {
+    int __lock;
+    unsigned int __count;
+    int __owner;
+    unsigned int __nusers;
+    int __kind;
+    int __spins;
+    __pthread_list_t __list;
+
+  } __data;
+  char __size[48];
+  long int __align;
+} pthread_mutex_t;
+
+
+
+
+typedef union
+{
+  char __size[8];
+  long 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];
+  long int __align;
+} pthread_cond_t;
+
+typedef union
+{
+  char __size[8];
+  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;
+  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[8];
+  int __align;
+} pthread_barrierattr_t;
+# 271 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/sys/types.h" 2 3 4
+
+
+}
+# 315 "/mnt/odroid-c2/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+
+extern long int random (void) throw ();
+
+
+extern void srandom (unsigned int __seed) throw ();
+
+
+
+
+
+extern char *initstate (unsigned int __seed, char *__statebuf,
+   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+struct random_data
+  {
+    int32_t *fptr;
+    int32_t *rptr;
+    int32_t *state;
+    int rand_type;
+    int rand_deg;
+    int rand_sep;
+    int32_t *end_ptr;
+  };
+
+extern int random_r (struct random_data *__restrict __buf,
+       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int srandom_r (unsigned int __seed, struct random_data *__buf)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
+   size_t __statelen,
+   struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (2, 4)));
+
+extern int setstate_r (char *__restrict __statebuf,
+         struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern int rand (void) throw ();
+
+extern void srand (unsigned int __seed) throw ();
+
+
+
+
+extern int rand_r (unsigned int *__seed) throw ();
+
+
+
+
+
+
+
+extern double drand48 (void) throw ();
+extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int lrand48 (void) throw ();
+extern long int nrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int mrand48 (void) throw ();
+extern long int jrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern void srand48 (long int __seedval) throw ();
+extern unsigned short int *seed48 (unsigned short int __seed16v[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+struct drand48_data
+  {
+    unsigned short int __x[3];
+    unsigned short int __old_x[3];
+    unsigned short int __c;
+    unsigned short int __init;
+    __extension__ unsigned long long int __a;
+
+  };
+
+
+extern int drand48_r (struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int erand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int lrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int nrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int mrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int jrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+extern int seed48_r (unsigned short int __seed16v[3],
+       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int lcong48_r (unsigned short int __param[7],
+        struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+
+
+
+extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
+
+extern void *calloc (size_t __nmemb, size_t __size)
+     throw () __attribute__ ((__malloc__)) ;
+
+
+
+
+
+
+
+
+
+
+extern void *realloc (void *__ptr, size_t __size)
+     throw () __attribute__ ((__warn_unused_result__));
+
+extern void free (void *__ptr) throw ();
+
+
+
+
+extern void cfree (void *__ptr) throw ();
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/alloca.h" 1 3 4
+# 24 "/mnt/odroid-c2/usr/include/alloca.h" 3 4
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 25 "/mnt/odroid-c2/usr/include/alloca.h" 2 3 4
+
+extern "C" {
+
+
+
+
+
+extern void *alloca (size_t __size) throw ();
+
+
+
+
+
+}
+# 493 "/mnt/odroid-c2/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
+
+
+
+
+extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+extern void *aligned_alloc (size_t __alignment, size_t __size)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
+
+
+
+
+extern void abort (void) throw () __attribute__ ((__noreturn__));
+
+
+
+extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern "C++" int at_quick_exit (void (*__func) (void))
+     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+
+
+extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern void exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+extern char *secure_getenv (const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int setenv (const char *__name, const char *__value, int __replace)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int clearenv (void) throw ();
+# 606 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
+# 619 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
+# 629 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
+# 641 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
+# 651 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern int mkstemps64 (char *__template, int __suffixlen)
+     __attribute__ ((__nonnull__ (1))) ;
+# 662 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
+# 673 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+# 683 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+# 693 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern int mkostemps (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+# 705 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+
+
+
+extern int system (const char *__command) ;
+
+
+
+
+
+
+extern char *canonicalize_file_name (const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) ;
+# 733 "/mnt/odroid-c2/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))) ;
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/stdlib-bsearch.h" 1 3 4
+# 19 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/stdlib-bsearch.h" 3 4
+extern __inline __attribute__ ((__gnu_inline__)) void *
+bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
+  __compar_fn_t __compar)
+{
+  size_t __l, __u, __idx;
+  const void *__p;
+  int __comparison;
+
+  __l = 0;
+  __u = __nmemb;
+  while (__l < __u)
+    {
+      __idx = (__l + __u) / 2;
+      __p = (void *) (((const char *) __base) + (__idx * __size));
+      __comparison = (*__compar) (__key, __p);
+      if (__comparison < 0)
+ __u = __idx;
+      else if (__comparison > 0)
+ __l = __idx + 1;
+      else
+ return (void *) __p;
+    }
+
+  return __null;
+}
+# 760 "/mnt/odroid-c2/usr/include/stdlib.h" 2 3 4
+
+
+
+
+extern void qsort (void *__base, size_t __nmemb, size_t __size,
+     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
+
+extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
+       __compar_d_fn_t __compar, void *__arg)
+  __attribute__ ((__nonnull__ (1, 4)));
+
+
+
+
+extern int abs (int __x) throw () __attribute__ ((__const__)) ;
+extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
+
+
+
+__extension__ extern long long int llabs (long long int __x)
+     throw () __attribute__ ((__const__)) ;
+
+
+
+
+
+
+
+extern div_t div (int __numer, int __denom)
+     throw () __attribute__ ((__const__)) ;
+extern ldiv_t ldiv (long int __numer, long int __denom)
+     throw () __attribute__ ((__const__)) ;
+
+
+
+
+__extension__ extern lldiv_t lldiv (long long int __numer,
+        long long int __denom)
+     throw () __attribute__ ((__const__)) ;
+
+# 811 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *gcvt (double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern char *qecvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qfcvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qgcvt (long double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+
+extern int qecvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int qfcvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+
+
+
+
+
+
+extern int mblen (const char *__s, size_t __n) throw ();
+
+
+extern int mbtowc (wchar_t *__restrict __pwc,
+     const char *__restrict __s, size_t __n) throw ();
+
+
+extern int wctomb (char *__s, wchar_t __wchar) throw ();
+
+
+
+extern size_t mbstowcs (wchar_t *__restrict __pwcs,
+   const char *__restrict __s, size_t __n) throw ();
+
+extern size_t wcstombs (char *__restrict __s,
+   const wchar_t *__restrict __pwcs, size_t __n)
+     throw ();
+
+
+
+
+
+
+
+
+extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
+# 898 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+extern int getsubopt (char **__restrict __optionp,
+        char *const *__restrict __tokens,
+        char **__restrict __valuep)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
+
+
+
+
+
+extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int posix_openpt (int __oflag) ;
+
+
+
+
+
+
+
+extern int grantpt (int __fd) throw ();
+
+
+
+extern int unlockpt (int __fd) throw ();
+
+
+
+
+extern char *ptsname (int __fd) throw () ;
+
+
+
+
+
+
+extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int getpt (void);
+
+
+
+
+
+
+extern int getloadavg (double __loadavg[], int __nelem)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/stdlib-float.h" 1 3 4
+# 24 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/stdlib-float.h" 3 4
+
+extern __inline __attribute__ ((__gnu_inline__)) double
+__attribute__ ((__leaf__)) atof (const char *__nptr) throw ()
+{
+  return strtod (__nptr, (char **) __null);
+}
+
+# 955 "/mnt/odroid-c2/usr/include/stdlib.h" 2 3 4
+# 967 "/mnt/odroid-c2/usr/include/stdlib.h" 3 4
+}
+# 73 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 2 3
+# 114 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::div_t;
+  using ::ldiv_t;
+
+  using ::abort;
+  using ::abs;
+  using ::atexit;
+
+
+  using ::at_quick_exit;
+
+
+  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 ::quick_exit;
+
+
+  using ::rand;
+  using ::realloc;
+  using ::srand;
+  using ::strtod;
+  using ::strtol;
+  using ::strtoul;
+  using ::system;
+
+  using ::wcstombs;
+  using ::wctomb;
+
+
+
+  inline long
+  abs(long __i) { return __builtin_labs(__i); }
+
+  inline ldiv_t
+  div(long __i, long __j) { return ldiv(__i, __j); }
+
+
+
+  inline long long
+  abs(long long __x) { return __builtin_llabs (__x); }
+# 195 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+
+}
+# 209 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  using ::lldiv_t;
+
+
+
+
+
+  using ::_Exit;
+
+
+
+  using ::llabs;
+
+  inline lldiv_t
+  div(long long __n, long long __d)
+  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
+
+  using ::lldiv;
+# 241 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+  using ::atoll;
+  using ::strtoll;
+  using ::strtoull;
+
+  using ::strtof;
+  using ::strtold;
+
+
+}
+
+namespace std
+{
+
+  using ::__gnu_cxx::lldiv_t;
+
+  using ::__gnu_cxx::_Exit;
+
+  using ::__gnu_cxx::llabs;
+  using ::__gnu_cxx::div;
+  using ::__gnu_cxx::lldiv;
+
+  using ::__gnu_cxx::atoll;
+  using ::__gnu_cxx::strtof;
+  using ::__gnu_cxx::strtoll;
+  using ::__gnu_cxx::strtoull;
+  using ::__gnu_cxx::strtold;
+}
+# 60 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/algorithmfwd.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/algorithmfwd.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/algorithmfwd.h" 3
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/algorithmfwd.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 194 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>
+    constexpr
+    const _Tp&
+    max(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    max(const _Tp&, const _Tp&, _Compare);
+
+
+
+
+  template<typename _Tp>
+    constexpr
+    const _Tp&
+    min(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    const _Tp&
+    min(const _Tp&, const _Tp&, _Compare);
+
+
+
+
+  template<typename _Tp>
+    constexpr
+    pair<const _Tp&, const _Tp&>
+    minmax(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    pair<const _Tp&, const _Tp&>
+    minmax(const _Tp&, const _Tp&, _Compare);
+
+  template<typename _FIter>
+    constexpr
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    constexpr
+    pair<_FIter, _FIter>
+    minmax_element(_FIter, _FIter, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    _Tp
+    min(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    _Tp
+    min(initializer_list<_Tp>, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    _Tp
+    max(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    _Tp
+    max(initializer_list<_Tp>, _Compare);
+
+  template<typename _Tp>
+    constexpr
+    pair<_Tp, _Tp>
+    minmax(initializer_list<_Tp>);
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    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);
+
+  inline namespace _V2
+  {
+    template<typename _FIter>
+      _FIter
+      rotate(_FIter, _FIter, _FIter);
+  }
+
+  template<typename _FIter, typename _OIter>
+    _OIter
+    rotate_copy(_FIter, _FIter, _FIter, _OIter);
+# 552 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>
+    constexpr
+    _FIter
+    max_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    constexpr
+    _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>
+    constexpr
+    _FIter
+    min_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    constexpr
+    _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);
+
+
+}
+# 61 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_heap.h" 1 3
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_heap.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  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,
+   __gnu_cxx::__ops::__iter_less_iter()) == __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,
+ __gnu_cxx::__ops::__iter_comp_iter(__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,
+    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);
+    }
+# 148 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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),
+         __gnu_cxx::__ops::__iter_less_val());
+    }
+# 182 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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),
+         __gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+
+  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),
+         __gnu_cxx::__ops::__iter_comp_val(__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);
+    }
+# 261 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+
+     
+
+     
+      ;
+      ;
+      ;
+
+      if (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last,
+     __gnu_cxx::__ops::__iter_less_iter());
+ }
+    }
+# 295 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    pop_heap(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+      ;
+
+      if (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last,
+     __gnu_cxx::__ops::__iter_comp_iter(__comp));
+ }
+    }
+
+  template<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--;
+ }
+    }
+# 349 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+      std::__make_heap(__first, __last,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 374 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+
+     
+
+      ;
+
+      std::__make_heap(__first, __last,
+         __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  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);
+ }
+    }
+# 408 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      std::__sort_heap(__first, __last,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 434 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+
+      std::__sort_heap(__first, __last,
+         __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 460 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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),
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 487 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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),
+          __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 509 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::is_heap_until(__first, __last) == __last; }
+# 522 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+
+
+
+}
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tempbuf.h" 1 3
+# 60 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tempbuf.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_construct.h" 1 3
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_construct.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/new" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/new" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/new" 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/exception" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/exception" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/exception" 3
+
+#pragma GCC visibility push(default)
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_lockfree_defines.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_lockfree_defines.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_lockfree_defines.h" 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/exception" 2 3
+
+extern "C++" {
+
+namespace std
+{
+# 60 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+
+
+
+  terminate_handler get_terminate() noexcept;
+
+
+
+
+  void terminate() noexcept __attribute__ ((__noreturn__));
+
+
+  unexpected_handler set_unexpected(unexpected_handler) noexcept;
+
+
+
+  unexpected_handler get_unexpected() noexcept;
+
+
+
+
+  void unexpected() __attribute__ ((__noreturn__));
+# 127 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/exception" 3
+  bool uncaught_exception() noexcept __attribute__ ((__pure__));
+
+
+}
+
+namespace __gnu_cxx
+{
+
+# 152 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/exception" 3
+  void __verbose_terminate_handler();
+
+
+}
+
+}
+
+#pragma GCC visibility pop
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/exception_ptr.h" 1 3
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/exception_ptr.h" 3
+#pragma GCC visibility push(default)
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/exception_ptr.h" 3
+extern "C++" {
+
+namespace std
+{
+  class type_info;
+
+
+
+
+
+  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; }
+# 111 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+# 138 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 std::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
+    make_exception_ptr(_Ex __ex) noexcept
+    {
+
+      try
+ {
+   throw __ex;
+ }
+      catch(...)
+ {
+   return current_exception();
+ }
+
+
+
+    }
+
+
+
+
+
+  template<typename _Ex>
+    exception_ptr
+    copy_exception(_Ex __ex) noexcept __attribute__ ((__deprecated__));
+
+  template<typename _Ex>
+    exception_ptr
+    copy_exception(_Ex __ex) noexcept
+    { return std::make_exception_ptr<_Ex>(__ex); }
+
+
+}
+
+}
+
+#pragma GCC visibility pop
+# 163 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/exception" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/nested_exception.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/nested_exception.h" 3
+#pragma GCC visibility push(default)
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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&) noexcept = default;
+
+    nested_exception& operator=(const nested_exception&) noexcept = default;
+
+    virtual ~nested_exception() noexcept;
+
+    [[noreturn]]
+    void
+    rethrow_nested() const
+    {
+      if (_M_ptr)
+ rethrow_exception(_M_ptr);
+      std::terminate();
+    }
+
+    exception_ptr
+    nested_ptr() const noexcept
+    { return _M_ptr; }
+  };
+
+  template<typename _Except>
+    struct _Nested_exception : public _Except, public nested_exception
+    {
+      explicit _Nested_exception(const _Except& __ex)
+      : _Except(__ex)
+      { }
+
+      explicit _Nested_exception(_Except&& __ex)
+      : _Except(static_cast<_Except&&>(__ex))
+      { }
+    };
+
+  template<typename _Tp,
+    bool __with_nested = !__is_base_of(nested_exception, _Tp)>
+    struct _Throw_with_nested_impl
+    {
+      template<typename _Up>
+ static void _S_throw(_Up&& __t)
+ { throw _Nested_exception<_Tp>{static_cast<_Up&&>(__t)}; }
+    };
+
+  template<typename _Tp>
+    struct _Throw_with_nested_impl<_Tp, false>
+    {
+      template<typename _Up>
+ static void _S_throw(_Up&& __t)
+ { throw static_cast<_Up&&>(__t); }
+    };
+
+  template<typename _Tp, bool = __is_class(_Tp) && !__is_final(_Tp)>
+    struct _Throw_with_nested_helper : _Throw_with_nested_impl<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct _Throw_with_nested_helper<_Tp, false>
+    : _Throw_with_nested_impl<_Tp, false>
+    { };
+
+  template<typename _Tp>
+    struct _Throw_with_nested_helper<_Tp&, false>
+    : _Throw_with_nested_helper<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct _Throw_with_nested_helper<_Tp&&, false>
+    : _Throw_with_nested_helper<_Tp>
+    { };
+
+
+
+  template<typename _Tp>
+    [[noreturn]]
+    inline void
+    throw_with_nested(_Tp&& __t)
+    {
+      _Throw_with_nested_helper<_Tp>::_S_throw(static_cast<_Tp&&>(__t));
+    }
+
+  template<typename _Tp, bool = __is_polymorphic(_Tp)>
+    struct _Rethrow_if_nested_impl
+    {
+      static void _S_rethrow(const _Tp& __t)
+      {
+ if (auto __tp = dynamic_cast<const nested_exception*>(&__t))
+   __tp->rethrow_nested();
+      }
+    };
+
+  template<typename _Tp>
+    struct _Rethrow_if_nested_impl<_Tp, false>
+    {
+      static void _S_rethrow(const _Tp&) { }
+    };
+
+
+  template<typename _Ex>
+    inline void
+    rethrow_if_nested(const _Ex& __ex)
+    {
+      _Rethrow_if_nested_impl<_Ex>::_S_rethrow(__ex);
+    }
+
+
+}
+
+}
+
+
+
+#pragma GCC visibility pop
+# 164 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/exception" 2 3
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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();
+  };
+
+
+  class bad_array_new_length : public bad_alloc
+  {
+  public:
+    bad_array_new_length() throw() { };
+
+
+
+    virtual ~bad_array_new_length() 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();
+
+
+
+  new_handler get_new_handler() noexcept;
+
+}
+# 111 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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
+# 60 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_construct.h" 2 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/alloc_traits.h" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/alloc_traits.h" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/alloc_traits.h" 3
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 1 3
+# 35 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/memoryfwd.h" 1 3
+# 46 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/memoryfwd.h" 3
+       
+# 47 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/memoryfwd.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/memoryfwd.h" 3
+  template<typename>
+    class allocator;
+
+  template<>
+    class allocator<void>;
+
+
+  template<typename, typename>
+    struct uses_allocator;
+
+
+
+
+}
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 true_type
+ _S_chk(typename _Alloc2::template rebind<_Tp2>::other*);
+
+      template<typename, typename>
+ static constexpr false_type
+ _S_chk(...);
+
+    public:
+      using __type = decltype(_S_chk<_Alloc, _Tp>(nullptr));
+    };
+
+  template<typename _Alloc, typename _Tp,
+    bool = __alloctr_rebind_helper<_Alloc, _Tp>::__type::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, typename _Tp>
+    using __alloc_rebind = typename __alloctr_rebind<_Alloc, _Tp>::__type;
+
+
+
+
+
+  template<typename _Alloc>
+    struct allocator_traits
+    {
+
+      typedef _Alloc allocator_type;
+
+      typedef typename _Alloc::value_type value_type;
+# 98 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(_Tp*); static typename pointer_traits<pointer>::template rebind<const value_type> _S_const_pointer_helper(...); typedef decltype(_S_const_pointer_helper((_Alloc*)0)) __const_pointer; public:
+# 116 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+      typedef __const_pointer const_pointer;
+
+private: template<typename _Tp> static typename _Tp::void_pointer _S_void_pointer_helper(_Tp*); static typename pointer_traits<pointer>::template rebind<void> _S_void_pointer_helper(...); typedef decltype(_S_void_pointer_helper((_Alloc*)0)) __void_pointer; public:
+# 127 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(_Tp*); static typename pointer_traits<pointer>::template rebind<const void> _S_const_void_pointer_helper(...); typedef decltype(_S_const_void_pointer_helper((_Alloc*)0)) __const_void_pointer; public:
+# 138 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(_Tp*); static typename pointer_traits<pointer>::difference_type _S_difference_type_helper(...); typedef decltype(_S_difference_type_helper((_Alloc*)0)) __difference_type; public:
+# 149 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+      typedef __difference_type difference_type;
+
+private: template<typename _Tp> static typename _Tp::size_type _S_size_type_helper(_Tp*); static typename make_unsigned<difference_type>::type _S_size_type_helper(...); typedef decltype(_S_size_type_helper((_Alloc*)0)) __size_type; public:
+# 160 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(_Tp*); static false_type _S_propagate_on_container_copy_assignment_helper(...); typedef decltype(_S_propagate_on_container_copy_assignment_helper((_Alloc*)0)) __propagate_on_container_copy_assignment; public:
+# 171 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(_Tp*); static false_type _S_propagate_on_container_move_assignment_helper(...); typedef decltype(_S_propagate_on_container_move_assignment_helper((_Alloc*)0)) __propagate_on_container_move_assignment; public:
+# 183 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(_Tp*); static false_type _S_propagate_on_container_swap_helper(...); typedef decltype(_S_propagate_on_container_swap_helper((_Alloc*)0)) __propagate_on_container_swap; public:
+# 195 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(...);
+
+   using type = decltype(__test<_Alloc>(0));
+ };
+
+      template<typename _Alloc2>
+ using __has_allocate = typename __allocate_helper<_Alloc2>::type;
+
+      template<typename _Alloc2,
+        typename = _Require<__has_allocate<_Alloc2>>>
+ static pointer
+ _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint)
+ { return __a.allocate(__n, __hint); }
+
+      template<typename _Alloc2, typename _UnusedHint,
+        typename = _Require<__not_<__has_allocate<_Alloc2>>>>
+ static pointer
+ _S_allocate(_Alloc2& __a, size_type __n, _UnusedHint)
+ { 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(...);
+
+   using type = decltype(__test<_Alloc>(0));
+ };
+
+      template<typename _Tp, typename... _Args>
+ using __has_construct
+   = typename __construct_helper<_Tp, _Args...>::type;
+
+      template<typename _Tp, typename... _Args>
+ static _Require<__has_construct<_Tp, _Args...>>
+ _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ { __a.construct(__p, std::forward<_Args>(__args)...); }
+
+      template<typename _Tp, typename... _Args>
+ static
+ _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
+          is_constructible<_Tp, _Args...>>>
+ _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(...);
+
+   using type = decltype(__test<_Alloc>(0));
+ };
+
+      template<typename _Tp>
+ using __has_destroy = typename __destroy_helper<_Tp>::type;
+
+      template<typename _Tp>
+ static _Require<__has_destroy<_Tp>>
+ _S_destroy(_Alloc& __a, _Tp* __p)
+ { __a.destroy(__p); }
+
+      template<typename _Tp>
+ static _Require<__not_<__has_destroy<_Tp>>>
+ _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(...);
+
+   using type = decltype(__test<_Alloc2>(0));
+ };
+
+      template<typename _Alloc2>
+ using __has_max_size = typename __maxsize_helper<_Alloc2>::type;
+
+      template<typename _Alloc2,
+        typename = _Require<__has_max_size<_Alloc2>>>
+ static size_type
+ _S_max_size(_Alloc2& __a, int)
+ { return __a.max_size(); }
+
+      template<typename _Alloc2,
+        typename = _Require<__not_<__has_max_size<_Alloc2>>>>
+ static size_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(...);
+
+   using type = decltype(__test<_Alloc2>(0));
+ };
+
+      template<typename _Alloc2>
+ using __has_soccc = typename __select_helper<_Alloc2>::type;
+
+      template<typename _Alloc2,
+        typename = _Require<__has_soccc<_Alloc2>>>
+ static _Alloc2
+ _S_select(_Alloc2& __a, int)
+ { return __a.select_on_container_copy_construction(); }
+
+      template<typename _Alloc2,
+        typename = _Require<__not_<__has_soccc<_Alloc2>>>>
+ static _Alloc2
+ _S_select(_Alloc2& __a, ...)
+ { return __a; }
+
+    public:
+# 358 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+      static pointer
+      allocate(_Alloc& __a, size_type __n)
+      { return __a.allocate(__n); }
+# 373 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+      static pointer
+      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
+      { return _S_allocate(__a, __n, __hint); }
+# 385 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+      static void deallocate(_Alloc& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+# 399 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+      template<typename _Tp, typename... _Args>
+ static auto construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
+ { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
+# 412 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+      template <class _Tp>
+ static void destroy(_Alloc& __a, _Tp* __p)
+ { _S_destroy(__a, __p); }
+# 424 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+      static size_type max_size(const _Alloc& __a) noexcept
+      { return _S_max_size(__a, 0); }
+# 435 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/alloc_traits.h" 3
+      static _Alloc
+      select_on_container_copy_construction(const _Alloc& __rhs)
+      { return _S_select(__rhs, 0); }
+    };
+
+  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());
+    }
+
+  template<typename _Alloc>
+    class __is_copy_insertable_impl
+    {
+      typedef allocator_traits<_Alloc> _Traits;
+
+      template<typename _Up, typename
+        = decltype(_Traits::construct(std::declval<_Alloc&>(),
+          std::declval<_Up*>(),
+          std::declval<const _Up&>()))>
+ static true_type
+ _M_select(int);
+
+      template<typename _Up>
+ static false_type
+ _M_select(...);
+
+    public:
+      typedef decltype(_M_select<typename _Alloc::value_type>(0)) type;
+    };
+
+
+  template<typename _Alloc>
+    struct __is_copy_insertable
+    : __is_copy_insertable_impl<_Alloc>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_copy_insertable<allocator<_Tp>>
+    : is_copy_constructible<_Tp>
+    { };
+
+
+}
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/alloc_traits.h" 2 3
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Alloc>
+    struct __allocator_always_compares_equal : std::false_type { };
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<std::allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename, typename> struct array_allocator;
+
+  template<typename _Tp, typename _Array>
+    struct __allocator_always_compares_equal<array_allocator<_Tp, _Array>>
+    : std::true_type { };
+
+  template<typename> struct bitmap_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<bitmap_allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename> struct malloc_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<malloc_allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename> struct mt_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<mt_allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename> struct new_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<new_allocator<_Tp>>
+    : std::true_type { };
+
+  template<typename> struct pool_allocator;
+
+  template<typename _Tp>
+    struct __allocator_always_compares_equal<pool_allocator<_Tp>>
+    : std::true_type { };
+
+
+
+
+
+
+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 typename _Base_type::difference_type difference_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>
+      using __is_custom_pointer
+ = std::__and_<std::is_same<pointer, _Ptr>,
+        std::__not_<std::is_pointer<_Ptr>>>;
+
+  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; };
+# 210 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/alloc_traits.h" 3
+  };
+
+
+}
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)...); }
+# 90 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 _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);
+    }
+
+
+}
+# 61 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tempbuf.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 83 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+    }
+# 110 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer __first, _Pointer __last,
+       _ForwardIterator __seed)
+        {
+   if(__first == __last)
+     return;
+
+   _Pointer __cur = __first;
+   try
+     {
+       std::_Construct(std::__addressof(*__first),
+         std::move(*__seed));
+       _Pointer __prev = __cur;
+       ++__cur;
+       for(; __cur != __last; ++__cur, ++__prev)
+  std::_Construct(std::__addressof(*__cur),
+    std::move(*__prev));
+       *__seed = std::move(*__prev);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_construct_buf_dispatch<true>
+    {
+      template<typename _Pointer, typename _ForwardIterator>
+        static void
+        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
+    };
+# 229 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tempbuf.h" 3
+  template<typename _Pointer, typename _ForwardIterator>
+    inline void
+    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
+      _ForwardIterator __seed)
+    {
+      typedef typename std::iterator_traits<_Pointer>::value_type
+ _ValueType;
+
+      std::__uninitialized_construct_buf_dispatch<
+        __has_trivial_constructor(_ValueType)>::
+   __ucr(__first, __last, __seed);
+    }
+
+  template<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;
+ }
+    }
+
+
+}
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 2 3
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 3
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cmath" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cmath" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cmath" 3
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/math.h" 1 3 4
+# 28 "/mnt/odroid-c2/usr/include/math.h" 3 4
+extern "C" {
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/math-vector.h" 1 3 4
+# 27 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/math-vector.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4
+# 27 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/math-vector.h" 2 3 4
+# 32 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/huge_val.h" 1 3 4
+# 36 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/huge_valf.h" 1 3 4
+# 38 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/huge_vall.h" 1 3 4
+# 39 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/inf.h" 1 3 4
+# 42 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/nan.h" 1 3 4
+# 45 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/mathdef.h" 1 3 4
+# 27 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/mathdef.h" 3 4
+typedef float float_t;
+
+typedef double double_t;
+# 49 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+# 83 "/mnt/odroid-c2/usr/include/math.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/mathcalls.h" 1 3 4
+# 52 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/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__));
+
+# 208 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/mathcalls.h" 3 4
+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__));
+# 247 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/mathcalls.h" 3 4
+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 ();
+__extension__
+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 ();
+__extension__
+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 () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+
+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 int __issignaling (double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+
+
+
+extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
+# 84 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+# 104 "/mnt/odroid-c2/usr/include/math.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/mathcalls.h" 1 3 4
+# 52 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/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 (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (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 ();
+__extension__
+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 ();
+__extension__
+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 () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+
+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 int __issignalingf (float __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+
+
+
+extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
+# 105 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+# 151 "/mnt/odroid-c2/usr/include/math.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/mathcalls.h" 1 3 4
+# 52 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/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 (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (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 ();
+__extension__
+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 ();
+__extension__
+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 () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+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 int __issignalingl (long double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+
+
+
+extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
+# 152 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+# 168 "/mnt/odroid-c2/usr/include/math.h" 3 4
+extern int signgam;
+# 209 "/mnt/odroid-c2/usr/include/math.h" 3 4
+enum
+  {
+    FP_NAN =
+
+      0,
+    FP_INFINITE =
+
+      1,
+    FP_ZERO =
+
+      2,
+    FP_SUBNORMAL =
+
+      3,
+    FP_NORMAL =
+
+      4
+  };
+# 347 "/mnt/odroid-c2/usr/include/math.h" 3 4
+typedef enum
+{
+  _IEEE_ = -1,
+  _SVID_,
+  _XOPEN_,
+  _POSIX_,
+  _ISOC_
+} _LIB_VERSION_TYPE;
+
+
+
+
+extern _LIB_VERSION_TYPE _LIB_VERSION;
+# 370 "/mnt/odroid-c2/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 ();
+# 472 "/mnt/odroid-c2/usr/include/math.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/mathinline.h" 1 3 4
+# 473 "/mnt/odroid-c2/usr/include/math.h" 2 3 4
+# 534 "/mnt/odroid-c2/usr/include/math.h" 3 4
+}
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cmath" 2 3
+# 75 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 431 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+
+
+}
+# 555 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cmath" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  constexpr int
+  fpclassify(float __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+
+  constexpr int
+  fpclassify(double __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+
+  constexpr int
+  fpclassify(long double __x)
+  { return __builtin_fpclassify(0, 1, 4,
+    3, 2, __x); }
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              int>::__type
+    fpclassify(_Tp __x)
+    { return __x != 0 ? 4 : 2; }
+
+
+  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_signbitf(__x); }
+
+  constexpr bool
+  signbit(double __x)
+  { return __builtin_signbit(__x); }
+
+  constexpr bool
+  signbit(long double __x)
+  { return __builtin_signbitl(__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));
+    }
+# 942 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cmath" 3
+
+}
+# 1058 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 1 3
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 3
+       
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stringfwd.h" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stringfwd.h" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stringfwd.h" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+  template<class _CharT>
+    struct char_traits;
+
+  template<> struct char_traits<char>;
+
+
+  template<> struct char_traits<wchar_t>;
+
+
+
+
+  template<> struct char_traits<char16_t>;
+  template<> struct char_traits<char32_t>;
+
+
+namespace __cxx11 {
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+           typename _Alloc = allocator<_CharT> >
+    class basic_string;
+
+
+  typedef basic_string<char> string;
+
+
+
+  typedef basic_string<wchar_t> wstring;
+
+
+
+
+
+  typedef basic_string<char16_t> u16string;
+
+
+  typedef basic_string<char32_t> u32string;
+
+
+}
+
+
+
+
+}
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/char_traits.h" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/char_traits.h" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/char_traits.h" 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/postypes.h" 1 3
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/postypes.h" 3
+       
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/postypes.h" 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/wchar.h" 1 3 4
+# 36 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/stdio.h" 1 3 4
+# 44 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+struct _IO_FILE;
+
+
+
+typedef struct _IO_FILE FILE;
+
+
+
+
+
+# 64 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+typedef struct _IO_FILE __FILE;
+# 37 "/mnt/odroid-c2/usr/include/wchar.h" 2 3 4
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stdarg.h" 1 3 4
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stdarg.h" 3 4
+typedef __builtin_va_list __gnuc_va_list;
+# 40 "/mnt/odroid-c2/usr/include/wchar.h" 2 3 4
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/wchar.h" 1 3 4
+# 42 "/mnt/odroid-c2/usr/include/wchar.h" 2 3 4
+# 51 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 357 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 3 4
+typedef unsigned int wint_t;
+# 52 "/mnt/odroid-c2/usr/include/wchar.h" 2 3 4
+# 82 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+typedef struct
+{
+  int __count;
+  union
+  {
+
+    unsigned int __wch;
+
+
+
+    char __wchb[4];
+  } __value;
+} __mbstate_t;
+# 104 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+
+
+typedef __mbstate_t mbstate_t;
+
+
+
+
+
+
+# 132 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+extern "C" {
+
+
+
+
+struct tm;
+
+
+
+
+
+
+
+
+
+extern wchar_t *wcscpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern wchar_t *wcscat (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern wchar_t *wcsncat (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
+
+
+extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
+   size_t __n) throw ();
+
+
+
+
+
+extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+    __locale_t __loc) throw ();
+
+extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+     size_t __n, __locale_t __loc) throw ();
+
+
+
+
+
+extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
+
+
+
+extern size_t wcsxfrm (wchar_t *__restrict __s1,
+         const wchar_t *__restrict __s2, size_t __n) throw ();
+
+
+
+
+
+
+
+
+extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
+        __locale_t __loc) throw ();
+
+
+
+
+extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
+    size_t __n, __locale_t __loc) throw ();
+
+
+extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
+
+
+
+
+
+extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+
+
+
+
+
+
+
+
+
+extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+
+extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
+     throw () __attribute__ ((__pure__));
+
+
+extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
+     throw () __attribute__ ((__pure__));
+
+
+extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
+         const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
+        const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern wchar_t *wcstok (wchar_t *__restrict __s,
+   const wchar_t *__restrict __delim,
+   wchar_t **__restrict __ptr) throw ();
+
+
+extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
+
+
+
+
+
+extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
+        const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+# 309 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
+         size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__));
+
+
+extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
+    const wchar_t *__restrict __s2, size_t __n) throw ();
+
+
+
+extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     throw ();
+
+
+extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
+
+
+
+
+
+extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
+     const wchar_t *__restrict __s2, size_t __n)
+     throw ();
+
+
+
+
+
+
+extern wint_t btowc (int __c) throw ();
+
+
+
+extern int wctob (wint_t __c) throw ();
+
+
+
+extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
+
+
+
+extern size_t mbrtowc (wchar_t *__restrict __pwc,
+         const char *__restrict __s, size_t __n,
+         mbstate_t *__restrict __p) throw ();
+
+
+extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
+         mbstate_t *__restrict __ps) throw ();
+
+
+extern size_t __mbrlen (const char *__restrict __s, size_t __n,
+   mbstate_t *__restrict __ps) throw ();
+extern size_t mbrlen (const char *__restrict __s, size_t __n,
+        mbstate_t *__restrict __ps) throw ();
+
+
+
+
+
+
+
+
+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 ();
+# 533 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+extern long int wcstol_l (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr, int __base,
+     __locale_t __loc) throw ();
+
+extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr,
+        int __base, __locale_t __loc) throw ();
+
+__extension__
+extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
+    wchar_t **__restrict __endptr,
+    int __base, __locale_t __loc) throw ();
+
+__extension__
+extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       int __base, __locale_t __loc)
+     throw ();
+
+extern double wcstod_l (const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, __locale_t __loc)
+     throw ();
+
+extern float wcstof_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, __locale_t __loc)
+     throw ();
+
+extern long double wcstold_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         __locale_t __loc) throw ();
+
+
+
+
+
+
+extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src) throw ();
+
+
+
+extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     throw ();
+
+
+
+
+
+
+extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
+
+
+
+
+
+
+extern int fwide (__FILE *__fp, int __mode) throw ();
+
+
+
+
+
+
+extern int fwprintf (__FILE *__restrict __stream,
+       const wchar_t *__restrict __format, ...)
+                                                           ;
+
+
+
+
+extern int wprintf (const wchar_t *__restrict __format, ...)
+                                                           ;
+
+extern int swprintf (wchar_t *__restrict __s, size_t __n,
+       const wchar_t *__restrict __format, ...)
+     throw () ;
+
+
+
+
+
+extern int vfwprintf (__FILE *__restrict __s,
+        const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+                                                           ;
+
+
+
+
+extern int vwprintf (const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                           ;
+
+
+extern int vswprintf (wchar_t *__restrict __s, size_t __n,
+        const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+     throw () ;
+
+
+
+
+
+
+extern int fwscanf (__FILE *__restrict __stream,
+      const wchar_t *__restrict __format, ...)
+                                                          ;
+
+
+
+
+extern int wscanf (const wchar_t *__restrict __format, ...)
+                                                          ;
+
+extern int swscanf (const wchar_t *__restrict __s,
+      const wchar_t *__restrict __format, ...)
+     throw () ;
+# 683 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+
+
+
+
+
+
+
+
+
+extern int vfwscanf (__FILE *__restrict __s,
+       const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                          ;
+
+
+
+
+extern int vwscanf (const wchar_t *__restrict __format,
+      __gnuc_va_list __arg)
+                                                          ;
+
+extern int vswscanf (const wchar_t *__restrict __s,
+       const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+     throw () ;
+# 739 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+
+
+
+
+
+
+
+
+
+extern wint_t fgetwc (__FILE *__stream);
+extern wint_t getwc (__FILE *__stream);
+
+
+
+
+
+extern wint_t getwchar (void);
+
+
+
+
+
+
+extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
+extern wint_t putwc (wchar_t __wc, __FILE *__stream);
+
+
+
+
+
+extern wint_t putwchar (wchar_t __wc);
+
+
+
+
+
+
+
+extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
+   __FILE *__restrict __stream);
+
+
+
+
+
+extern int fputws (const wchar_t *__restrict __ws,
+     __FILE *__restrict __stream);
+
+
+
+
+
+
+extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
+
+# 804 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+extern wint_t getwc_unlocked (__FILE *__stream);
+extern wint_t getwchar_unlocked (void);
+
+
+
+
+
+
+
+extern wint_t fgetwc_unlocked (__FILE *__stream);
+
+
+
+
+
+
+
+extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
+# 830 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
+extern wint_t putwchar_unlocked (wchar_t __wc);
+# 840 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
+     __FILE *__restrict __stream);
+
+
+
+
+
+
+
+extern int fputws_unlocked (const wchar_t *__restrict __ws,
+       __FILE *__restrict __stream);
+
+
+
+
+
+
+
+extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
+   const wchar_t *__restrict __format,
+   const struct tm *__restrict __tp) throw ();
+
+
+
+
+
+
+
+extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
+     const wchar_t *__restrict __format,
+     const struct tm *__restrict __tp,
+     __locale_t __loc) throw ();
+# 894 "/mnt/odroid-c2/usr/include/wchar.h" 3 4
+}
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 2 3
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+namespace std
+{
+  using ::mbstate_t;
+}
+# 135 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::wint_t;
+
+  using ::btowc;
+  using ::fgetwc;
+  using ::fgetws;
+  using ::fputwc;
+  using ::fputws;
+  using ::fwide;
+  using ::fwprintf;
+  using ::fwscanf;
+  using ::getwc;
+  using ::getwchar;
+  using ::mbrlen;
+  using ::mbrtowc;
+  using ::mbsinit;
+  using ::mbsrtowcs;
+  using ::putwc;
+  using ::putwchar;
+
+  using ::swprintf;
+
+  using ::swscanf;
+  using ::ungetwc;
+  using ::vfwprintf;
+
+  using ::vfwscanf;
+
+
+  using ::vswprintf;
+
+
+  using ::vswscanf;
+
+  using ::vwprintf;
+
+  using ::vwscanf;
+
+  using ::wcrtomb;
+  using ::wcscat;
+  using ::wcscmp;
+  using ::wcscoll;
+  using ::wcscpy;
+  using ::wcscspn;
+  using ::wcsftime;
+  using ::wcslen;
+  using ::wcsncat;
+  using ::wcsncmp;
+  using ::wcsncpy;
+  using ::wcsrtombs;
+  using ::wcsspn;
+  using ::wcstod;
+
+  using ::wcstof;
+
+  using ::wcstok;
+  using ::wcstol;
+  using ::wcstoul;
+  using ::wcsxfrm;
+  using ::wctob;
+  using ::wmemcmp;
+  using ::wmemcpy;
+  using ::wmemmove;
+  using ::wmemset;
+  using ::wprintf;
+  using ::wscanf;
+  using ::wcschr;
+  using ::wcspbrk;
+  using ::wcsrchr;
+  using ::wcsstr;
+  using ::wmemchr;
+# 232 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+
+}
+
+
+
+
+
+
+
+namespace __gnu_cxx
+{
+
+
+
+
+
+  using ::wcstold;
+# 257 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+  using ::wcstoll;
+  using ::wcstoull;
+
+}
+
+namespace std
+{
+  using ::__gnu_cxx::wcstold;
+  using ::__gnu_cxx::wcstoll;
+  using ::__gnu_cxx::wcstoull;
+}
+# 277 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+
+}
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/postypes.h" 2 3
+# 68 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/postypes.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 88 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/postypes.h" 3
+  typedef long streamoff;
+# 98 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/postypes.h" 3
+  typedef ptrdiff_t streamsize;
+# 111 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/postypes.h" 3
+  template<typename _StateT>
+    class fpos
+    {
+    private:
+      streamoff _M_off;
+      _StateT _M_state;
+
+    public:
+
+
+
+
+      fpos()
+      : _M_off(0), _M_state() { }
+# 133 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+
+
+
+}
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/char_traits.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/wchar.h" 1 3 4
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 2 3
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/char_traits.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+# 57 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    };
+# 82 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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")))
+{
+
+# 226 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 (static_cast<unsigned char>(__c1)
+  < static_cast<unsigned char>(__c2));
+      }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return 0;
+ return __builtin_memcmp(__s1, __s2, __n);
+      }
+
+      static size_t
+      length(const char_type* __s)
+      { return __builtin_strlen(__s); }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ if (__n == 0)
+   return 0;
+ return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ if (__n == 0)
+   return __s;
+ return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
+      }
+
+      static 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)
+      {
+ if (__n == 0)
+   return 0;
+ return wmemcmp(__s1, __s2, __n);
+      }
+
+      static size_t
+      length(const char_type* __s)
+      { return wcslen(__s); }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      {
+ if (__n == 0)
+   return 0;
+ return wmemchr(__s, __a, __n);
+      }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return wmemmove(__s1, __s2, __n);
+      }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      {
+ if (__n == 0)
+   return __s1;
+ return wmemcpy(__s1, __s2, __n);
+      }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      {
+ if (__n == 0)
+   return __s;
+ return wmemset(__s, __a, __n);
+      }
+
+      static 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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdint" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdint" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdint" 3
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdint" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stdint.h" 1 3 4
+# 9 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stdint.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/stdint.h" 1 3 4
+# 27 "/mnt/odroid-c2/usr/include/stdint.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4
+# 28 "/mnt/odroid-c2/usr/include/stdint.h" 2 3 4
+# 48 "/mnt/odroid-c2/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;
+# 65 "/mnt/odroid-c2/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;
+# 90 "/mnt/odroid-c2/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;
+# 103 "/mnt/odroid-c2/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;
+# 119 "/mnt/odroid-c2/usr/include/stdint.h" 3 4
+typedef long int intptr_t;
+
+
+typedef unsigned long int uintptr_t;
+# 134 "/mnt/odroid-c2/usr/include/stdint.h" 3 4
+typedef long int intmax_t;
+typedef unsigned long int uintmax_t;
+# 10 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stdint.h" 2 3 4
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdint" 2 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;
+}
+# 421 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+      {
+ if (__n == 0)
+   return __s1;
+ 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)
+      {
+ if (__n == 0)
+   return __s1;
+ 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)
+      {
+ if (__n == 0)
+   return __s1;
+ 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)
+      {
+ if (__n == 0)
+   return __s1;
+ 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; }
+    };
+
+
+}
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/allocator.h" 1 3
+# 46 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/allocator.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++allocator.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++allocator.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/new_allocator.h" 1 3
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/new_allocator.h" 3
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using std::size_t;
+  using std::ptrdiff_t;
+# 57 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; };
+
+
+
+
+      typedef std::true_type propagate_on_container_move_assignment;
+
+
+      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(); }
+# 135 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+
+
+}
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++allocator.h" 2 3
+
+
+namespace std
+{
+# 47 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++allocator.h" 3
+  template<typename _Tp>
+    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
+}
+# 47 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/allocator.h" 2 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+  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; };
+
+
+
+
+      typedef true_type propagate_on_container_move_assignment;
+
+    };
+# 91 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/allocator.h" 3
+  template<typename _Tp>
+    class allocator: public __allocator_base<_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; };
+
+
+
+
+      typedef true_type propagate_on_container_move_assignment;
+
+
+      allocator() throw() { }
+
+      allocator(const allocator& __a) throw()
+      : __allocator_base<_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>&)
+    noexcept
+    { return true; }
+
+  template<typename _Tp>
+    inline bool
+    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
+    noexcept
+    { return true; }
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator!=(const allocator<_T1>&, const allocator<_T2>&)
+    noexcept
+    { return false; }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
+    noexcept
+    { return false; }
+
+
+
+
+
+
+  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&) noexcept { } };
+
+  template<typename _Alloc>
+    struct __alloc_swap<_Alloc, false>
+    {
+      static void
+      _S_do_it(_Alloc& __one, _Alloc& __two) noexcept
+      {
+
+ 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&) noexcept { return false; } };
+
+  template<typename _Tp>
+    struct __shrink_to_fit_aux<_Tp, true>
+    {
+      static bool
+      _S_do_it(_Tp& __c) noexcept
+      {
+
+ 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; }
+
+
+
+      }
+    };
+
+
+
+}
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 2 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/localefwd.h" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/localefwd.h" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/localefwd.h" 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++locale.h" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++locale.h" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++locale.h" 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/clocale" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/clocale" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/clocale" 3
+
+
+# 1 "/mnt/odroid-c2/usr/include/locale.h" 1 3 4
+# 28 "/mnt/odroid-c2/usr/include/locale.h" 3 4
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 29 "/mnt/odroid-c2/usr/include/locale.h" 2 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/locale.h" 1 3 4
+# 30 "/mnt/odroid-c2/usr/include/locale.h" 2 3 4
+
+extern "C" {
+# 50 "/mnt/odroid-c2/usr/include/locale.h" 3 4
+
+
+
+struct lconv
+{
+
+
+  char *decimal_point;
+  char *thousands_sep;
+
+
+
+
+
+  char *grouping;
+
+
+
+
+
+  char *int_curr_symbol;
+  char *currency_symbol;
+  char *mon_decimal_point;
+  char *mon_thousands_sep;
+  char *mon_grouping;
+  char *positive_sign;
+  char *negative_sign;
+  char int_frac_digits;
+  char frac_digits;
+
+  char p_cs_precedes;
+
+  char p_sep_by_space;
+
+  char n_cs_precedes;
+
+  char n_sep_by_space;
+
+
+
+
+
+
+  char p_sign_posn;
+  char n_sign_posn;
+
+
+  char int_p_cs_precedes;
+
+  char int_p_sep_by_space;
+
+  char int_n_cs_precedes;
+
+  char int_n_sep_by_space;
+
+
+
+
+
+
+  char int_p_sign_posn;
+  char int_n_sign_posn;
+# 120 "/mnt/odroid-c2/usr/include/locale.h" 3 4
+};
+
+
+
+extern char *setlocale (int __category, const char *__locale) throw ();
+
+
+extern struct lconv *localeconv (void) throw ();
+
+
+# 151 "/mnt/odroid-c2/usr/include/locale.h" 3 4
+extern __locale_t newlocale (int __category_mask, const char *__locale,
+        __locale_t __base) throw ();
+# 186 "/mnt/odroid-c2/usr/include/locale.h" 3 4
+extern __locale_t duplocale (__locale_t __dataset) throw ();
+
+
+
+extern void freelocale (__locale_t __dataset) throw ();
+
+
+
+
+
+
+extern __locale_t uselocale (__locale_t __dataset) throw ();
+
+
+
+
+
+
+
+}
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/clocale" 2 3
+# 51 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/clocale" 3
+namespace std
+{
+  using ::lconv;
+  using ::setlocale;
+  using ::localeconv;
+}
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++locale.h" 2 3
+
+
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+  extern "C" __typeof(uselocale) __uselocale;
+
+
+}
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  typedef __locale_t __c_locale;
+
+
+
+
+
+  inline int
+  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
+     char* __out,
+     const int __size __attribute__ ((__unused__)),
+     const char* __fmt, ...)
+  {
+
+    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
+# 88 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/c++locale.h" 3
+    __builtin_va_list __args;
+    __builtin_va_start(__args, __fmt);
+
+
+    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+
+
+
+
+    __builtin_va_end(__args);
+
+
+    __gnu_cxx::__uselocale(__old);
+
+
+
+
+
+
+
+    return __ret;
+  }
+
+
+}
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/localefwd.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iosfwd" 1 3
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iosfwd" 3
+       
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iosfwd" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 74 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iosfwd" 3
+  class ios_base;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ios;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_streambuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_istream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ostream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_iostream;
+
+
+namespace __cxx11 {
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+     typename _Alloc = allocator<_CharT> >
+    class basic_stringbuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_istringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_ostringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_stringstream;
+
+}
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_filebuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ifstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ofstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_fstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class istreambuf_iterator;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class ostreambuf_iterator;
+
+
+
+  typedef basic_ios<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;
+
+
+
+
+}
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/localefwd.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cctype" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cctype" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cctype" 3
+
+
+# 1 "/mnt/odroid-c2/usr/include/ctype.h" 1 3 4
+# 28 "/mnt/odroid-c2/usr/include/ctype.h" 3 4
+extern "C" {
+# 46 "/mnt/odroid-c2/usr/include/ctype.h" 3 4
+enum
+{
+  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
+  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
+  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
+  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
+  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
+  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
+  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
+  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
+  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
+  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
+  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
+  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
+};
+# 79 "/mnt/odroid-c2/usr/include/ctype.h" 3 4
+extern const unsigned short int **__ctype_b_loc (void)
+     throw () __attribute__ ((__const__));
+extern const __int32_t **__ctype_tolower_loc (void)
+     throw () __attribute__ ((__const__));
+extern const __int32_t **__ctype_toupper_loc (void)
+     throw () __attribute__ ((__const__));
+# 104 "/mnt/odroid-c2/usr/include/ctype.h" 3 4
+
+
+
+
+
+
+extern int isalnum (int) throw ();
+extern int isalpha (int) throw ();
+extern int iscntrl (int) throw ();
+extern int isdigit (int) throw ();
+extern int islower (int) throw ();
+extern int isgraph (int) throw ();
+extern int isprint (int) throw ();
+extern int ispunct (int) throw ();
+extern int isspace (int) throw ();
+extern int isupper (int) throw ();
+extern int isxdigit (int) throw ();
+
+
+
+extern int tolower (int __c) throw ();
+
+
+extern int toupper (int __c) throw ();
+
+
+
+
+
+
+
+
+extern int isblank (int) throw ();
+
+
+
+
+
+
+extern int isctype (int __c, int __mask) throw ();
+
+
+
+
+
+
+extern int isascii (int __c) throw ();
+
+
+
+extern int toascii (int __c) throw ();
+
+
+
+extern int _toupper (int) throw ();
+extern int _tolower (int) throw ();
+# 271 "/mnt/odroid-c2/usr/include/ctype.h" 3 4
+extern int isalnum_l (int, __locale_t) throw ();
+extern int isalpha_l (int, __locale_t) throw ();
+extern int iscntrl_l (int, __locale_t) throw ();
+extern int isdigit_l (int, __locale_t) throw ();
+extern int islower_l (int, __locale_t) throw ();
+extern int isgraph_l (int, __locale_t) throw ();
+extern int isprint_l (int, __locale_t) throw ();
+extern int ispunct_l (int, __locale_t) throw ();
+extern int isspace_l (int, __locale_t) throw ();
+extern int isupper_l (int, __locale_t) throw ();
+extern int isxdigit_l (int, __locale_t) throw ();
+
+extern int isblank_l (int, __locale_t) throw ();
+
+
+
+extern int __tolower_l (int __c, __locale_t __l) throw ();
+extern int tolower_l (int __c, __locale_t __l) throw ();
+
+
+extern int __toupper_l (int __c, __locale_t __l) throw ();
+extern int toupper_l (int __c, __locale_t __l) throw ();
+# 347 "/mnt/odroid-c2/usr/include/ctype.h" 3 4
+}
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cctype" 2 3
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+}
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/localefwd.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 55 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>
+    bool
+    isblank(_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;
+
+namespace __cxx11 {
+  template<typename _CharT> class numpunct;
+  template<typename _CharT> class numpunct_byname;
+}
+
+namespace __cxx11 {
+
+  template<typename _CharT>
+    class collate;
+  template<typename _CharT>
+    class collate_byname;
+}
+
+
+  class time_base;
+namespace __cxx11 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get;
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get_byname;
+}
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put_byname;
+
+
+  class money_base;
+namespace __cxx11 {
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class money_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class money_put;
+}
+namespace __cxx11 {
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct;
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct_byname;
+}
+
+
+  class messages_base;
+namespace __cxx11 {
+  template<typename _CharT>
+    class messages;
+  template<typename _CharT>
+    class messages_byname;
+}
+
+
+}
+# 44 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ostream_insert.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ostream_insert.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ostream_insert.h" 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/cxxabi_forced.h" 1 3
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/cxxabi_forced.h" 3
+       
+# 35 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ostream_insert.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+      const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+      if (__put != __n)
+ __out.setstate(__ios_base::badbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const _CharT __c = __out.fill();
+      for (; __n > 0; --__n)
+ {
+   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+   if (_Traits::eq_int_type(__put, _Traits::eof()))
+     {
+       __out.setstate(__ios_base::badbit);
+       break;
+     }
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+       const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      typename __ostream_type::sentry __cerb(__out);
+      if (__cerb)
+ {
+   try
+     {
+       const streamsize __w = __out.width();
+       if (__w > __n)
+  {
+    const bool __left = ((__out.flags()
+     & __ios_base::adjustfield)
+           == __ios_base::left);
+    if (!__left)
+      __ostream_fill(__out, __w - __n);
+    if (__out.good())
+      __ostream_write(__out, __s, __n);
+    if (__left && __out.good())
+      __ostream_fill(__out, __w - __n);
+  }
+       else
+  __ostream_write(__out, __s, __n);
+       __out.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(__ios_base::badbit); }
+ }
+      return __out;
+    }
+
+
+
+
+  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
+
+
+  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
+          streamsize);
+
+
+
+
+}
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 2 3
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_function.h" 1 3
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_function.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 104 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    };
+# 144 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_function.h" 3
+  struct __is_transparent;
+
+  template<typename _Tp = void>
+    struct plus;
+
+  template<typename _Tp = void>
+    struct minus;
+
+  template<typename _Tp = void>
+    struct multiplies;
+
+  template<typename _Tp = void>
+    struct divides;
+
+  template<typename _Tp = void>
+    struct modulus;
+
+  template<typename _Tp = void>
+    struct negate;
+
+
+
+  template<typename _Tp>
+    struct plus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x + __y; }
+    };
+
+
+  template<typename _Tp>
+    struct minus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x - __y; }
+    };
+
+
+  template<typename _Tp>
+    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x * __y; }
+    };
+
+
+  template<typename _Tp>
+    struct divides : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x / __y; }
+    };
+
+
+  template<typename _Tp>
+    struct modulus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x % __y; }
+    };
+
+
+  template<typename _Tp>
+    struct negate : public unary_function<_Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x) const
+      { return -__x; }
+    };
+
+
+
+
+
+
+  template<>
+    struct plus<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct minus<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct multiplies<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct divides<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct modulus<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct negate<void>
+    {
+      template <typename _Tp>
+ constexpr
+ auto
+ operator()(_Tp&& __t) const
+ noexcept(noexcept(-std::forward<_Tp>(__t)))
+ -> decltype(-std::forward<_Tp>(__t))
+ { return -std::forward<_Tp>(__t); }
+
+      typedef __is_transparent is_transparent;
+    };
+# 331 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_function.h" 3
+  template<typename _Tp = void>
+    struct equal_to;
+
+  template<typename _Tp = void>
+    struct not_equal_to;
+
+  template<typename _Tp = void>
+    struct greater;
+
+  template<typename _Tp = void>
+    struct less;
+
+  template<typename _Tp = void>
+    struct greater_equal;
+
+  template<typename _Tp = void>
+    struct less_equal;
+
+
+
+  template<typename _Tp>
+    struct equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      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>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x != __y; }
+    };
+
+
+  template<typename _Tp>
+    struct greater : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x > __y; }
+    };
+
+
+  template<typename _Tp>
+    struct less : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x < __y; }
+    };
+
+
+  template<typename _Tp>
+    struct greater_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x >= __y; }
+    };
+
+
+  template<typename _Tp>
+    struct less_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x <= __y; }
+    };
+
+
+
+  template<>
+    struct equal_to<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct not_equal_to<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct greater<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct less<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct greater_equal<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct less_equal<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+# 513 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_function.h" 3
+  template<typename _Tp = void>
+    struct logical_and;
+
+  template<typename _Tp = void>
+    struct logical_or;
+
+  template<typename _Tp = void>
+    struct logical_not;
+
+
+
+  template<typename _Tp>
+    struct logical_and : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x && __y; }
+    };
+
+
+  template<typename _Tp>
+    struct logical_or : public binary_function<_Tp, _Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x || __y; }
+    };
+
+
+  template<typename _Tp>
+    struct logical_not : public unary_function<_Tp, bool>
+    {
+      constexpr
+      bool
+      operator()(const _Tp& __x) const
+      { return !__x; }
+    };
+
+
+
+  template<>
+    struct logical_and<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct logical_or<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+  template<>
+    struct logical_not<void>
+    {
+      template <typename _Tp>
+ constexpr
+ auto
+ operator()(_Tp&& __t) const
+ noexcept(noexcept(!std::forward<_Tp>(__t)))
+ -> decltype(!std::forward<_Tp>(__t))
+ { return !std::forward<_Tp>(__t); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+
+
+
+  template<typename _Tp = void>
+    struct bit_and;
+
+  template<typename _Tp = void>
+    struct bit_or;
+
+  template<typename _Tp = void>
+    struct bit_xor;
+
+  template<typename _Tp = void>
+    struct bit_not;
+
+
+
+
+  template<typename _Tp>
+    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x & __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x | __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
+    {
+      constexpr
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x ^ __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_not : public unary_function<_Tp, _Tp>
+    {
+    constexpr
+      _Tp
+      operator()(const _Tp& __x) const
+      { return ~__x; }
+    };
+
+
+  template <>
+    struct bit_and<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  template <>
+    struct bit_or<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  template <>
+    struct bit_xor<void>
+    {
+      template <typename _Tp, typename _Up>
+ constexpr
+ auto
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
+ -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
+ { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
+
+      typedef __is_transparent is_transparent;
+    };
+
+  template <>
+    struct bit_not<void>
+    {
+      template <typename _Tp>
+ constexpr
+ auto
+ operator()(_Tp&& __t) const
+ noexcept(noexcept(~std::forward<_Tp>(__t)))
+ -> decltype(~std::forward<_Tp>(__t))
+ { return ~std::forward<_Tp>(__t); }
+
+      typedef __is_transparent is_transparent;
+    };
+# 741 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_function.h" 3
+  template<typename _Predicate>
+    class unary_negate
+    : public unary_function<typename _Predicate::argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+
+    public:
+      constexpr
+      explicit
+      unary_negate(const _Predicate& __x) : _M_pred(__x) { }
+
+      constexpr
+      bool
+      operator()(const typename _Predicate::argument_type& __x) const
+      { return !_M_pred(__x); }
+    };
+
+
+  template<typename _Predicate>
+    constexpr
+    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:
+      constexpr
+      explicit
+      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
+
+      constexpr
+      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>
+    constexpr
+    inline binary_negate<_Predicate>
+    not2(const _Predicate& __pred)
+    { return binary_negate<_Predicate>(__pred); }
+# 818 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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
+    : public unary_function<_Tp,_Tp>
+    {
+      _Tp&
+      operator()(_Tp& __x) const
+      { return __x; }
+
+      const _Tp&
+      operator()(const _Tp& __x) const
+      { return __x; }
+    };
+
+  template<typename _Pair>
+    struct _Select1st
+    : public unary_function<_Pair, typename _Pair::first_type>
+    {
+      typename _Pair::first_type&
+      operator()(_Pair& __x) const
+      { return __x.first; }
+
+      const typename _Pair::first_type&
+      operator()(const _Pair& __x) const
+      { return __x.first; }
+
+
+      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
+    : public unary_function<_Pair, typename _Pair::second_type>
+    {
+      typename _Pair::second_type&
+      operator()(_Pair& __x) const
+      { return __x.second; }
+
+      const typename _Pair::second_type&
+      operator()(const _Pair& __x) const
+      { return __x.second; }
+    };
+# 938 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/backward/binders.h" 1 3
+# 60 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/backward/binders.h" 3
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 107 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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));
+    }
+
+
+
+}
+
+#pragma GCC diagnostic pop
+# 1129 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_function.h" 2 3
+# 49 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 2 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/range_access.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/range_access.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 constexpr _Tp*
+    begin(_Tp (&__arr)[_Nm])
+    { return __arr; }
+
+
+
+
+
+
+  template<class _Tp, size_t _Nm>
+    inline constexpr _Tp*
+    end(_Tp (&__arr)[_Nm])
+    { return __arr + _Nm; }
+
+
+
+  template<typename _Tp> class valarray;
+
+  template<typename _Tp> _Tp* begin(valarray<_Tp>&);
+  template<typename _Tp> const _Tp* begin(const valarray<_Tp>&);
+  template<typename _Tp> _Tp* end(valarray<_Tp>&);
+  template<typename _Tp> const _Tp* end(const valarray<_Tp>&);
+
+
+
+
+
+
+  template<class _Container>
+    inline constexpr auto
+    cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
+      -> decltype(std::begin(__cont))
+    { return std::begin(__cont); }
+
+
+
+
+
+
+  template<class _Container>
+    inline constexpr auto
+    cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
+      -> decltype(std::end(__cont))
+    { return std::end(__cont); }
+
+
+
+
+
+
+  template<class _Container>
+    inline auto
+    rbegin(_Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+
+
+
+
+
+
+  template<class _Container>
+    inline auto
+    rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+
+
+
+
+
+
+  template<class _Container>
+    inline auto
+    rend(_Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+
+
+
+
+
+
+  template<class _Container>
+    inline auto
+    rend(const _Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+
+
+
+
+
+
+  template<class _Tp, size_t _Nm>
+    inline reverse_iterator<_Tp*>
+    rbegin(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr + _Nm); }
+
+
+
+
+
+
+  template<class _Tp, size_t _Nm>
+    inline reverse_iterator<_Tp*>
+    rend(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr); }
+
+
+
+
+
+
+  template<class _Tp>
+    inline reverse_iterator<const _Tp*>
+    rbegin(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.end()); }
+
+
+
+
+
+
+  template<class _Tp>
+    inline reverse_iterator<const _Tp*>
+    rend(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.begin()); }
+
+
+
+
+
+
+  template<class _Container>
+    inline auto
+    crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
+    { return std::rbegin(__cont); }
+
+
+
+
+
+
+  template<class _Container>
+    inline auto
+    crend(const _Container& __cont) -> decltype(std::rend(__cont))
+    { return std::rend(__cont); }
+
+
+
+
+}
+# 52 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/atomicity.h" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/atomicity.h" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/atomicity.h" 3
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr.h" 1 3
+# 30 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr.h" 3
+#pragma GCC visibility push(default)
+# 148 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 1 3
+# 35 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 3
+# 1 "/mnt/odroid-c2/usr/include/pthread.h" 1 3 4
+# 23 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/sched.h" 1 3 4
+# 28 "/mnt/odroid-c2/usr/include/sched.h" 3 4
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 29 "/mnt/odroid-c2/usr/include/sched.h" 2 3 4
+
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/time.h" 1 3 4
+# 35 "/mnt/odroid-c2/usr/include/sched.h" 2 3 4
+# 43 "/mnt/odroid-c2/usr/include/sched.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/sched.h" 1 3 4
+# 72 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/sched.h" 3 4
+struct sched_param
+  {
+    int __sched_priority;
+  };
+
+extern "C" {
+
+
+
+extern int clone (int (*__fn) (void *__arg), void *__child_stack,
+    int __flags, void *__arg, ...) throw ();
+
+
+extern int unshare (int __flags) throw ();
+
+
+extern int sched_getcpu (void) throw ();
+
+
+extern int setns (int __fd, int __nstype) throw ();
+
+
+
+}
+
+
+
+
+
+
+
+struct __sched_param
+  {
+    int __sched_priority;
+  };
+# 118 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/sched.h" 3 4
+typedef unsigned long int __cpu_mask;
+
+
+
+
+
+
+typedef struct
+{
+  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
+} cpu_set_t;
+# 201 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/sched.h" 3 4
+extern "C" {
+
+extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
+  throw ();
+extern cpu_set_t *__sched_cpualloc (size_t __count) throw () ;
+extern void __sched_cpufree (cpu_set_t *__set) throw ();
+
+}
+# 44 "/mnt/odroid-c2/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 "/mnt/odroid-c2/usr/include/sched.h" 3 4
+extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
+         const cpu_set_t *__cpuset) throw ();
+
+
+extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
+         cpu_set_t *__cpuset) throw ();
+
+
+}
+# 24 "/mnt/odroid-c2/usr/include/pthread.h" 2 3 4
+# 1 "/mnt/odroid-c2/usr/include/time.h" 1 3 4
+# 29 "/mnt/odroid-c2/usr/include/time.h" 3 4
+extern "C" {
+
+
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 38 "/mnt/odroid-c2/usr/include/time.h" 2 3 4
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/time.h" 1 3 4
+# 88 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/time.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/timex.h" 1 3 4
+# 25 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/timex.h" 3 4
+struct timex
+{
+  unsigned int modes;
+  __syscall_slong_t offset;
+  __syscall_slong_t freq;
+  __syscall_slong_t maxerror;
+  __syscall_slong_t esterror;
+  int status;
+  __syscall_slong_t constant;
+  __syscall_slong_t precision;
+  __syscall_slong_t tolerance;
+  struct timeval time;
+  __syscall_slong_t tick;
+  __syscall_slong_t ppsfreq;
+  __syscall_slong_t jitter;
+  int shift;
+  __syscall_slong_t stabil;
+  __syscall_slong_t jitcnt;
+  __syscall_slong_t calcnt;
+  __syscall_slong_t errcnt;
+  __syscall_slong_t stbcnt;
+
+  int tai;
+
+
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32; int :32;
+  int :32; int :32; int :32;
+};
+# 89 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/time.h" 2 3 4
+
+extern "C" {
+
+
+extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();
+
+}
+# 42 "/mnt/odroid-c2/usr/include/time.h" 2 3 4
+# 131 "/mnt/odroid-c2/usr/include/time.h" 3 4
+
+
+struct tm
+{
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+
+
+  long int tm_gmtoff;
+  const char *tm_zone;
+
+
+
+
+};
+
+
+
+
+
+
+
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+
+
+struct sigevent;
+# 186 "/mnt/odroid-c2/usr/include/time.h" 3 4
+
+
+
+extern clock_t clock (void) throw ();
+
+
+extern time_t time (time_t *__timer) throw ();
+
+
+extern double difftime (time_t __time1, time_t __time0)
+     throw () __attribute__ ((__const__));
+
+
+extern time_t mktime (struct tm *__tp) throw ();
+
+
+
+
+
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+   const char *__restrict __format,
+   const struct tm *__restrict __tp) throw ();
+
+
+
+
+
+extern char *strptime (const char *__restrict __s,
+         const char *__restrict __fmt, struct tm *__tp)
+     throw ();
+
+
+
+
+
+
+
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+     const char *__restrict __format,
+     const struct tm *__restrict __tp,
+     __locale_t __loc) throw ();
+
+
+
+extern char *strptime_l (const char *__restrict __s,
+    const char *__restrict __fmt, struct tm *__tp,
+    __locale_t __loc) throw ();
+
+
+
+
+
+
+extern struct tm *gmtime (const time_t *__timer) throw ();
+
+
+
+extern struct tm *localtime (const time_t *__timer) throw ();
+
+
+
+
+
+extern struct tm *gmtime_r (const time_t *__restrict __timer,
+       struct tm *__restrict __tp) throw ();
+
+
+
+extern struct tm *localtime_r (const time_t *__restrict __timer,
+          struct tm *__restrict __tp) throw ();
+
+
+
+
+
+extern char *asctime (const struct tm *__tp) throw ();
+
+
+extern char *ctime (const time_t *__timer) throw ();
+
+
+
+
+
+
+
+extern char *asctime_r (const struct tm *__restrict __tp,
+   char *__restrict __buf) throw ();
+
+
+extern char *ctime_r (const time_t *__restrict __timer,
+        char *__restrict __buf) throw ();
+
+
+
+
+extern char *__tzname[2];
+extern int __daylight;
+extern long int __timezone;
+
+
+
+
+extern char *tzname[2];
+
+
+
+extern void tzset (void) throw ();
+
+
+
+extern int daylight;
+extern long int timezone;
+
+
+
+
+
+extern int stime (const time_t *__when) throw ();
+# 319 "/mnt/odroid-c2/usr/include/time.h" 3 4
+extern time_t timegm (struct tm *__tp) throw ();
+
+
+extern time_t timelocal (struct tm *__tp) throw ();
+
+
+extern int dysize (int __year) throw () __attribute__ ((__const__));
+# 334 "/mnt/odroid-c2/usr/include/time.h" 3 4
+extern int nanosleep (const struct timespec *__requested_time,
+        struct timespec *__remaining);
+
+
+
+extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
+
+
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
+
+
+extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
+     throw ();
+
+
+
+
+
+
+extern int clock_nanosleep (clockid_t __clock_id, int __flags,
+       const struct timespec *__req,
+       struct timespec *__rem);
+
+
+extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
+
+
+
+
+extern int timer_create (clockid_t __clock_id,
+    struct sigevent *__restrict __evp,
+    timer_t *__restrict __timerid) throw ();
+
+
+extern int timer_delete (timer_t __timerid) throw ();
+
+
+extern int timer_settime (timer_t __timerid, int __flags,
+     const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue) throw ();
+
+
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     throw ();
+
+
+extern int timer_getoverrun (timer_t __timerid) throw ();
+
+
+
+
+
+extern int timespec_get (struct timespec *__ts, int __base)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 403 "/mnt/odroid-c2/usr/include/time.h" 3 4
+extern int getdate_err;
+# 412 "/mnt/odroid-c2/usr/include/time.h" 3 4
+extern struct tm *getdate (const char *__string);
+# 426 "/mnt/odroid-c2/usr/include/time.h" 3 4
+extern int getdate_r (const char *__restrict __string,
+        struct tm *__restrict __resbufp);
+
+
+}
+# 25 "/mnt/odroid-c2/usr/include/pthread.h" 2 3 4
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/setjmp.h" 1 3 4
+# 30 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/setjmp.h" 3 4
+__extension__ typedef unsigned long long __jmp_buf [22];
+# 28 "/mnt/odroid-c2/usr/include/pthread.h" 2 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/wordsize.h" 1 3 4
+# 29 "/mnt/odroid-c2/usr/include/pthread.h" 2 3 4
+
+
+
+enum
+{
+  PTHREAD_CREATE_JOINABLE,
+
+  PTHREAD_CREATE_DETACHED
+
+};
+
+
+
+enum
+{
+  PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_ADAPTIVE_NP
+
+  ,
+  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
+
+
+
+  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
+
+};
+
+
+
+
+enum
+{
+  PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_ROBUST,
+  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
+};
+
+
+
+
+
+enum
+{
+  PTHREAD_PRIO_NONE,
+  PTHREAD_PRIO_INHERIT,
+  PTHREAD_PRIO_PROTECT
+};
+# 114 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+enum
+{
+  PTHREAD_RWLOCK_PREFER_READER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
+  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
+};
+# 155 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+enum
+{
+  PTHREAD_INHERIT_SCHED,
+
+  PTHREAD_EXPLICIT_SCHED
+
+};
+
+
+
+enum
+{
+  PTHREAD_SCOPE_SYSTEM,
+
+  PTHREAD_SCOPE_PROCESS
+
+};
+
+
+
+enum
+{
+  PTHREAD_PROCESS_PRIVATE,
+
+  PTHREAD_PROCESS_SHARED
+
+};
+# 190 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+struct _pthread_cleanup_buffer
+{
+  void (*__routine) (void *);
+  void *__arg;
+  int __canceltype;
+  struct _pthread_cleanup_buffer *__prev;
+};
+
+
+enum
+{
+  PTHREAD_CANCEL_ENABLE,
+
+  PTHREAD_CANCEL_DISABLE
+
+};
+enum
+{
+  PTHREAD_CANCEL_DEFERRED,
+
+  PTHREAD_CANCEL_ASYNCHRONOUS
+
+};
+# 228 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+extern "C" {
+
+
+
+
+extern int pthread_create (pthread_t *__restrict __newthread,
+      const pthread_attr_t *__restrict __attr,
+      void *(*__start_routine) (void *),
+      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+
+extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+extern int pthread_join (pthread_t __th, void **__thread_return);
+
+
+
+
+extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
+
+
+
+
+
+
+
+extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
+     const struct timespec *__abstime);
+
+
+
+
+
+
+extern int pthread_detach (pthread_t __th) throw ();
+
+
+
+extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
+
+
+extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
+  throw () __attribute__ ((__const__));
+
+
+
+
+
+
+
+extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_destroy (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
+     int *__detachstate)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
+     int __detachstate)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
+          size_t *__guardsize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
+          size_t __guardsize)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
+           struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
+           const struct sched_param *__restrict
+           __param) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
+     __attr, int *__restrict __policy)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
+      __attr, int *__restrict __inherit)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
+      int __inherit)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
+      int *__restrict __scope)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
+          __attr, void **__restrict __stackaddr)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
+
+
+
+
+
+extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
+          void *__stackaddr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
+
+
+extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
+          __attr, size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
+          size_t __stacksize)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
+      void **__restrict __stackaddr,
+      size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
+      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+extern int pthread_getattr_default_np (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+
+extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
+      const struct sched_param *__param)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getschedparam (pthread_t __target_thread,
+      int *__restrict __policy,
+      struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+
+extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
+     throw ();
+
+
+
+
+extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
+          size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+extern int pthread_getconcurrency (void) throw ();
+
+
+extern int pthread_setconcurrency (int __level) throw ();
+
+
+
+
+
+
+
+extern int pthread_yield (void) throw ();
+
+
+
+
+extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
+       const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
+       cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+# 494 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+extern int pthread_once (pthread_once_t *__once_control,
+    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
+# 506 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+extern int pthread_setcancelstate (int __state, int *__oldstate);
+
+
+
+extern int pthread_setcanceltype (int __type, int *__oldtype);
+
+
+extern int pthread_cancel (pthread_t __th);
+
+
+
+
+extern void pthread_testcancel (void);
+
+
+
+
+typedef struct
+{
+  struct
+  {
+    __jmp_buf __cancel_jmp_buf;
+    int __mask_was_saved;
+  } __cancel_jmp_buf[1];
+  void *__pad[4];
+} __pthread_unwind_buf_t __attribute__ ((__aligned__));
+# 540 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+struct __pthread_cleanup_frame
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+};
+
+
+
+
+class __pthread_cleanup_class
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+
+ public:
+  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
+    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
+  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
+  void __setdoit (int __newval) { __do_it = __newval; }
+  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
+        &__cancel_type); }
+  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
+};
+# 742 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+struct __jmp_buf_tag;
+extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
+
+
+
+
+
+extern int pthread_mutex_init (pthread_mutex_t *__mutex,
+          const pthread_mutexattr_t *__mutexattr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
+        const struct timespec *__restrict
+        __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
+      __restrict __mutex,
+      int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
+      int __prioceiling,
+      int *__restrict __old_ceiling)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 806 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
+      __restrict __attr,
+      int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
+      int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
+          __attr, int *__restrict __kind)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
+       __restrict __attr,
+       int *__restrict __protocol)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
+       int __protocol)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
+          __restrict __attr,
+          int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
+          int __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
+     int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
+        int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
+     int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
+        int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 888 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
+    const pthread_rwlockattr_t *__restrict
+    __attr) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
+  throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
+       int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pref)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
+       int __pref) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
+         const pthread_condattr_t *__restrict __cond_attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_destroy (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_signal (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_broadcast (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
+         pthread_mutex_t *__restrict __mutex)
+     __attribute__ ((__nonnull__ (1, 2)));
+# 1000 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
+       pthread_mutex_t *__restrict __mutex,
+       const struct timespec *__restrict __abstime)
+     __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+extern int pthread_condattr_init (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_getpshared (const pthread_condattr_t *
+     __restrict __attr,
+     int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
+     int __pshared) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_condattr_getclock (const pthread_condattr_t *
+          __restrict __attr,
+          __clockid_t *__restrict __clock_id)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
+          __clockid_t __clock_id)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 1044 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_lock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
+     const pthread_barrierattr_t *__restrict
+     __attr, unsigned int __count)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
+        __restrict __attr,
+        int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
+        int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 1111 "/mnt/odroid-c2/usr/include/pthread.h" 3 4
+extern int pthread_key_create (pthread_key_t *__key,
+          void (*__destr_function) (void *))
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_key_delete (pthread_key_t __key) throw ();
+
+
+extern void *pthread_getspecific (pthread_key_t __key) throw ();
+
+
+extern int pthread_setspecific (pthread_key_t __key,
+    const void *__pointer) throw () ;
+
+
+
+
+extern int pthread_getcpuclockid (pthread_t __thread_id,
+      __clockid_t *__clock_id)
+     throw () __attribute__ ((__nonnull__ (2)));
+# 1145 "/mnt/odroid-c2/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;
+}
+
+
+}
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 2 3
+# 47 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 3
+typedef pthread_t __gthread_t;
+typedef pthread_key_t __gthread_key_t;
+typedef pthread_once_t __gthread_once_t;
+typedef pthread_mutex_t __gthread_mutex_t;
+typedef pthread_mutex_t __gthread_recursive_mutex_t;
+typedef pthread_cond_t __gthread_cond_t;
+typedef struct timespec __gthread_time_t;
+# 101 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 3
+static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
+static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
+static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
+
+static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
+static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
+static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
+static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
+static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
+
+static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
+
+static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
+
+static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
+static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
+
+static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
+
+static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
+static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
+static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
+
+static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
+static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
+static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
+static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
+static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
+static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
+
+static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
+static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
+static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
+static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
+static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
+# 236 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 3
+static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
+# 246 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_active_p (void)
+{
+  static void *const __gthread_active_ptr
+    = __extension__ (void *) &__gthrw___pthread_key_create;
+  return __gthread_active_ptr != 0;
+}
+# 658 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
+    void *__args)
+{
+  return __gthrw_pthread_create (__threadid, __null, __func, __args);
+}
+
+static inline int
+__gthread_join (__gthread_t __threadid, void **__value_ptr)
+{
+  return __gthrw_pthread_join (__threadid, __value_ptr);
+}
+
+static inline int
+__gthread_detach (__gthread_t __threadid)
+{
+  return __gthrw_pthread_detach (__threadid);
+}
+
+static inline int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+  return __gthrw_pthread_equal (__t1, __t2);
+}
+
+static inline __gthread_t
+__gthread_self (void)
+{
+  return __gthrw_pthread_self ();
+}
+
+static inline int
+__gthread_yield (void)
+{
+  return __gthrw_sched_yield ();
+}
+
+static inline int
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_once (__once, __func);
+  else
+    return -1;
+}
+
+static inline int
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
+{
+  return __gthrw_pthread_key_create (__key, __dtor);
+}
+
+static inline int
+__gthread_key_delete (__gthread_key_t __key)
+{
+  return __gthrw_pthread_key_delete (__key);
+}
+
+static inline void *
+__gthread_getspecific (__gthread_key_t __key)
+{
+  return __gthrw_pthread_getspecific (__key);
+}
+
+static inline int
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
+{
+  return __gthrw_pthread_setspecific (__key, __ptr);
+}
+
+static inline void
+__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    __gthrw_pthread_mutex_init (__mutex, __null);
+}
+
+static inline int
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_destroy (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_lock (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_trylock (__mutex);
+  else
+    return 0;
+}
+
+
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
+      const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+
+static inline int
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_unlock (__mutex);
+  else
+    return 0;
+}
+# 807 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_lock (__mutex);
+}
+
+static inline int
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_trylock (__mutex);
+}
+
+
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+         const __gthread_time_t *__abs_timeout)
+{
+  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
+}
+
+
+static inline int
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_unlock (__mutex);
+}
+
+static inline int
+__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_destroy (__mutex);
+}
+# 849 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_broadcast (__cond);
+}
+
+static inline int
+__gthread_cond_signal (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_signal (__cond);
+}
+
+static inline int
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
+{
+  return __gthrw_pthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
+     const __gthread_time_t *__abs_timeout)
+{
+  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
+}
+
+static inline int
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+          __gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_destroy (__gthread_cond_t* __cond)
+{
+  return __gthrw_pthread_cond_destroy (__cond);
+}
+# 149 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/gthr.h" 2 3
+
+
+#pragma GCC visibility pop
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/atomicity.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/atomic_word.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/atomic_word.h" 3
+typedef int _Atomic_word;
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/atomicity.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  static inline _Atomic_word
+  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
+  { return __atomic_fetch_add(__mem, __val, 4); }
+
+  static inline void
+  __atomic_add(volatile _Atomic_word* __mem, int __val)
+  { __atomic_fetch_add(__mem, __val, 4); }
+# 64 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/atomicity.h" 3
+  static inline _Atomic_word
+  __exchange_and_add_single(_Atomic_word* __mem, int __val)
+  {
+    _Atomic_word __result = *__mem;
+    *__mem += __val;
+    return __result;
+  }
+
+  static inline void
+  __atomic_add_single(_Atomic_word* __mem, int __val)
+  { *__mem += __val; }
+
+  static inline _Atomic_word
+  __attribute__ ((__unused__))
+  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      return __exchange_and_add(__mem, __val);
+    else
+      return __exchange_and_add_single(__mem, __val);
+
+
+
+  }
+
+  static inline void
+  __attribute__ ((__unused__))
+  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      __atomic_add(__mem, __val);
+    else
+      __atomic_add_single(__mem, __val);
+
+
+
+  }
+
+
+}
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 2 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+namespace __cxx11 {
+# 70 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_string
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_CharT>::other _Char_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
+
+
+    public:
+      typedef _Traits traits_type;
+      typedef typename _Traits::char_type value_type;
+      typedef _Char_alloc_type allocator_type;
+      typedef typename _Alloc_traits::size_type size_type;
+      typedef typename _Alloc_traits::difference_type difference_type;
+      typedef typename _Alloc_traits::reference reference;
+      typedef typename _Alloc_traits::const_reference const_reference;
+      typedef typename _Alloc_traits::pointer pointer;
+      typedef typename _Alloc_traits::const_pointer const_pointer;
+      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
+       const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+
+
+      static const size_type npos = static_cast<size_type>(-1);
+
+    private:
+
+
+
+
+      typedef const_iterator __const_iterator;
+
+
+
+      struct _Alloc_hider : allocator_type
+      {
+ _Alloc_hider(pointer __dat, const _Alloc& __a = _Alloc())
+ : allocator_type(__a), _M_p(__dat) { }
+
+ pointer _M_p;
+      };
+
+      _Alloc_hider _M_dataplus;
+      size_type _M_string_length;
+
+      enum { _S_local_capacity = 15 / sizeof(_CharT) };
+
+      union
+      {
+ _CharT _M_local_buf[_S_local_capacity + 1];
+ size_type _M_allocated_capacity;
+      };
+
+      void
+      _M_data(pointer __p)
+      { _M_dataplus._M_p = __p; }
+
+      void
+      _M_length(size_type __length)
+      { _M_string_length = __length; }
+
+      pointer
+      _M_data() const
+      { return _M_dataplus._M_p; }
+
+      pointer
+      _M_local_data()
+      {
+
+ return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);
+
+
+
+      }
+
+      const_pointer
+      _M_local_data() const
+      {
+
+ return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);
+
+
+
+      }
+
+      void
+      _M_capacity(size_type __capacity)
+      { _M_allocated_capacity = __capacity; }
+
+      void
+      _M_set_length(size_type __n)
+      {
+ _M_length(__n);
+ traits_type::assign(_M_data()[__n], _CharT());
+      }
+
+      bool
+      _M_is_local() const
+      { return _M_data() == _M_local_data(); }
+
+
+      pointer
+      _M_create(size_type&, size_type);
+
+      void
+      _M_dispose()
+      {
+ if (!_M_is_local())
+   _M_destroy(_M_allocated_capacity);
+      }
+
+      void
+      _M_destroy(size_type __size) throw()
+      { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
+
+
+
+      template<typename _InIterator>
+        void
+        _M_construct_aux(_InIterator __beg, _InIterator __end,
+    std::__false_type)
+ {
+          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
+          _M_construct(__beg, __end, _Tag());
+ }
+
+
+
+      template<typename _Integer>
+        void
+        _M_construct_aux(_Integer __beg, _Integer __end, std::__true_type)
+ { _M_construct_aux_2(static_cast<size_type>(__beg), __end); }
+
+      void
+      _M_construct_aux_2(size_type __req, _CharT __c)
+      { _M_construct(__req, __c); }
+
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end)
+ {
+   typedef typename std::__is_integer<_InIterator>::__type _Integral;
+   _M_construct_aux(__beg, __end, _Integral());
+        }
+
+
+      template<typename _InIterator>
+        void
+        _M_construct(_InIterator __beg, _InIterator __end,
+       std::input_iterator_tag);
+
+
+
+      template<typename _FwdIterator>
+        void
+        _M_construct(_FwdIterator __beg, _FwdIterator __end,
+       std::forward_iterator_tag);
+
+      void
+      _M_construct(size_type __req, _CharT __c);
+
+      allocator_type&
+      _M_get_allocator()
+      { return _M_dataplus; }
+
+      const allocator_type&
+      _M_get_allocator() const
+      { return _M_dataplus; }
+
+    private:
+# 257 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      _M_check(size_type __pos, const char* __s) const
+      {
+ if (__pos > this->size())
+   __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)")
+                                         ,
+       __s, __pos, this->size());
+ return __pos;
+      }
+
+      void
+      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
+      {
+ if (this->max_size() - (this->size() - __n1) < __n2)
+   __throw_length_error((__s));
+      }
+
+
+
+      size_type
+      _M_limit(size_type __pos, size_type __off) const noexcept
+      {
+ const bool __testoff = __off < this->size() - __pos;
+ return __testoff ? __off : this->size() - __pos;
+      }
+
+
+      bool
+      _M_disjunct(const _CharT* __s) const noexcept
+      {
+ return (less<const _CharT*>()(__s, _M_data())
+  || less<const _CharT*>()(_M_data() + this->size(), __s));
+      }
+
+
+
+      static void
+      _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::copy(__d, __s, __n);
+      }
+
+      static void
+      _S_move(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::move(__d, __s, __n);
+      }
+
+      static void
+      _S_assign(_CharT* __d, size_type __n, _CharT __c)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, __c);
+ else
+   traits_type::assign(__d, __n, __c);
+      }
+
+
+
+      template<class _Iterator>
+        static void
+        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
+        {
+   for (; __k1 != __k2; ++__k1, ++__p)
+     traits_type::assign(*__p, *__k1);
+ }
+
+      static void
+      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
+      noexcept
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
+      { _S_copy(__p, __k1, __k2 - __k1); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
+      noexcept
+      { _S_copy(__p, __k1, __k2 - __k1); }
+
+      static int
+      _S_compare(size_type __n1, size_type __n2) noexcept
+      {
+ 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_assign(const basic_string& __rcs);
+
+      void
+      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+  size_type __len2);
+
+      void
+      _M_erase(size_type __pos, size_type __n);
+
+    public:
+
+
+
+
+
+
+
+      basic_string()
+
+      noexcept(is_nothrow_default_constructible<_Alloc>::value)
+
+      : _M_dataplus(_M_local_data())
+      { _M_set_length(0); }
+
+
+
+
+      explicit
+      basic_string(const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_set_length(0); }
+
+
+
+
+
+      basic_string(const basic_string& __str)
+      : _M_dataplus(_M_local_data(), __str._M_get_allocator())
+      { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
+# 410 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n = npos)
+      : _M_dataplus(_M_local_data())
+      {
+ const _CharT* __start = __str._M_data()
+   + __str._M_check(__pos, "basic_string::basic_string");
+ _M_construct(__start, __start + __str._M_limit(__pos, __n));
+      }
+# 426 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n, const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ const _CharT* __start
+   = __str._M_data() + __str._M_check(__pos, "string::string");
+ _M_construct(__start, __start + __str._M_limit(__pos, __n));
+      }
+# 444 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string(const _CharT* __s, size_type __n,
+     const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__s, __s + __n); }
+
+
+
+
+
+
+      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__s, __s ? __s + traits_type::length(__s) : __s+npos); }
+
+
+
+
+
+
+
+      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__n, __c); }
+# 476 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string(basic_string&& __str) noexcept
+      : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
+      {
+ if (__str._M_is_local())
+   {
+     traits_type::copy(_M_local_buf, __str._M_local_buf,
+         _S_local_capacity + 1);
+   }
+ else
+   {
+     _M_data(__str._M_data());
+     _M_capacity(__str._M_allocated_capacity);
+   }
+
+
+
+
+ _M_length(__str.length());
+ __str._M_data(__str._M_local_data());
+ __str._M_set_length(0);
+      }
+
+
+
+
+
+
+      basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__l.begin(), __l.end()); }
+
+      basic_string(const basic_string& __str, const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__str.begin(), __str.end()); }
+
+      basic_string(basic_string&& __str, const _Alloc& __a)
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ if (__str.get_allocator() == __a)
+   *this = std::move(__str);
+ else
+   _M_construct(__str.begin(), __str.end());
+      }
+# 529 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+
+
+
+        basic_string(_InputIterator __beg, _InputIterator __end,
+       const _Alloc& __a = _Alloc())
+ : _M_dataplus(_M_local_data(), __a)
+ { _M_construct(__beg, __end); }
+
+
+
+
+      ~basic_string()
+      { _M_dispose(); }
+
+
+
+
+
+      basic_string&
+      operator=(const basic_string& __str)
+      { return this->assign(__str); }
+
+
+
+
+
+      basic_string&
+      operator=(const _CharT* __s)
+      { return this->assign(__s); }
+# 568 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      operator=(_CharT __c)
+      {
+ this->assign(1, __c);
+ return *this;
+      }
+# 586 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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
+      { return iterator(_M_data()); }
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_M_data()); }
+
+
+
+
+
+      iterator
+      end() noexcept
+      { 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_string_length; }
+
+
+
+      size_type
+      length() const noexcept
+      { return _M_string_length; }
+
+
+      size_type
+      max_size() const noexcept
+      { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
+# 739 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      void
+      resize(size_type __n, _CharT __c);
+# 752 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      void
+      resize(size_type __n)
+      { this->resize(__n, _CharT()); }
+
+
+
+      void
+      shrink_to_fit() noexcept
+      {
+
+ if (capacity() > size())
+   {
+     try
+       { reserve(0); }
+     catch(...)
+       { }
+   }
+
+      }
+
+
+
+
+
+
+      size_type
+      capacity() const noexcept
+      {
+ return _M_is_local() ? size_type(_S_local_capacity)
+                      : _M_allocated_capacity;
+      }
+# 801 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      void
+      reserve(size_type __res_arg = 0);
+
+
+
+
+      void
+      clear() noexcept
+      { _M_set_length(0); }
+
+
+
+
+
+      bool
+      empty() const noexcept
+      { return this->size() == 0; }
+# 830 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      const_reference
+      operator[] (size_type __pos) const noexcept
+      {
+ ;
+ return _M_data()[__pos];
+      }
+# 847 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      reference
+      operator[](size_type __pos)
+      {
+
+
+ ;
+
+ ;
+ return _M_data()[__pos];
+      }
+# 868 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      const_reference
+      at(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")
+
+                            ,
+       __n, this->size());
+ return _M_data()[__n];
+      }
+# 889 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      reference
+      at(size_type __n)
+      {
+ if (__n >= size())
+   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)")
+
+                            ,
+       __n, this->size());
+ return _M_data()[__n];
+      }
+
+
+
+
+
+
+      reference
+      front() noexcept
+      { return operator[](0); }
+
+
+
+
+
+      const_reference
+      front() const noexcept
+      { return operator[](0); }
+
+
+
+
+
+      reference
+      back() noexcept
+      { return operator[](this->size() - 1); }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      { return operator[](this->size() - 1); }
+# 940 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+      { return _M_append(__str._M_data(), __str.size()); }
+# 998 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      append(const basic_string& __str, size_type __pos, size_type __n)
+      { return _M_append(__str._M_data()
+    + __str._M_check(__pos, "basic_string::append"),
+    __str._M_limit(__pos, __n)); }
+
+
+
+
+
+
+
+      basic_string&
+      append(const _CharT* __s, size_type __n)
+      {
+ ;
+ _M_check_length(size_type(0), __n, "basic_string::append");
+ return _M_append(__s, __n);
+      }
+
+
+
+
+
+
+      basic_string&
+      append(const _CharT* __s)
+      {
+ ;
+ const size_type __n = traits_type::length(__s);
+ _M_check_length(size_type(0), __n, "basic_string::append");
+ return _M_append(__s, __n);
+      }
+# 1040 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      append(size_type __n, _CharT __c)
+      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }
+
+
+
+
+
+
+
+      basic_string&
+      append(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+# 1064 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+
+
+
+        basic_string&
+        append(_InputIterator __first, _InputIterator __last)
+        { return this->replace(end(), end(), __first, __last); }
+
+
+
+
+
+      void
+      push_back(_CharT __c)
+      {
+ const size_type __size = this->size();
+ if (__size + 1 > this->capacity())
+   this->_M_mutate(__size, size_type(0), 0, size_type(1));
+ traits_type::assign(this->_M_data()[__size], __c);
+ this->_M_set_length(__size + 1);
+      }
+
+
+
+
+
+
+      basic_string&
+      assign(const basic_string& __str)
+      {
+ this->_M_assign(__str);
+ return *this;
+      }
+# 1108 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(basic_string&& __str)
+      {
+
+
+ return *this = std::move(__str);
+      }
+# 1130 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(const basic_string& __str, size_type __pos, size_type __n)
+      { return _M_replace(size_type(0), this->size(), __str._M_data()
+     + __str._M_check(__pos, "basic_string::assign"),
+     __str._M_limit(__pos, __n)); }
+# 1146 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s, size_type __n)
+      {
+ ;
+ return _M_replace(size_type(0), this->size(), __s, __n);
+      }
+# 1162 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s)
+      {
+ ;
+ return _M_replace(size_type(0), this->size(), __s,
+     traits_type::length(__s));
+      }
+# 1179 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      assign(size_type __n, _CharT __c)
+      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
+# 1192 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+
+
+
+        basic_string&
+        assign(_InputIterator __first, _InputIterator __last)
+        { return this->replace(begin(), end(), __first, __last); }
+
+
+
+
+
+
+
+      basic_string&
+      assign(initializer_list<_CharT> __l)
+      { return this->assign(__l.begin(), __l.size()); }
+# 1228 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      iterator
+      insert(const_iterator __p, size_type __n, _CharT __c)
+      {
+ ;
+ const size_type __pos = __p - begin();
+ this->replace(__p, __p, __n, __c);
+ return iterator(this->_M_data() + __pos);
+      }
+# 1270 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+        insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
+        {
+   ;
+   const size_type __pos = __p - begin();
+   this->replace(__p, __p, __beg, __end);
+   return iterator(this->_M_data() + __pos);
+ }
+# 1306 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      void
+      insert(iterator __p, initializer_list<_CharT> __l)
+      {
+ ;
+ this->insert(__p - begin(), __l.begin(), __l.size());
+      }
+# 1326 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str)
+      { return this->replace(__pos1, size_type(0),
+        __str._M_data(), __str.size()); }
+# 1349 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str,
+      size_type __pos2, size_type __n)
+      { return this->replace(__pos1, size_type(0), __str._M_data()
+        + __str._M_check(__pos2, "basic_string::insert"),
+        __str._M_limit(__pos2, __n)); }
+# 1372 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, const _CharT* __s, size_type __n)
+      { return this->replace(__pos, size_type(0), __s, __n); }
+# 1391 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, const _CharT* __s)
+      {
+ ;
+ return this->replace(__pos, size_type(0), __s,
+        traits_type::length(__s));
+      }
+# 1415 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, size_type __n, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
+         size_type(0), __n, __c); }
+# 1433 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      iterator
+      insert(__const_iterator __p, _CharT __c)
+      {
+ ;
+ const size_type __pos = __p - begin();
+ _M_replace_aux(__pos, size_type(0), size_type(1), __c);
+ return iterator(_M_data() + __pos);
+      }
+# 1457 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      erase(size_type __pos = 0, size_type __n = npos)
+      {
+ this->_M_erase(_M_check(__pos, "basic_string::erase"),
+         _M_limit(__pos, __n));
+ return *this;
+      }
+# 1473 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      iterator
+      erase(__const_iterator __position)
+      {
+
+                           ;
+ const size_type __pos = __position - begin();
+ this->_M_erase(__pos, size_type(1));
+ return iterator(_M_data() + __pos);
+      }
+# 1492 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      iterator
+      erase(__const_iterator __first, __const_iterator __last)
+      {
+
+                        ;
+        const size_type __pos = __first - begin();
+ this->_M_erase(__pos, __last - __first);
+ return iterator(this->_M_data() + __pos);
+      }
+
+
+
+
+
+
+
+      void
+      pop_back() noexcept
+      { _M_erase(size()-1, 1); }
+# 1530 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n, const basic_string& __str)
+      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
+# 1552 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2)
+      { return this->replace(__pos1, __n1, __str._M_data()
+        + __str._M_check(__pos2, "basic_string::replace"),
+        __str._M_limit(__pos2, __n2)); }
+# 1577 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2)
+      {
+ ;
+ return _M_replace(_M_check(__pos, "basic_string::replace"),
+     _M_limit(__pos, __n1), __s, __n2);
+      }
+# 1602 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s)
+      {
+ ;
+ return this->replace(__pos, __n1, __s, traits_type::length(__s));
+      }
+# 1626 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
+         _M_limit(__pos, __n1), __n2, __c); }
+# 1644 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const basic_string& __str)
+      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
+# 1664 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const _CharT* __s, size_type __n)
+      {
+
+                      ;
+ return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
+      }
+# 1686 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
+      {
+ ;
+ return this->replace(__i1, __i2, __s, traits_type::length(__s));
+      }
+# 1707 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
+       _CharT __c)
+      {
+
+                      ;
+ return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
+      }
+# 1732 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      template<class _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        basic_string&
+        replace(const_iterator __i1, const_iterator __i2,
+  _InputIterator __k1, _InputIterator __k2)
+        {
+  
+                        ;
+   ;
+   return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
+        std::__false_type());
+ }
+# 1764 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       _CharT* __k1, _CharT* __k2)
+      {
+
+                      ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const _CharT* __k1, const _CharT* __k2)
+      {
+
+                      ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       iterator __k1, iterator __k2)
+      {
+
+                      ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+
+      basic_string&
+      replace(__const_iterator __i1, __const_iterator __i2,
+       const_iterator __k1, const_iterator __k2)
+      {
+
+                      ;
+ ;
+ return this->replace(__i1 - begin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+# 1823 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string& replace(const_iterator __i1, const_iterator __i2,
+       initializer_list<_CharT> __l)
+      { return this->replace(__i1, __i2, __l.begin(), __l.end()); }
+
+
+    private:
+      template<class _Integer>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _Integer __n, _Integer __val, __true_type)
+        { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
+
+      template<class _InputIterator>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _InputIterator __k1, _InputIterator __k2,
+       __false_type);
+
+      basic_string&
+      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+       _CharT __c);
+
+      basic_string&
+      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+   const size_type __len2);
+
+      basic_string&
+      _M_append(const _CharT* __s, size_type __n);
+
+    public:
+# 1866 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
+# 1876 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      void
+      swap(basic_string& __s) noexcept;
+# 1886 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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_get_allocator(); }
+# 1919 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos, size_type __n) const;
+# 1932 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()); }
+# 1947 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const
+      {
+ ;
+ return this->find(__s, __pos, traits_type::length(__s));
+      }
+# 1964 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find(_CharT __c, size_type __pos = 0) const noexcept;
+# 1977 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()); }
+# 1994 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+# 2007 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->rfind(__s, __pos, traits_type::length(__s));
+      }
+# 2024 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const noexcept;
+# 2038 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()); }
+# 2055 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
+# 2068 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos = 0) const
+      {
+ ;
+ return this->find_first_of(__s, __pos, traits_type::length(__s));
+      }
+# 2087 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
+      { return this->find(__c, __pos); }
+# 2102 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()); }
+# 2119 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
+# 2132 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->find_last_of(__s, __pos, traits_type::length(__s));
+      }
+# 2151 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
+      { return this->rfind(__c, __pos); }
+# 2165 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()); }
+# 2182 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos,
+   size_type __n) const;
+# 2196 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+      {
+ ;
+ return this->find_first_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2213 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const
+ noexcept;
+# 2228 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()); }
+# 2245 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos,
+         size_type __n) const;
+# 2259 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->find_last_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2276 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const
+ noexcept;
+# 2292 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      basic_string
+      substr(size_type __pos = 0, size_type __n = npos) const
+      { return basic_string(*this,
+       _M_check(__pos, "basic_string::substr"), __n); }
+# 2311 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      int
+      compare(const basic_string& __str) const
+      {
+ const size_type __size = this->size();
+ const size_type __osize = __str.size();
+ const size_type __len = std::min(__size, __osize);
+
+ int __r = traits_type::compare(_M_data(), __str.data(), __len);
+ if (!__r)
+   __r = _S_compare(__size, __osize);
+ return __r;
+      }
+# 2343 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n, const basic_string& __str) const;
+# 2369 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      int
+      compare(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2) const;
+# 2387 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      int
+      compare(const _CharT* __s) const;
+# 2411 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
+# 2438 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2) const;
+  };
+}
+# 4781 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)); }
+# 4902 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+# 4948 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return !(__lhs == __rhs); }
+# 4985 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) > 0; }
+# 5022 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) < 0; }
+# 5059 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) >= 0; }
+# 5096 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const _CharT* __lhs,
+      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) <= 0; }
+# 5133 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline void
+    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
+  basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+# 5152 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 5170 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+        const basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+
+
+      return __ostream_insert(__os, __str.data(), __str.size());
+    }
+# 5193 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
+# 5210 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return std::getline(__is, __str, __is.widen('\n')); }
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>&& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    { return std::getline(__is, __str, __delim); }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>&& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return std::getline(__is, __str); }
+
+
+  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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/string_conversions.h" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/string_conversions.h" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/string_conversions.h" 3
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/string_conversions.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdlib" 3
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/string_conversions.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 3
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/wchar.h" 1 3 4
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwchar" 2 3
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/string_conversions.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdio" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdio" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdio" 3
+
+
+# 1 "/mnt/odroid-c2/usr/include/stdio.h" 1 3 4
+# 29 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern "C" {
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 34 "/mnt/odroid-c2/usr/include/stdio.h" 2 3 4
+# 74 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/libio.h" 1 3 4
+# 31 "/mnt/odroid-c2/usr/include/libio.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/_G_config.h" 1 3 4
+# 15 "/mnt/odroid-c2/usr/include/_G_config.h" 3 4
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 16 "/mnt/odroid-c2/usr/include/_G_config.h" 2 3 4
+
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/wchar.h" 1 3 4
+# 21 "/mnt/odroid-c2/usr/include/_G_config.h" 2 3 4
+typedef struct
+{
+  __off_t __pos;
+  __mbstate_t __state;
+} _G_fpos_t;
+typedef struct
+{
+  __off64_t __pos;
+  __mbstate_t __state;
+} _G_fpos64_t;
+# 32 "/mnt/odroid-c2/usr/include/libio.h" 2 3 4
+# 49 "/mnt/odroid-c2/usr/include/libio.h" 3 4
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stdarg.h" 1 3 4
+# 50 "/mnt/odroid-c2/usr/include/libio.h" 2 3 4
+# 144 "/mnt/odroid-c2/usr/include/libio.h" 3 4
+struct _IO_jump_t; struct _IO_FILE;
+
+
+
+
+
+typedef void _IO_lock_t;
+
+
+
+
+
+struct _IO_marker {
+  struct _IO_marker *_next;
+  struct _IO_FILE *_sbuf;
+
+
+
+  int _pos;
+# 173 "/mnt/odroid-c2/usr/include/libio.h" 3 4
+};
+
+
+enum __codecvt_result
+{
+  __codecvt_ok,
+  __codecvt_partial,
+  __codecvt_error,
+  __codecvt_noconv
+};
+# 241 "/mnt/odroid-c2/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;
+# 289 "/mnt/odroid-c2/usr/include/libio.h" 3 4
+  __off64_t _offset;
+
+
+
+
+
+
+
+  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_;
+# 333 "/mnt/odroid-c2/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);
+# 429 "/mnt/odroid-c2/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 ();
+# 459 "/mnt/odroid-c2/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 ();
+# 521 "/mnt/odroid-c2/usr/include/libio.h" 3 4
+}
+# 75 "/mnt/odroid-c2/usr/include/stdio.h" 2 3 4
+
+
+
+
+typedef __gnuc_va_list va_list;
+# 108 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+
+
+typedef _G_fpos_t fpos_t;
+
+
+
+
+
+typedef _G_fpos64_t fpos64_t;
+# 164 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/stdio_lim.h" 1 3 4
+# 165 "/mnt/odroid-c2/usr/include/stdio.h" 2 3 4
+
+
+
+extern struct _IO_FILE *stdin;
+extern struct _IO_FILE *stdout;
+extern struct _IO_FILE *stderr;
+
+
+
+
+
+
+
+extern int remove (const char *__filename) throw ();
+
+extern int rename (const char *__old, const char *__new) throw ();
+
+
+
+
+extern int renameat (int __oldfd, const char *__old, int __newfd,
+       const char *__new) throw ();
+
+
+
+
+
+
+
+
+extern FILE *tmpfile (void) ;
+# 205 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern FILE *tmpfile64 (void) ;
+
+
+
+extern char *tmpnam (char *__s) throw () ;
+
+
+
+
+
+extern char *tmpnam_r (char *__s) throw () ;
+# 227 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern char *tempnam (const char *__dir, const char *__pfx)
+     throw () __attribute__ ((__malloc__)) ;
+
+
+
+
+
+
+
+
+extern int fclose (FILE *__stream);
+
+
+
+
+extern int fflush (FILE *__stream);
+
+# 252 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern int fflush_unlocked (FILE *__stream);
+# 262 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern int fcloseall (void);
+
+
+
+
+
+
+
+
+
+extern FILE *fopen (const char *__restrict __filename,
+      const char *__restrict __modes) ;
+
+
+
+
+extern FILE *freopen (const char *__restrict __filename,
+        const char *__restrict __modes,
+        FILE *__restrict __stream) ;
+# 295 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+
+
+extern FILE *fopen64 (const char *__restrict __filename,
+        const char *__restrict __modes) ;
+extern FILE *freopen64 (const char *__restrict __filename,
+   const char *__restrict __modes,
+   FILE *__restrict __stream) ;
+
+
+
+
+extern FILE *fdopen (int __fd, const char *__modes) throw () ;
+
+
+
+
+
+extern FILE *fopencookie (void *__restrict __magic_cookie,
+     const char *__restrict __modes,
+     _IO_cookie_io_functions_t __io_funcs) throw () ;
+
+
+
+
+extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
+  throw () ;
+
+
+
+
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
+
+
+
+
+
+
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
+
+
+
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+      int __modes, size_t __n) throw ();
+
+
+
+
+
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+         size_t __size) throw ();
+
+
+extern void setlinebuf (FILE *__stream) throw ();
+
+
+
+
+
+
+
+
+extern int fprintf (FILE *__restrict __stream,
+      const char *__restrict __format, ...);
+
+
+
+
+extern int printf (const char *__restrict __format, ...);
+
+extern int sprintf (char *__restrict __s,
+      const char *__restrict __format, ...) throw ();
+
+
+
+
+
+extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg);
+
+
+
+
+extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
+
+extern int vsprintf (char *__restrict __s, const char *__restrict __format,
+       __gnuc_va_list __arg) throw ();
+
+
+
+
+
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+       const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
+
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+        const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
+
+
+
+
+
+
+extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
+        __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
+extern int __asprintf (char **__restrict __ptr,
+         const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
+extern int asprintf (char **__restrict __ptr,
+       const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
+
+
+
+
+extern int vdprintf (int __fd, const char *__restrict __fmt,
+       __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, const char *__restrict __fmt, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+
+
+
+
+
+
+
+
+extern int fscanf (FILE *__restrict __stream,
+     const char *__restrict __format, ...) ;
+
+
+
+
+extern int scanf (const char *__restrict __format, ...) ;
+
+extern int sscanf (const char *__restrict __s,
+     const char *__restrict __format, ...) throw ();
+# 463 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+
+
+
+
+
+
+
+
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
+      __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+
+
+
+
+
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+
+
+extern int vsscanf (const char *__restrict __s,
+      const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
+# 522 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+
+
+
+
+
+
+
+
+
+extern int fgetc (FILE *__stream);
+extern int getc (FILE *__stream);
+
+
+
+
+
+extern int getchar (void);
+
+# 550 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern int getc_unlocked (FILE *__stream);
+extern int getchar_unlocked (void);
+# 561 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern int fgetc_unlocked (FILE *__stream);
+
+
+
+
+
+
+
+
+
+
+
+extern int fputc (int __c, FILE *__stream);
+extern int putc (int __c, FILE *__stream);
+
+
+
+
+
+extern int putchar (int __c);
+
+# 594 "/mnt/odroid-c2/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)
+     ;
+# 640 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+
+# 649 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern char *fgets_unlocked (char *__restrict __s, int __n,
+        FILE *__restrict __stream) ;
+# 665 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern __ssize_t __getdelim (char **__restrict __lineptr,
+          size_t *__restrict __n, int __delimiter,
+          FILE *__restrict __stream) ;
+extern __ssize_t getdelim (char **__restrict __lineptr,
+        size_t *__restrict __n, int __delimiter,
+        FILE *__restrict __stream) ;
+
+
+
+
+
+
+
+extern __ssize_t getline (char **__restrict __lineptr,
+       size_t *__restrict __n,
+       FILE *__restrict __stream) ;
+
+
+
+
+
+
+
+
+extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
+
+
+
+
+
+extern int puts (const char *__s);
+
+
+
+
+
+
+extern int ungetc (int __c, FILE *__stream);
+
+
+
+
+
+
+extern size_t fread (void *__restrict __ptr, size_t __size,
+       size_t __n, FILE *__restrict __stream) ;
+
+
+
+
+extern size_t fwrite (const void *__restrict __ptr, size_t __size,
+        size_t __n, FILE *__restrict __s);
+
+# 726 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern int fputs_unlocked (const char *__restrict __s,
+      FILE *__restrict __stream);
+# 737 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+         size_t __n, FILE *__restrict __stream) ;
+extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
+          size_t __n, FILE *__restrict __stream);
+
+
+
+
+
+
+
+
+extern int fseek (FILE *__stream, long int __off, int __whence);
+
+
+
+
+extern long int ftell (FILE *__stream) ;
+
+
+
+
+extern void rewind (FILE *__stream);
+
+# 773 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+extern int fseeko (FILE *__stream, __off_t __off, int __whence);
+
+
+
+
+extern __off_t ftello (FILE *__stream) ;
+# 792 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+
+
+
+
+
+
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
+
+
+
+
+extern int fsetpos (FILE *__stream, const fpos_t *__pos);
+# 815 "/mnt/odroid-c2/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 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/sys_errlist.h" 1 3 4
+# 26 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/sys_errlist.h" 3 4
+extern int sys_nerr;
+extern const char *const sys_errlist[];
+
+
+extern int _sys_nerr;
+extern const char *const _sys_errlist[];
+# 854 "/mnt/odroid-c2/usr/include/stdio.h" 2 3 4
+
+
+
+
+extern int fileno (FILE *__stream) throw () ;
+
+
+
+
+extern int fileno_unlocked (FILE *__stream) throw () ;
+# 872 "/mnt/odroid-c2/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 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/stdio.h" 1 3 4
+# 35 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/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 "/mnt/odroid-c2/usr/include/stdio.h" 2 3 4
+# 942 "/mnt/odroid-c2/usr/include/stdio.h" 3 4
+}
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdio" 2 3
+# 96 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 ::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;
+}
+# 157 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cstdio" 3
+namespace __gnu_cxx
+{
+# 175 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+}
+# 44 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/string_conversions.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cerrno" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cerrno" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cerrno" 3
+
+# 1 "/mnt/odroid-c2/usr/include/errno.h" 1 3 4
+# 31 "/mnt/odroid-c2/usr/include/errno.h" 3 4
+extern "C" {
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/errno.h" 1 3 4
+# 24 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/errno.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/linux/errno.h" 1 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/asm/errno.h" 1 3 4
+# 1 "/mnt/odroid-c2/usr/include/asm-generic/errno.h" 1 3 4
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/asm-generic/errno-base.h" 1 3 4
+# 5 "/mnt/odroid-c2/usr/include/asm-generic/errno.h" 2 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/asm/errno.h" 2 3 4
+# 1 "/mnt/odroid-c2/usr/include/linux/errno.h" 2 3 4
+# 25 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/errno.h" 2 3 4
+# 50 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/errno.h" 3 4
+extern int *__errno_location (void) throw () __attribute__ ((__const__));
+# 36 "/mnt/odroid-c2/usr/include/errno.h" 2 3 4
+# 54 "/mnt/odroid-c2/usr/include/errno.h" 3 4
+extern char *program_invocation_name, *program_invocation_short_name;
+
+
+
+}
+# 68 "/mnt/odroid-c2/usr/include/errno.h" 3 4
+typedef int error_t;
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cerrno" 2 3
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+    }
+
+
+}
+# 5250 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __cxx11 {
+
+
+  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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/functional_hash.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/functional_hash.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/functional_hash.h" 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/hash_bytes.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/hash_bytes.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/functional_hash.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 49 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+
+
+  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); }
+    };
+# 80 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    };
+
+
+
+
+
+
+
+  template<typename _Hash>
+    struct __is_fast_hash : public std::true_type
+    { };
+
+  template<>
+    struct __is_fast_hash<hash<long double>> : public std::false_type
+    { };
+
+
+}
+# 5472 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 __is_fast_hash<hash<string>> : std::false_type
+    { };
+
+
+
+  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 __is_fast_hash<hash<wstring>> : std::false_type
+    { };
+
+
+
+
+
+  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 __is_fast_hash<hash<u16string>> : std::false_type
+    { };
+
+
+  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)); }
+    };
+
+  template<>
+    struct __is_fast_hash<hash<u32string>> : std::false_type
+    { };
+
+
+
+
+
+
+  inline namespace literals
+  {
+  inline namespace string_literals
+  {
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char>
+    operator""s(const char* __str, size_t __len)
+    { return basic_string<char>{__str, __len}; }
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<wchar_t>
+    operator""s(const wchar_t* __str, size_t __len)
+    { return basic_string<wchar_t>{__str, __len}; }
+
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char16_t>
+    operator""s(const char16_t* __str, size_t __len)
+    { return basic_string<char16_t>{__str, __len}; }
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    inline basic_string<char32_t>
+    operator""s(const char32_t* __str, size_t __len)
+    { return basic_string<char32_t>{__str, __len}; }
+
+
+  }
+  }
+
+
+
+
+}
+# 53 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.tcc" 1 3
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.tcc" 3
+       
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::npos;
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    swap(basic_string& __s) noexcept
+    {
+      if (this == &__s)
+ return;
+
+
+
+
+      std::__alloc_swap<allocator_type>::_S_do_it(_M_get_allocator(),
+        __s._M_get_allocator());
+
+      if (_M_is_local())
+ if (__s._M_is_local())
+   {
+     if (length() && __s.length())
+       {
+  _CharT __tmp_data[_S_local_capacity + 1];
+  traits_type::copy(__tmp_data, __s._M_local_buf,
+      _S_local_capacity + 1);
+  traits_type::copy(__s._M_local_buf, _M_local_buf,
+      _S_local_capacity + 1);
+  traits_type::copy(_M_local_buf, __tmp_data,
+      _S_local_capacity + 1);
+       }
+     else if (__s.length())
+       {
+  traits_type::copy(_M_local_buf, __s._M_local_buf,
+      _S_local_capacity + 1);
+  _M_length(__s.length());
+  __s._M_set_length(0);
+  return;
+       }
+     else if (length())
+       {
+  traits_type::copy(__s._M_local_buf, _M_local_buf,
+      _S_local_capacity + 1);
+  __s._M_length(length());
+  _M_set_length(0);
+  return;
+       }
+   }
+ else
+   {
+     const size_type __tmp_capacity = __s._M_allocated_capacity;
+     traits_type::copy(__s._M_local_buf, _M_local_buf,
+         _S_local_capacity + 1);
+     _M_data(__s._M_data());
+     __s._M_data(__s._M_local_buf);
+     _M_capacity(__tmp_capacity);
+   }
+      else
+ {
+   const size_type __tmp_capacity = _M_allocated_capacity;
+   if (__s._M_is_local())
+     {
+       traits_type::copy(_M_local_buf, __s._M_local_buf,
+    _S_local_capacity + 1);
+       __s._M_data(_M_data());
+       _M_data(_M_local_buf);
+     }
+   else
+     {
+       pointer __tmp_ptr = _M_data();
+       _M_data(__s._M_data());
+       __s._M_data(__tmp_ptr);
+       _M_capacity(__s._M_allocated_capacity);
+     }
+   __s._M_capacity(__tmp_capacity);
+ }
+
+      const size_type __tmp_length = length();
+      _M_length(__s.length());
+      __s._M_length(__tmp_length);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::pointer
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_create(size_type& __capacity, size_type __old_capacity)
+    {
+
+
+      if (__capacity > max_size())
+ std::__throw_length_error(("basic_string::_M_create"));
+
+
+
+
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
+ {
+   __capacity = 2 * __old_capacity;
+
+   if (__capacity > max_size())
+     __capacity = max_size();
+ }
+
+
+
+      return _Alloc_traits::allocate(_M_get_allocator(), __capacity + 1);
+    }
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+     std::input_iterator_tag)
+      {
+ size_type __len = 0;
+ size_type __capacity = size_type(_S_local_capacity);
+
+ while (__beg != __end && __len < __capacity)
+   {
+     _M_data()[__len++] = *__beg;
+     ++__beg;
+   }
+
+ try
+   {
+     while (__beg != __end)
+       {
+  if (__len == __capacity)
+    {
+
+      __capacity = __len + 1;
+      pointer __another = _M_create(__capacity, __len);
+      this->_S_copy(__another, _M_data(), __len);
+      _M_dispose();
+      _M_data(__another);
+      _M_capacity(__capacity);
+    }
+  _M_data()[__len++] = *__beg;
+  ++__beg;
+       }
+   }
+ catch(...)
+   {
+     _M_dispose();
+     throw;
+   }
+
+ _M_set_length(__len);
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      void
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_construct(_InIterator __beg, _InIterator __end,
+     std::forward_iterator_tag)
+      {
+
+ if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
+   std::__throw_logic_error(("basic_string::" "_M_construct null not valid")
+                                         );
+
+ size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));
+
+ if (__dnew > size_type(_S_local_capacity))
+   {
+     _M_data(_M_create(__dnew, size_type(0)));
+     _M_capacity(__dnew);
+   }
+
+
+ try
+   { this->_S_copy_chars(_M_data(), __beg, __end); }
+ catch(...)
+   {
+     _M_dispose();
+     throw;
+   }
+
+ _M_set_length(__dnew);
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_construct(size_type __n, _CharT __c)
+    {
+      if (__n > size_type(_S_local_capacity))
+ {
+   _M_data(_M_create(__n, size_type(0)));
+   _M_capacity(__n);
+ }
+
+      if (__n)
+ this->_S_assign(_M_data(), __n, __c);
+
+      _M_set_length(__n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_assign(const basic_string& __str)
+    {
+      if (this != &__str)
+ {
+   const size_type __rsize = __str.length();
+   const size_type __capacity = capacity();
+
+   if (__rsize > __capacity)
+     {
+       size_type __new_capacity = __rsize;
+       pointer __tmp = _M_create(__new_capacity, __capacity);
+       _M_dispose();
+       _M_data(__tmp);
+       _M_capacity(__new_capacity);
+     }
+
+   if (__rsize)
+     this->_S_copy(_M_data(), __str._M_data(), __rsize);
+
+   _M_set_length(__rsize);
+ }
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    reserve(size_type __res)
+    {
+
+      if (__res < length())
+ __res = length();
+
+      const size_type __capacity = capacity();
+      if (__res != __capacity)
+ {
+   if (__res > __capacity
+       || __res > size_type(_S_local_capacity))
+     {
+       pointer __tmp = _M_create(__res, __capacity);
+       this->_S_copy(__tmp, _M_data(), length() + 1);
+       _M_dispose();
+       _M_data(__tmp);
+       _M_capacity(__res);
+     }
+   else if (!_M_is_local())
+     {
+       this->_S_copy(_M_local_data(), _M_data(), length() + 1);
+       _M_destroy(__capacity);
+       _M_data(_M_local_data());
+     }
+ }
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
+       size_type __len2)
+    {
+      const size_type __how_much = length() - __pos - __len1;
+
+      size_type __new_capacity = length() + __len2 - __len1;
+      pointer __r = _M_create(__new_capacity, capacity());
+
+      if (__pos)
+ this->_S_copy(__r, _M_data(), __pos);
+      if (__s && __len2)
+ this->_S_copy(__r + __pos, __s, __len2);
+      if (__how_much)
+ this->_S_copy(__r + __pos + __len2,
+        _M_data() + __pos + __len1, __how_much);
+
+      _M_dispose();
+      _M_data(__r);
+      _M_capacity(__new_capacity);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_erase(size_type __pos, size_type __n)
+    {
+      const size_type __how_much = length() - __pos - __n;
+
+      if (__how_much && __n)
+ this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);
+
+      _M_set_length(length() - __n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    resize(size_type __n, _CharT __c)
+    {
+      const size_type __size = this->size();
+      if (__size < __n)
+ this->append(__n - __size, __c);
+      else if (__n < __size)
+ this->_M_erase(__n, __size - __n);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_append(const _CharT* __s, size_type __n)
+    {
+      const size_type __len = __n + this->size();
+
+      if (__len <= this->capacity())
+ {
+   if (__n)
+     this->_S_copy(this->_M_data() + this->size(), __s, __n);
+ }
+      else
+ this->_M_mutate(this->size(), size_type(0), __s, __n);
+
+      this->_M_set_length(__len);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+      basic_string<_CharT, _Traits, _Alloc>&
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+     _InputIterator __k1, _InputIterator __k2,
+     std::__false_type)
+      {
+ const basic_string __s(__k1, __k2);
+ const size_type __n1 = __i2 - __i1;
+ return _M_replace(__i1 - begin(), __n1, __s._M_data(),
+     __s.size());
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+     _CharT __c)
+    {
+      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
+
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __n2 - __n1;
+
+      if (__new_size <= this->capacity())
+ {
+   _CharT* __p = this->_M_data() + __pos1;
+
+   const size_type __how_much = __old_size - __pos1 - __n1;
+   if (__how_much && __n1 != __n2)
+     this->_S_move(__p + __n2, __p + __n1, __how_much);
+ }
+      else
+ this->_M_mutate(__pos1, __n1, 0, __n2);
+
+      if (__n2)
+ this->_S_assign(this->_M_data() + __pos1, __n2, __c);
+
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+        const size_type __len2)
+    {
+      _M_check_length(__len1, __len2, "basic_string::_M_replace");
+
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __len2 - __len1;
+
+      if (__new_size <= this->capacity())
+ {
+   _CharT* __p = this->_M_data() + __pos;
+
+   const size_type __how_much = __old_size - __pos - __len1;
+   if (_M_disjunct(__s))
+     {
+       if (__how_much && __len1 != __len2)
+  this->_S_move(__p + __len2, __p + __len1, __how_much);
+       if (__len2)
+  this->_S_copy(__p, __s, __len2);
+     }
+   else
+     {
+
+       if (__len2 && __len2 <= __len1)
+  this->_S_move(__p, __s, __len2);
+       if (__how_much && __len1 != __len2)
+  this->_S_move(__p + __len2, __p + __len1, __how_much);
+       if (__len2 > __len1)
+  {
+    if (__s + __len2 <= __p + __len1)
+      this->_S_move(__p, __s, __len2);
+    else if (__s >= __p + __len1)
+      this->_S_copy(__p, __s + __len2 - __len1, __len2);
+    else
+      {
+        const size_type __nleft = (__p + __len1) - __s;
+        this->_S_move(__p, __s, __nleft);
+        this->_S_copy(__p + __nleft, __p + __len2,
+        __len2 - __nleft);
+      }
+  }
+     }
+ }
+      else
+ this->_M_mutate(__pos, __len1, __s, __len2);
+
+      this->_M_set_length(__new_size);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    copy(_CharT* __s, size_type __n, size_type __pos) const
+    {
+      _M_check(__pos, "basic_string::copy");
+      __n = _M_limit(__pos, __n);
+      ;
+      if (__n)
+ _S_copy(__s, _M_data() + __pos, __n);
+
+      return __n;
+    }
+# 1149 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_string.tcc" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      ;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      const __size_type __len = _Traits::length(__lhs);
+      __string_type __str;
+      __str.reserve(__len + __rhs.size());
+      __str.append(__lhs, __len);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str;
+      const __size_type __len = __rhs.size();
+      __str.reserve(__len + 1);
+      __str.append(__size_type(1), __lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  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&);
+
+
+
+
+}
+# 54 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/string" 2 3
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 2 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/limits" 1 3
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/limits" 3
+       
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/limits" 3
+# 158 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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
+  };
+# 202 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+# 288 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/limits" 3
+    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;
+  };
+# 314 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/limits" 3
+  template<typename _Tp>
+    struct numeric_limits : public __numeric_limits_base
+    {
+
+
+      static constexpr _Tp
+      min() noexcept { return _Tp(); }
+
+
+      static constexpr _Tp
+      max() noexcept { return _Tp(); }
+
+
+
+
+      static constexpr _Tp
+      lowest() noexcept { return _Tp(); }
+
+
+
+
+      static constexpr _Tp
+      epsilon() noexcept { return _Tp(); }
+
+
+      static constexpr _Tp
+      round_error() noexcept { return _Tp(); }
+
+
+      static constexpr _Tp
+      infinity() noexcept { return _Tp(); }
+
+
+
+      static constexpr _Tp
+      quiet_NaN() noexcept { return _Tp(); }
+
+
+
+      static constexpr _Tp
+      signaling_NaN() noexcept { return _Tp(); }
+
+
+
+
+      static constexpr _Tp
+      denorm_min() noexcept { return _Tp(); }
+    };
+
+
+  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 = !is_signed;
+
+      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 -0x7f - 1; }
+
+      static constexpr signed char
+      max() noexcept { return 0x7f; }
+
+
+      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 = 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<unsigned char>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned char
+      min() noexcept { return 0; }
+
+      static constexpr unsigned char
+      max() noexcept { return 0x7f * 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 = !is_signed;
+
+      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 = !is_signed;
+
+      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 = !is_signed;
+
+      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 -0x7fff - 1; }
+
+      static constexpr short
+      max() noexcept { return 0x7fff; }
+
+
+      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 = 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<unsigned short>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned short
+      min() noexcept { return 0; }
+
+      static constexpr unsigned short
+      max() noexcept { return 0x7fff * 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 -0x7fffffff - 1; }
+
+      static constexpr int
+      max() noexcept { return 0x7fffffff; }
+
+
+      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 = 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<unsigned int>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned int
+      min() noexcept { return 0; }
+
+      static constexpr unsigned int
+      max() noexcept { return 0x7fffffff * 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 -0x7fffffffffffffffL - 1; }
+
+      static constexpr long
+      max() noexcept { return 0x7fffffffffffffffL; }
+
+
+      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 = 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<unsigned long>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr unsigned long
+      min() noexcept { return 0; }
+
+      static constexpr unsigned long
+      max() noexcept { return 0x7fffffffffffffffL * 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 -0x7fffffffffffffffLL - 1; }
+
+      static constexpr long long
+      max() noexcept { return 0x7fffffffffffffffLL; }
+
+
+      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 = 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<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 0x7fffffffffffffffLL * 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;
+    };
+# 1592 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/limits" 3
+  template<>
+    struct numeric_limits<float>
+    {
+      static constexpr bool is_specialized = true;
+
+      static constexpr float
+      min() noexcept { return 1.17549435082228750796873653722224568e-38F; }
+
+      static constexpr float
+      max() noexcept { return 3.40282346638528859811704183484516925e+38F; }
+
+
+      static constexpr float
+      lowest() noexcept { return -3.40282346638528859811704183484516925e+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.19209289550781250000000000000000000e-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.40129846432481707092372958328991613e-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.22507385850720138309023271733240406e-308L); }
+
+      static constexpr double
+      max() noexcept { return double(1.79769313486231570814527423731704357e+308L); }
+
+
+      static constexpr double
+      lowest() noexcept { return -double(1.79769313486231570814527423731704357e+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.22044604925031308084726333618164062e-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.94065645841246544176568792868221372e-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.36210314311209350626267781732175260e-4932L; }
+
+      static constexpr long double
+      max() noexcept { return 1.18973149535723176508575932662800702e+4932L; }
+
+
+      static constexpr long double
+      lowest() noexcept { return -1.18973149535723176508575932662800702e+4932L; }
+
+
+      static constexpr int digits = 113;
+      static constexpr int digits10 = 33;
+
+      static constexpr int max_digits10
+  = (2 + (113) * 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.92592994438723585305597794258492732e-34L; }
+
+      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 6.47517511943802511092443895822764655e-4966L; }
+
+      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;
+    };
+
+
+
+
+
+
+}
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 2 3
+
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/random.h" 1 3
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/random.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/vector" 1 3
+# 58 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/vector" 3
+       
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/vector" 3
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_uninitialized.h" 1 3
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+    };
+# 105 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+
+
+
+
+      typedef typename iterator_traits<_InputIterator>::reference _RefType1;
+      typedef typename iterator_traits<_ForwardIterator>::reference _RefType2;
+      const bool __assignable = is_assignable<_RefType2, _RefType1>::value;
+
+
+      return std::__uninitialized_copy<__is_trivial(_ValueType1)
+           && __is_trivial(_ValueType2)
+           && __assignable>::
+ __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); }
+    };
+# 171 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+
+
+
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+
+      std::__uninitialized_fill<__is_trivial(_ValueType) && __assignable>::
+ __uninit_fill(__first, __last, __x);
+    }
+
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_fill_n
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static _ForwardIterator
+        __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);
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_fill_n<true>
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static _ForwardIterator
+        __uninit_fill_n(_ForwardIterator __first, _Size __n,
+   const _Tp& __x)
+        { return std::fill_n(__first, __n, __x); }
+    };
+# 234 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_uninitialized.h" 3
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator
+    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
+ __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>
+    _ForwardIterator
+    __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);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Tp2>
+    inline _ForwardIterator
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, allocator<_Tp2>&)
+    { return std::uninitialized_fill_n(__first, __n, __x); }
+# 370 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 _ForwardIterator
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, ++__cur)
+  std::_Construct(std::__addressof(*__cur));
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_default_n_1<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __uninit_default_n(_ForwardIterator __first, _Size __n)
+        {
+   typedef typename iterator_traits<_ForwardIterator>::value_type
+     _ValueType;
+
+   return 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;
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      std::__uninitialized_default_1<__is_trivial(_ValueType)
+         && __assignable>::
+ __uninit_default(__first, __last);
+    }
+
+
+
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    __uninitialized_default_n(_ForwardIterator __first, _Size __n)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      return __uninitialized_default_n_1<__is_trivial(_ValueType)
+           && __assignable>::
+ __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>
+    _ForwardIterator
+    __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));
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
+    allocator<_Tp>&)
+    { return 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); }
+# 677 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)); }
+
+
+
+}
+# 64 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/vector" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 1 3
+# 66 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(), _M_finish(), _M_end_of_storage()
+ { }
+
+ _Vector_impl(_Tp_alloc_type const& __a) noexcept
+ : _Tp_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ _Vector_impl(_Tp_alloc_type&& __a) noexcept
+ : _Tp_alloc_type(std::move(__a)),
+   _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ void _M_swap_data(_Vector_impl& __x) noexcept
+ {
+   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) noexcept
+      : _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) noexcept
+      : _M_impl(std::move(__a)) { }
+
+      _Vector_base(_Vector_base&& __x) noexcept
+      : _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() noexcept
+      { _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)
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+ return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
+      }
+
+      void
+      _M_deallocate(pointer __p, size_t __n)
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
+ if (__p)
+   _Tr::deallocate(_M_impl, __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;
+      }
+    };
+# 213 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()
+
+      noexcept(is_nothrow_default_constructible<_Alloc>::value)
+
+      : _Base() { }
+
+
+
+
+
+      explicit
+      vector(const allocator_type& __a) noexcept
+      : _Base(__a) { }
+# 276 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      explicit
+      vector(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_default_initialize(__n); }
+# 289 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 318 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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());
+      }
+# 335 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+      noexcept(_Alloc_traits::_S_always_equal())
+      : _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();
+   }
+      }
+# 373 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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());
+      }
+# 399 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        vector(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a = allocator_type())
+ : _Base(__a)
+        { _M_initialize_dispatch(__first, __last, __false_type()); }
+# 423 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      ~vector() noexcept
+      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+        _M_get_Tp_allocator()); }
+# 435 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      vector&
+      operator=(const vector& __x);
+# 447 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+      }
+# 469 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      vector&
+      operator=(initializer_list<value_type> __l)
+      {
+ this->assign(__l.begin(), __l.end());
+ return *this;
+      }
+# 487 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 504 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        { _M_assign_dispatch(__first, __last, __false_type()); }
+# 532 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()); }
+# 672 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+      }
+# 692 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+      }
+# 724 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(); }
+# 763 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      void
+      reserve(size_type __n);
+# 778 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      reference
+      operator[](size_type __n) noexcept
+      { return *(this->_M_impl._M_start + __n); }
+# 793 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      const_reference
+      operator[](size_type __n) const noexcept
+      { return *(this->_M_impl._M_start + __n); }
+
+    protected:
+
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
+
+                            ,
+       __n, this->size());
+      }
+
+    public:
+# 821 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+# 839 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      const_reference
+      at(size_type __n) const
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+
+
+
+
+
+      reference
+      front() noexcept
+      { return *begin(); }
+
+
+
+
+
+      const_reference
+      front() const noexcept
+      { return *begin(); }
+
+
+
+
+
+      reference
+      back() noexcept
+      { return *(end() - 1); }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      { return *(end() - 1); }
+# 886 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      _Tp*
+
+
+
+      data() noexcept
+      { return _M_data_ptr(this->_M_impl._M_start); }
+
+
+      const _Tp*
+
+
+
+      data() const noexcept
+      { return _M_data_ptr(this->_M_impl._M_start); }
+# 912 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 948 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      void
+      pop_back() noexcept
+      {
+ --this->_M_impl._M_finish;
+ _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
+      }
+# 968 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args);
+# 983 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+# 1013 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+# 1030 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      { return this->insert(__position, __l.begin(), __l.end()); }
+# 1050 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_fill_insert(begin() + __offset, __n, __x);
+ return begin() + __offset;
+      }
+# 1092 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        iterator
+        insert(const_iterator __position, _InputIterator __first,
+        _InputIterator __last)
+        {
+   difference_type __offset = __position - cbegin();
+   _M_insert_dispatch(begin() + __offset,
+        __first, __last, __false_type());
+   return begin() + __offset;
+ }
+# 1144 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      iterator
+
+      erase(const_iterator __position)
+      { return _M_erase(begin() + (__position - cbegin())); }
+# 1171 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_vector.h" 3
+      iterator
+
+      erase(const_iterator __first, const_iterator __last)
+      {
+ const auto __beg = begin();
+ const auto __cbeg = cbegin();
+ return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg));
+      }
+# 1193 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+     }
+ }
+# 1245 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+
+     emplace_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)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
+     _M_get_Tp_allocator());
+      }
+
+
+
+      void
+      _M_default_initialize(size_type __n)
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_default_n_a(this->_M_impl._M_start, __n,
+        _M_get_Tp_allocator());
+      }
+# 1323 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 1363 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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) noexcept
+      {
+ std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
+ this->_M_impl._M_finish = __pos;
+      }
+
+      iterator
+      _M_erase(iterator __position);
+
+      iterator
+      _M_erase(iterator __first, iterator __last);
+
+
+    private:
+
+
+
+      void
+      _M_move_assign(vector&& __x, std::true_type) noexcept
+      {
+ vector __tmp(get_allocator());
+ this->_M_impl._M_swap_data(__tmp._M_impl);
+ this->_M_impl._M_swap_data(__x._M_impl);
+ 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();
+   }
+      }
+
+
+
+      template<typename _Up>
+ _Up*
+ _M_data_ptr(_Up* __ptr) const
+ { return __ptr; }
+
+      template<typename _Ptr>
+ typename std::pointer_traits<_Ptr>::element_type*
+ _M_data_ptr(_Ptr __ptr) const
+ { return empty() ? nullptr : std::__addressof(*__ptr); }
+
+
+
+
+
+
+    };
+# 1509 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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())); }
+# 1526 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+
+
+}
+# 65 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/vector" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_bvector.h" 1 3
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+  };
+
+
+  inline void
+  swap(_Bit_reference __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+  inline void
+  swap(_Bit_reference __x, bool& __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+  inline void
+  swap(bool& __x, _Bit_reference __y) noexcept
+  {
+    bool __tmp = __x;
+    __x = __y;
+    __y = __tmp;
+  }
+
+
+  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) { }
+
+    iterator
+    _M_const_cast() const
+    { return *this; }
+
+    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) { }
+
+    _Bit_iterator
+    _M_const_cast() const
+    { return _Bit_iterator(_M_p, _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 __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_Bit_type>::other _Bit_alloc_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
+ _Bit_alloc_traits;
+      typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
+
+      struct _Bvector_impl
+      : public _Bit_alloc_type
+      {
+ _Bit_iterator _M_start;
+ _Bit_iterator _M_finish;
+ _Bit_pointer _M_end_of_storage;
+
+ _Bvector_impl()
+ : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+ _Bvector_impl(const _Bit_alloc_type& __a)
+ : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ _Bvector_impl(_Bit_alloc_type&& __a)
+ : _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
+   _M_end_of_storage()
+ { }
+
+
+ _Bit_type*
+ _M_end_addr() const noexcept
+ {
+   if (_M_end_of_storage)
+     return std::__addressof(_M_end_of_storage[-1]) + 1;
+   return 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 = nullptr;
+      }
+
+
+      ~_Bvector_base()
+      { this->_M_deallocate(); }
+
+    protected:
+      _Bvector_impl _M_impl;
+
+      _Bit_pointer
+      _M_allocate(size_t __n)
+      { return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
+
+      void
+      _M_deallocate()
+      {
+ if (_M_impl._M_start._M_p)
+   {
+     const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
+     _Bit_alloc_traits::deallocate(_M_impl,
+       _M_impl._M_end_of_storage - __n,
+       __n);
+   }
+      }
+
+      static size_t
+      _S_nword(size_t __n)
+      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
+    };
+
+
+}
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 540 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_bvector.h" 3
+template<typename _Alloc>
+  class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
+  {
+    typedef _Bvector_base<_Alloc> _Base;
+    typedef typename _Base::_Bit_pointer _Bit_pointer;
+    typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;
+
+
+    template<typename> friend struct 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()
+
+      noexcept(is_nothrow_default_constructible<allocator_type>::value)
+
+    : _Base() { }
+
+    explicit
+    vector(const allocator_type& __a)
+    : _Base(__a) { }
+
+
+    explicit
+    vector(size_type __n, const allocator_type& __a = allocator_type())
+    : vector(__n, false, __a)
+    { }
+
+    vector(size_type __n, const bool& __value,
+    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_addr(),
+  __value ? ~0 : 0);
+    }
+# 611 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_bvector.h" 3
+    vector(const vector& __x)
+    : _Base(_Bit_alloc_traits::_S_select_on_copy(__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(vector&& __x, const allocator_type& __a)
+    noexcept(_Bit_alloc_traits::_S_always_equal())
+    : _Base(__a)
+    {
+      if (__x.get_allocator() == __a)
+ {
+   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 = nullptr;
+ }
+      else
+ {
+   _M_initialize(__x.size());
+   _M_copy_aligned(__x.begin(), __x.end(), begin());
+   __x.clear();
+ }
+    }
+
+    vector(const vector& __x, const allocator_type& __a)
+    : _Base(__a)
+    {
+      _M_initialize(__x.size());
+      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+    }
+
+    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,
+      typename = std::_RequireInputIter<_InputIterator>>
+      vector(_InputIterator __first, _InputIterator __last,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      { _M_initialize_dispatch(__first, __last, __false_type()); }
+# 677 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_bvector.h" 3
+    ~vector() noexcept { }
+
+    vector&
+    operator=(const vector& __x)
+    {
+      if (&__x == this)
+ return *this;
+
+      if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
+ {
+   if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
+     {
+       this->_M_deallocate();
+       std::__alloc_on_copy(_M_get_Bit_allocator(),
+       __x._M_get_Bit_allocator());
+       _M_initialize(__x.size());
+     }
+   else
+     std::__alloc_on_copy(_M_get_Bit_allocator(),
+     __x._M_get_Bit_allocator());
+ }
+
+      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) noexcept(_Bit_alloc_traits::_S_nothrow_move())
+    {
+      if (_Bit_alloc_traits::_S_propagate_on_move_assign()
+   || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
+ {
+   this->_M_deallocate();
+   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 = nullptr;
+   std::__alloc_on_move(_M_get_Bit_allocator(),
+          __x._M_get_Bit_allocator());
+ }
+      else
+ {
+   if (__x.size() > capacity())
+     {
+       this->_M_deallocate();
+       _M_initialize(__x.size());
+     }
+   this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+          begin());
+   __x.clear();
+ }
+      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,
+      typename = std::_RequireInputIter<_InputIterator>>
+      void
+      assign(_InputIterator __first, _InputIterator __last)
+      { _M_assign_dispatch(__first, __last, __false_type()); }
+# 773 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_bvector.h" 3
+    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
+ = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
+      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_addr(), 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_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)")
+
+                          ,
+     __n, this->size());
+    }
+
+  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_addr())
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(end(), __x);
+    }
+
+    void
+    swap(vector& __x)
+
+      noexcept(_Bit_alloc_traits::_S_nothrow_swap())
+
+    {
+      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);
+      _Bit_alloc_traits::_S_on_swap(_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(const_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_addr()
+   && __position == end())
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(__position._M_const_cast(), __x);
+      return begin() + __n;
+    }
+
+
+    template<typename _InputIterator,
+      typename = std::_RequireInputIter<_InputIterator>>
+      iterator
+      insert(const_iterator __position,
+      _InputIterator __first, _InputIterator __last)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_insert_dispatch(__position._M_const_cast(),
+      __first, __last, __false_type());
+ return begin() + __offset;
+      }
+# 992 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_bvector.h" 3
+    iterator
+    insert(const_iterator __position, size_type __n, const bool& __x)
+    {
+      difference_type __offset = __position - cbegin();
+      _M_fill_insert(__position._M_const_cast(), __n, __x);
+      return begin() + __offset;
+    }
+
+
+
+
+
+
+
+    iterator
+    insert(const_iterator __p, initializer_list<bool> __l)
+    { return this->insert(__p, __l.begin(), __l.end()); }
+
+
+    void
+    pop_back()
+    { --this->_M_impl._M_finish; }
+
+    iterator
+
+    erase(const_iterator __position)
+
+
+
+    { return _M_erase(__position._M_const_cast()); }
+
+    iterator
+
+    erase(const_iterator __first, const_iterator __last)
+
+
+
+    { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
+
+    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
+    {
+      _Bit_type * const __end = this->_M_impl._M_end_addr();
+      for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
+        *__p = ~*__p;
+    }
+
+    void
+    clear() noexcept
+    { _M_erase_at_end(begin()); }
+
+
+    template<typename... _Args>
+      void
+      emplace_back(_Args&&... __args)
+      { push_back(bool(__args...)); }
+
+    template<typename... _Args>
+      iterator
+      emplace(const_iterator __pos, _Args&&... __args)
+      { return insert(__pos, bool(__args...)); }
+
+
+  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_pointer __q = this->_M_allocate(__n);
+      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
+      this->_M_impl._M_start = iterator(std::__addressof(*__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_addr(), __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_addr(), __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_addr(), __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; }
+
+    iterator
+    _M_erase(iterator __pos);
+
+    iterator
+    _M_erase(iterator __first, iterator __last);
+  };
+
+
+}
+
+
+
+
+
+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;
+    };
+
+
+}
+# 66 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/vector" 2 3
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/vector.tcc" 1 3
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(const_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
+ {
+
+   const auto __pos = begin() + (__position - cbegin());
+   if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+     {
+       _Tp __x_copy = __x;
+       _M_insert_aux(__pos, std::move(__x_copy));
+     }
+   else
+     _M_insert_aux(__pos, __x);
+
+
+
+ }
+      return iterator(this->_M_impl._M_start + __n);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    _M_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>::
+    _M_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);
+    this->_M_impl._M_start = nullptr;
+    this->_M_impl._M_finish = nullptr;
+    this->_M_impl._M_end_of_storage = nullptr;
+  }
+       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._M_impl._M_swap_data(this->_M_impl);
+ }
+      else if (__n > size())
+ {
+   std::fill(begin(), end(), __val);
+   this->_M_impl._M_finish =
+     std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+       __n - size(), __val,
+       _M_get_Tp_allocator());
+ }
+      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(const_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(begin() + (__position - cbegin()),
+   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 = pointer();
+
+       __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 = pointer();
+
+     __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
+  {
+    this->_M_impl._M_finish =
+      std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+        __n - __elems_after,
+        __x_copy,
+        _M_get_Tp_allocator());
+    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 = pointer();
+
+    __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)
+     {
+       this->_M_impl._M_finish =
+  std::__uninitialized_default_n_a(this->_M_impl._M_finish,
+       __n, _M_get_Tp_allocator());
+     }
+   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());
+    __new_finish =
+      std::__uninitialized_default_n_a(__new_finish, __n,
+           _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 _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_pointer __q = this->_M_allocate(__n);
+      iterator __start(std::__addressof(*__q), 0);
+      this->_M_impl._M_finish = _M_copy_aligned(begin(), end(), __start);
+      this->_M_deallocate();
+      this->_M_impl._M_start = __start;
+      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_pointer __q = this->_M_allocate(__len);
+   iterator __start(std::__addressof(*__q), 0);
+   iterator __i = _M_copy_aligned(begin(), __position, __start);
+   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 = __start;
+ }
+    }
+
+  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_pointer __q = this->_M_allocate(__len);
+  iterator __start(std::__addressof(*__q), 0);
+  iterator __i = _M_copy_aligned(begin(), __position, __start);
+  __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 = __start;
+       }
+   }
+      }
+
+  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_addr())
+ {
+   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_pointer __q = this->_M_allocate(__len);
+   iterator __start(std::__addressof(*__q), 0);
+   iterator __i = _M_copy_aligned(begin(), __position, __start);
+   *__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 = __start;
+ }
+    }
+
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      if (__position + 1 != end())
+        std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      return __position;
+    }
+
+  template<typename _Alloc>
+    typename vector<bool, _Alloc>::iterator
+    vector<bool, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first != __last)
+ _M_erase_at_end(std::copy(__last, end(), __first));
+      return __first;
+    }
+
+
+  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;
+    }
+
+
+}
+# 70 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/vector" 2 3
+# 35 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/random.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 55 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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<int __s,
+      int __which = ((__s <= 8 * sizeof (int))
+       + (__s <= 8 * sizeof (long))
+       + (__s <= 8 * sizeof (long long))
+
+       + (__s <= 128))>
+      struct _Select_uint_least_t
+      {
+ static_assert(__which < 0,
+        "sorry, would be too much trouble for a slow result");
+      };
+
+    template<int __s>
+      struct _Select_uint_least_t<__s, 4>
+      { typedef unsigned int type; };
+
+    template<int __s>
+      struct _Select_uint_least_t<__s, 3>
+      { typedef unsigned long type; };
+
+    template<int __s>
+      struct _Select_uint_least_t<__s, 2>
+      { typedef unsigned long long type; };
+
+
+    template<int __s>
+      struct _Select_uint_least_t<__s, 1>
+      { typedef unsigned __int128 type; };
+
+
+
+    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
+      bool __big_enough = (!(__m & (__m - 1))
+      || (_Tp(-1) - __c) / __a >= __m - 1),
+             bool __schrage_ok = __m % __a < __m / __a>
+      struct _Mod
+      {
+ typedef typename _Select_uint_least_t<std::__lg(__a)
+           + std::__lg(__m) + 2>::type _Tp2;
+ static _Tp
+ __calc(_Tp __x)
+ { return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); }
+      };
+
+
+    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
+      struct _Mod<_Tp, __m, __a, __c, false, true>
+      {
+ static _Tp
+ __calc(_Tp __x);
+      };
+
+
+
+
+    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
+      struct _Mod<_Tp, __m, __a, __c, true, __s>
+      {
+ static _Tp
+ __calc(_Tp __x)
+ {
+   _Tp __res = __a * __x + __c;
+   if (__m)
+     __res %= __m;
+   return __res;
+ }
+      };
+
+    template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
+      inline _Tp
+      __mod(_Tp __x)
+      { return _Mod<_Tp, __m, __a, __c>::__calc(__x); }
+
+
+    template<typename _Tp>
+      inline bool
+      _Power_of_2(_Tp __x)
+      {
+ return ((__x - 1) & __x) == 0;
+      };
+
+
+
+
+
+    template<typename _Engine, typename _DInputType>
+      struct _Adaptor
+      {
+ static_assert(std::is_floating_point<_DInputType>::value,
+        "template argument not a floating point type");
+
+      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;
+      };
+
+ 
+  }
+
+
+# 242 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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");
+
+    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;
+# 269 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 302 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+      }
+# 354 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/random.h" 3
+      friend bool
+      operator==(const linear_congruential_engine& __lhs,
+   const linear_congruential_engine& __rhs)
+      { return __lhs._M_x == __rhs._M_x; }
+# 367 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 387 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    };
+# 409 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 446 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+
+      result_type
+      operator()();
+# 560 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 578 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 604 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      void _M_gen_rand();
+
+      _UIntType _M_x[state_size];
+      size_t _M_p;
+    };
+# 637 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 665 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 718 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()();
+# 773 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 792 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>& __os,
+     const std::subtract_with_carry_engine<_UIntType1, __w1,
+     __s1, __r1>& __x);
+# 811 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>& __is,
+     std::subtract_with_carry_engine<_UIntType1, __w1,
+     __s1, __r1>& __x);
+
+    private:
+
+      _UIntType _M_x[long_lag];
+      _UIntType _M_carry;
+      size_t _M_p;
+    };
+# 837 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 852 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()();
+# 1002 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+# 1018 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 1036 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    };
+# 1059 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()();
+# 1212 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/random.h" 3
+      friend bool
+      operator==(const independent_bits_engine& __lhs,
+   const independent_bits_engine& __rhs)
+      { return __lhs._M_b == __rhs._M_b; }
+# 1229 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    };
+# 1255 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 1273 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()();
+# 1441 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 1459 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 1477 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    };
+# 1507 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+# 1536 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 = "default")
+    {
+      _M_init(__token);
+    }
+
+    ~random_device()
+    { _M_fini(); }
+# 1603 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()()
+    {
+
+      return this->_M_getval();
+
+
+
+    }
+
+
+    random_device(const random_device&) = delete;
+    void operator=(const random_device&) = delete;
+
+  private:
+
+    void _M_init(const std::string& __token);
+    void _M_init_pretr1(const std::string& __token);
+    void _M_fini();
+
+    result_type _M_getval();
+    result_type _M_getval_pretr1();
+
+    union
+    {
+      void* _M_file;
+      mt19937 _M_mt;
+    };
+  };
+# 1664 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const uniform_int_distribution& __d1,
+   const uniform_int_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _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 == __d2); }
+# 1838 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>&);
+# 1852 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>&);
+# 1865 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_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();
+ }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const uniform_real_distribution& __d1,
+   const uniform_real_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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 == __d2); }
+# 2047 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>&);
+# 2061 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>&);
+# 2083 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>::lowest(); }
+
+
+
+
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+
+
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+ { return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+
+      template<typename _RealType1>
+ friend bool
+        operator==(const std::normal_distribution<_RealType1>& __d1,
+     const std::normal_distribution<_RealType1>& __d2);
+# 2244 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 2259 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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); }
+# 2296 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_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 _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+
+      friend bool
+      operator==(const lognormal_distribution& __d1,
+   const lognormal_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+  && __d1._M_nd == __d2._M_nd); }
+# 2448 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 2463 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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); }
+# 2500 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+
+      friend bool
+      operator==(const gamma_distribution& __d1,
+   const gamma_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+  && __d1._M_nd == __d2._M_nd); }
+# 2669 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 2683 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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); }
+# 2717 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+        { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { typename std::gamma_distribution<result_type>::param_type
+     __p2(__p.n() / 2);
+   this->__generate_impl(__f, __t, __urng, __p2); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng)
+        { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { typename std::gamma_distribution<result_type>::param_type
+     __p2(__p.n() / 2);
+   this->__generate_impl(__f, __t, __urng, __p2); }
+
+
+
+
+
+
+      friend bool
+      operator==(const chi_squared_distribution& __d1,
+   const chi_squared_distribution& __d2)
+      { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
+# 2871 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 2886 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const typename
+   std::gamma_distribution<result_type>::param_type& __p);
+
+      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); }
+# 2927 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>::lowest(); }
+
+
+
+
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+
+
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+ { return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const cauchy_distribution& __d1,
+   const cauchy_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      param_type _M_param;
+    };
+
+
+
+
+
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::cauchy_distribution<_RealType>& __d1,
+        const std::cauchy_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+# 3097 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 3112 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 3128 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+
+      friend bool
+      operator==(const fisher_f_distribution& __d1,
+   const fisher_f_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+  && __d1._M_gd_x == __d2._M_gd_x
+  && __d1._M_gd_y == __d2._M_gd_y); }
+# 3295 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 3310 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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); }
+# 3352 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>::lowest(); }
+
+
+
+
+      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 _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+
+      friend bool
+      operator==(const student_t_distribution& __d1,
+   const student_t_distribution& __d2)
+      { return (__d1._M_param == __d2._M_param
+  && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
+# 3508 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 3523 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng);
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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); }
+# 3571 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_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;
+      }
+
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      __generate(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng)
+      { this->__generate(__f, __t, __urng, _M_param); }
+
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      __generate(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng, const param_type& __p)
+      { this->__generate_impl(__f, __t, __urng, __p); }
+
+    template<typename _UniformRandomNumberGenerator>
+      void
+      __generate(result_type* __f, result_type* __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p)
+      { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+    friend bool
+    operator==(const bernoulli_distribution& __d1,
+        const bernoulli_distribution& __d2)
+    { return __d1._M_param == __d2._M_param; }
+
+  private:
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p);
+
+    param_type _M_param;
+  };
+
+
+
+
+
+  inline bool
+  operator!=(const std::bernoulli_distribution& __d1,
+      const std::bernoulli_distribution& __d2)
+  { return !(__d1 == __d2); }
+# 3742 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 3756 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 3775 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+
+ friend bool
+        operator==(const binomial_distribution& __d1,
+     const binomial_distribution& __d2)
+
+ { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
+# 3948 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 3964 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ _M_waiting(_UniformRandomNumberGenerator& __urng,
+     _IntType __t, double __q);
+
+      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); }
+# 4006 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const geometric_distribution& __d1,
+   const geometric_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      param_type _M_param;
+    };
+
+
+
+
+
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::geometric_distribution<_IntType>& __d1,
+        const std::geometric_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+# 4177 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 4192 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 4206 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate_impl(__f, __t, __urng); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+
+      friend bool
+      operator==(const negative_binomial_distribution& __d1,
+   const negative_binomial_distribution& __d2)
+      { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
+# 4365 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 4380 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng);
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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); }
+# 4428 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+
+      friend bool
+      operator==(const poisson_distribution& __d1,
+   const poisson_distribution& __d2)
+
+      { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
+# 4585 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 4600 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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); }
+# 4644 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ {
+   __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+     __aurng(__urng);
+   return -std::log(result_type(1) - __aurng()) / __p.lambda();
+ }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const exponential_distribution& __d1,
+   const exponential_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      param_type _M_param;
+    };
+
+
+
+
+
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::exponential_distribution<_RealType>& __d1,
+        const std::exponential_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+# 4816 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 4831 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 4846 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const weibull_distribution& __d1,
+   const weibull_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      param_type _M_param;
+    };
+
+
+
+
+
+  template<typename _RealType>
+    inline bool
+    operator!=(const std::weibull_distribution<_RealType>& __d1,
+        const std::weibull_distribution<_RealType>& __d2)
+    { return !(__d1 == __d2); }
+# 5019 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 5034 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 5049 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>::lowest(); }
+
+
+
+
+      result_type
+      max() const
+      { return std::numeric_limits<result_type>::max(); }
+
+
+
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng)
+ { return this->operator()(__urng, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const extreme_value_distribution& __d1,
+   const extreme_value_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+
+    private:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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 == __d2); }
+# 5222 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 5237 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 5249 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const discrete_distribution& __d1,
+   const discrete_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+# 5430 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 5446 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      param_type _M_param;
+    };
+
+
+
+
+
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::discrete_distribution<_IntType>& __d1,
+        const std::discrete_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+# 5479 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const piecewise_constant_distribution& __d1,
+   const piecewise_constant_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+# 5697 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 5713 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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 == __d2); }
+# 5746 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, _M_param); }
+
+      template<typename _UniformRandomNumberGenerator>
+ result_type
+ operator()(_UniformRandomNumberGenerator& __urng,
+     const param_type& __p);
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng)
+ { this->__generate(__f, __t, __urng, _M_param); }
+
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate(_ForwardIterator __f, _ForwardIterator __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+      template<typename _UniformRandomNumberGenerator>
+ void
+ __generate(result_type* __f, result_type* __t,
+     _UniformRandomNumberGenerator& __urng,
+     const param_type& __p)
+ { this->__generate_impl(__f, __t, __urng, __p); }
+
+
+
+
+
+      friend bool
+      operator==(const piecewise_linear_distribution& __d1,
+   const piecewise_linear_distribution& __d2)
+      { return __d1._M_param == __d2._M_param; }
+# 5967 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 5983 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+      template<typename _ForwardIterator,
+        typename _UniformRandomNumberGenerator>
+ void
+ __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+   _UniformRandomNumberGenerator& __urng,
+   const param_type& __p);
+
+      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 == __d2); }
+# 6024 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+  };
+
+
+
+
+
+
+}
+# 50 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/opt_random.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/opt_random.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/opt_random.h" 3
+# 51 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/random.tcc" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/random.tcc" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/numeric" 1 3
+# 58 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/numeric" 3
+       
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/numeric" 3
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_numeric.h" 1 3
+# 65 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_numeric.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 80 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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")))
+{
+
+# 118 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 144 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 172 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 203 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 235 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 275 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 315 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 357 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/numeric" 2 3
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/random.tcc" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  namespace __detail
+  {
+ 
+
+
+
+
+
+
+
+    template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
+      _Tp
+      _Mod<_Tp, __m, __a, __c, false, true>::
+      __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 _InputIterator, typename _OutputIterator,
+      typename _Tp>
+      _OutputIterator
+      __normalize(_InputIterator __first, _InputIterator __last,
+    _OutputIterator __result, const _Tp& __factor)
+      {
+ for (; __first != __last; ++__first, ++__result)
+   *__result = *__first / __factor;
+ 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;
+ _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>
+    void
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+       __s, __b, __t, __c, __l, __f>::
+    _M_gen_rand(void)
+    {
+      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;
+    }
+
+  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>::
+    discard(unsigned long long __z)
+    {
+      while (__z > state_size - _M_p)
+ {
+   __z -= state_size - _M_p;
+   _M_gen_rand();
+ }
+      _M_p += __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
+    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)
+ _M_gen_rand();
+
+
+      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)
+   {
+# 924 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      uniform_int_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _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)
+   {
+     if (__detail::_Power_of_2(__urngrange + 1)
+  && __detail::_Power_of_2(__urange + 1))
+       {
+  while (__f != __t)
+    {
+      __ret = __uctype(__urng()) - __urngmin;
+      *__f++ = (__ret & __urange) + __param.a();
+    }
+       }
+     else
+       {
+
+  const __uctype __uerange = __urange + 1;
+  const __uctype __scaling = __urngrange / __uerange;
+  const __uctype __past = __uerange * __scaling;
+  while (__f != __t)
+    {
+      do
+        __ret = __uctype(__urng()) - __urngmin;
+      while (__ret >= __past);
+      *__f++ = __ret / __scaling + __param.a();
+    }
+       }
+   }
+ else if (__urngrange < __urange)
+   {
+# 1008 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/random.tcc" 3
+     __uctype __tmp;
+     while (__f != __t)
+       {
+  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);
+  *__f++ = __ret;
+       }
+   }
+ else
+   while (__f != __t)
+     *__f++ = __uctype(__urng()) - __urngmin + __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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      uniform_real_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p)
+      {
+
+ __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+   __aurng(__urng);
+ auto __range = __p.b() - __p.a();
+ while (__f != __t)
+   *__f++ = __aurng() * __range + __p.a();
+      }
+
+  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 _ForwardIterator,
+    typename _UniformRandomNumberGenerator>
+    void
+    std::bernoulli_distribution::
+    __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+      _UniformRandomNumberGenerator& __urng,
+      const param_type& __p)
+    {
+     
+      __detail::_Adaptor<_UniformRandomNumberGenerator, double>
+ __aurng(__urng);
+      auto __limit = __p.p() * (__aurng.max() - __aurng.min());
+
+      while (__f != __t)
+ *__f++ = (__aurng() - __aurng.min()) < __limit;
+    }
+
+  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(1.0 - __aurng()) / __param._M_log_1_p);
+ while (__cand >= __thr);
+
+ return result_type(__cand + __naf);
+      }
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      geometric_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _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);
+
+ while (__f != __t)
+   {
+     double __cand;
+     do
+       __cand = std::floor(std::log(1.0 - __aurng())
+      / __param._M_log_1_p);
+     while (__cand >= __thr);
+
+     *__f++ = __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<double>::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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      negative_binomial_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng)
+      {
+
+ while (__f != __t)
+   {
+     const double __y = _M_gd(__urng);
+
+
+     std::poisson_distribution<result_type> __poisson(__y);
+     *__f++ = __poisson(__urng);
+   }
+      }
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      negative_binomial_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p)
+      {
+
+ typename std::gamma_distribution<result_type>::param_type
+   __p2(__p.k(), (1.0 - __p.p()) / __p.p());
+
+ while (__f != __t)
+   {
+     const double __y = _M_gd(__urng, __p2);
+
+     std::poisson_distribution<result_type> __poisson(__y);
+     *__f++ = __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);
+      }
+# 1432 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(1.0 - __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(1.0 - __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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      poisson_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __param)
+      {
+
+
+ while (__f != __t)
+   *__f++ = this->operator()(__urng, __param);
+      }
+
+  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, double __q)
+      {
+ _IntType __x = 0;
+ double __sum = 0.0;
+ __detail::_Adaptor<_UniformRandomNumberGenerator, double>
+   __aurng(__urng);
+
+ do
+   {
+     if (__t == __x)
+       return __x;
+     const double __e = -std::log(1.0 - __aurng());
+     __sum += __e / (__t - __x);
+     __x += 1;
+   }
+ while (__sum <= __q);
+
+ return __x - 1;
+      }
+# 1682 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(1.0 - __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(1.0 - __aurng());
+   __x = std::floor(-__y);
+   __v = -__e - __n * __n / 2;
+        }
+    }
+  else if (__u <= __a123)
+    {
+      const double __e1 = -std::log(1.0 - __aurng());
+      const double __e2 = -std::log(1.0 - __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(1.0 - __aurng());
+      const double __e2 = -std::log(1.0 - __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),
+         __param._M_q);
+     __ret = _IntType(__x) + __z;
+   }
+ else
+
+   __ret = _M_waiting(__urng, __t, __param._M_q);
+
+ if (__p12 != __p)
+   __ret = __t - __ret;
+ return __ret;
+      }
+
+  template<typename _IntType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      binomial_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __param)
+      {
+
+
+ while (__f != __t)
+   *__f++ = this->operator()(__urng, __param);
+      }
+
+  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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      std::exponential_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p)
+      {
+
+ __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+   __aurng(__urng);
+ while (__f != __t)
+   *__f++ = -std::log(result_type(1) - __aurng()) / __p.lambda();
+      }
+
+  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;
+    }
+# 1931 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      normal_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __param)
+      {
+
+
+ if (__f == __t)
+   return;
+
+ if (_M_saved_available)
+   {
+     _M_saved_available = false;
+     *__f++ = _M_saved * __param.stddev() + __param.mean();
+
+     if (__f == __t)
+       return;
+   }
+
+ __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+   __aurng(__urng);
+
+ while (__f + 1 < __t)
+   {
+     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);
+     *__f++ = __y * __mult * __param.stddev() + __param.mean();
+     *__f++ = __x * __mult * __param.stddev() + __param.mean();
+   }
+
+ if (__f != __t)
+   {
+     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;
+     *__f = __y * __mult * __param.stddev() + __param.mean();
+   }
+      }
+
+  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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      lognormal_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p)
+      {
+
+   while (__f != __t)
+     *__f++ = std::exp(__p.s() * _M_nd(__urng) + __p.m());
+      }
+
+  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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      std::chi_squared_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng)
+      {
+
+ while (__f != __t)
+   *__f++ = 2 * _M_gd(__urng);
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      std::chi_squared_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const typename
+        std::gamma_distribution<result_type>::param_type& __p)
+      {
+
+ while (__f != __t)
+   *__f++ = 2 * _M_gd(__urng, __p);
+      }
+
+  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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      cauchy_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p)
+      {
+
+ const _RealType __pi = 3.1415926535897932384626433832795029L;
+ __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+   __aurng(__urng);
+ while (__f != __t)
+   {
+     _RealType __u;
+     do
+       __u = __aurng();
+     while (__u == 0.5);
+
+     *__f++ = __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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      std::fisher_f_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng)
+      {
+
+ while (__f != __t)
+   *__f++ = ((_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()));
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      std::fisher_f_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p)
+      {
+
+ typedef typename std::gamma_distribution<result_type>::param_type
+   param_type;
+ param_type __p1(__p.m() / 2);
+ param_type __p2(__p.n() / 2);
+ while (__f != __t)
+   *__f++ = ((_M_gd_x(__urng, __p1) * n())
+      / (_M_gd_y(__urng, __p2) * m()));
+      }
+
+  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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      std::student_t_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng)
+      {
+
+ while (__f != __t)
+   *__f++ = _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng));
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      std::student_t_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p)
+      {
+
+ typename std::gamma_distribution<result_type>::param_type
+   __p2(__p.n() / 2, 2);
+ while (__f != __t)
+   *__f++ = _M_nd(__urng) * std::sqrt(__p.n() / _M_gd(__urng, __p2));
+      }
+
+  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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      gamma_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _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));
+
+ if (__param.alpha() == __param._M_malpha)
+   while (__f != __t)
+     {
+       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)))));
+
+       *__f++ = __a1 * __v * __param.beta();
+     }
+ else
+   while (__f != __t)
+     {
+       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)))));
+
+       do
+  __u = __aurng();
+       while (__u == 0.0);
+
+       *__f++ = (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(result_type(1) - __aurng()),
+      result_type(1) / __p.a());
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      weibull_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p)
+      {
+
+ __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+   __aurng(__urng);
+ auto __inv_a = result_type(1) / __p.a();
+
+ while (__f != __t)
+   *__f++ = __p.b() * std::pow(-std::log(result_type(1) - __aurng()),
+          __inv_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(result_type(1)
+            - __aurng()));
+      }
+
+  template<typename _RealType>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      extreme_value_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __p)
+      {
+
+ __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+   __aurng(__urng);
+
+ while (__f != __t)
+   *__f++ = __p.a() - __p.b() * std::log(-std::log(result_type(1)
+         - __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::__normalize(_M_prob.begin(), _M_prob.end(), _M_prob.begin(),
+       __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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      discrete_distribution<_IntType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __param)
+      {
+
+
+ if (__param._M_cp.empty())
+   {
+     while (__f != __t)
+       *__f++ = result_type(0);
+     return;
+   }
+
+ __detail::_Adaptor<_UniformRandomNumberGenerator, double>
+   __aurng(__urng);
+
+ while (__f != __t)
+   {
+     const double __p = __aurng();
+     auto __pos = std::lower_bound(__param._M_cp.begin(),
+       __param._M_cp.end(), __p);
+
+     *__f++ = __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::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
+       __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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      piecewise_constant_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __param)
+      {
+
+ __detail::_Adaptor<_UniformRandomNumberGenerator, double>
+   __aurng(__urng);
+
+ if (__param._M_cp.empty())
+   {
+     while (__f != __t)
+       *__f++ = __aurng();
+     return;
+   }
+
+ while (__f != __t)
+   {
+     const double __p = __aurng();
+
+     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;
+
+     *__f++ = (__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::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
+       __sum);
+
+      __detail::__normalize(_M_cp.begin(), _M_cp.end(), _M_cp.begin(), __sum);
+
+      __detail::__normalize(_M_m.begin(), _M_m.end(), _M_m.begin(), __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>
+    template<typename _ForwardIterator,
+      typename _UniformRandomNumberGenerator>
+      void
+      piecewise_linear_distribution<_RealType>::
+      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
+        _UniformRandomNumberGenerator& __urng,
+        const param_type& __param)
+      {
+
+
+ while (__f != __t)
+   *__f++ = this->operator()(__urng, __param);
+      }
+
+  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(size_t(__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)
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "template argument not a floating point type");
+
+      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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/random" 2 3
+# 67 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Iterator, typename _Compare>
+    void
+    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
+      _Iterator __c, _Compare __comp)
+    {
+      if (__comp(__a, __b))
+ {
+   if (__comp(__b, __c))
+     std::iter_swap(__result, __b);
+   else if (__comp(__a, __c))
+     std::iter_swap(__result, __c);
+   else
+     std::iter_swap(__result, __a);
+ }
+      else if (__comp(__a, __c))
+ std::iter_swap(__result, __a);
+      else if (__comp(__b, __c))
+ std::iter_swap(__result, __c);
+      else
+ std::iter_swap(__result, __b);
+    }
+
+
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if(_InputIterator __first, _InputIterator __last,
+       _Predicate __pred, input_iterator_tag)
+    {
+      while (__first != __last && !__pred(__first))
+ ++__first;
+      return __first;
+    }
+
+
+  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 _Iterator, typename _Predicate>
+    inline _Iterator
+    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
+    {
+      return __find_if(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+
+
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if_not(_InputIterator __first, _InputIterator __last,
+    _Predicate __pred)
+    {
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__negate(__pred),
+       std::__iterator_category(__first));
+    }
+
+
+
+
+  template<typename _InputIterator, typename _Predicate, typename _Distance>
+    _InputIterator
+    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
+    {
+      for (; __len; --__len, ++__first)
+ if (!__pred(__first))
+   break;
+      return __first;
+    }
+# 202 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+ return std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+
+      _ForwardIterator2 __p;
+      _ForwardIterator1 __current = __first1;
+
+      for (;;)
+ {
+   __first1 =
+     std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+   if (__first1 == __last1)
+     return __last1;
+
+   __p = __p1;
+   __current = __first1;
+   if (++__current == __last1)
+     return __last1;
+
+   while (__predicate(__current, __p))
+     {
+       if (++__p == __last2)
+  return __first1;
+       if (++__current == __last1)
+  return __last1;
+     }
+   ++__first1;
+ }
+      return __first1;
+    }
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Integer,
+    typename _UnaryPredicate>
+    _ForwardIterator
+    __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
+     _Integer __count, _UnaryPredicate __unary_pred,
+     std::forward_iterator_tag)
+    {
+      __first = std::__find_if(__first, __last, __unary_pred);
+      while (__first != __last)
+ {
+   typename iterator_traits<_ForwardIterator>::difference_type
+     __n = __count;
+   _ForwardIterator __i = __first;
+   ++__i;
+   while (__i != __last && __n != 1 && __unary_pred(__i))
+     {
+       ++__i;
+       --__n;
+     }
+   if (__n == 1)
+     return __first;
+   if (__i == __last)
+     return __last;
+   __first = std::__find_if(++__i, __last, __unary_pred);
+ }
+      return __last;
+    }
+
+
+
+
+
+  template<typename _RandomAccessIter, typename _Integer,
+    typename _UnaryPredicate>
+    _RandomAccessIter
+    __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
+     _Integer __count, _UnaryPredicate __unary_pred,
+     std::random_access_iterator_tag)
+    {
+      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
+ _DistanceType;
+
+      _DistanceType __tailSize = __last - __first;
+      _DistanceType __remainder = __count;
+
+      while (__remainder <= __tailSize)
+ {
+   __first += __remainder;
+   __tailSize -= __remainder;
+
+
+   _RandomAccessIter __backTrack = __first;
+   while (__unary_pred(--__backTrack))
+     {
+       if (--__remainder == 0)
+         return (__first - __count);
+     }
+   __remainder = __count + 1 - (__first - __backTrack);
+ }
+      return __last;
+    }
+
+  template<typename _ForwardIterator, typename _Integer,
+           typename _UnaryPredicate>
+    _ForwardIterator
+    __search_n(_ForwardIterator __first, _ForwardIterator __last,
+        _Integer __count,
+        _UnaryPredicate __unary_pred)
+    {
+      if (__count <= 0)
+ return __first;
+
+      if (__count == 1)
+ return std::__find_if(__first, __last, __unary_pred);
+
+      return std::__search_n_aux(__first, __last, __count, __unary_pred,
+     std::__iterator_category(__first));
+    }
+
+
+  template<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;
+
+      _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,
+    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;
+ }
+    }
+# 423 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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),
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 471 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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),
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 506 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 523 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 541 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 556 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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,
+    __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 580 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+    }
+# 598 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    _OutputIterator
+    __remove_copy_if(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _Predicate __pred)
+    {
+      for (; __first != __last; ++__first)
+ if (!__pred(__first))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+# 665 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    inline _OutputIterator
+    remove_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result, const _Tp& __value)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      return std::__remove_copy_if(__first, __last, __result,
+ __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+# 697 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    inline _OutputIterator
+    remove_copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      return std::__remove_copy_if(__first, __last, __result,
+       __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 731 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 794 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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));
+    }
+# 822 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+    }
+
+
+  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 (!__pred(__first))
+          {
+            *__result = std::move(*__first);
+            ++__result;
+          }
+      return __result;
+    }
+# 891 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    remove(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __value)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__remove_if(__first, __last,
+  __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+# 924 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    remove_if(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__remove_if(__first, __last,
+         __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+  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;
+    }
+
+  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 (!__binary_pred(__dest, __first))
+   *++__dest = std::move(*__first);
+      return ++__dest;
+    }
+# 990 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__unique(__first, __last,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 1020 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last,
+           _BinaryPredicate __binary_pred)
+    {
+
+     
+
+     
+
+
+      ;
+
+      return std::__unique(__first, __last,
+      __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+
+
+
+
+
+
+
+  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 (!__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;
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
+ __rebound_pred
+ = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
+      *__result = __value;
+      while (++__first != __last)
+ if (!__rebound_pred(__first, __value))
+   {
+     __value = *__first;
+     *++__result = __value;
+   }
+      return ++__result;
+    }
+
+
+
+
+
+
+
+  template<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 (!__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;
+ }
+    }
+# 1175 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline void
+    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    {
+
+     
+
+      ;
+      std::__reverse(__first, __last, std::__iterator_category(__first));
+    }
+# 1202 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+
+  inline namespace _V2
+  {
+
+
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    __rotate(_ForwardIterator __first,
+      _ForwardIterator __middle,
+      _ForwardIterator __last,
+      forward_iterator_tag)
+    {
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+
+      _ForwardIterator __first2 = __middle;
+      do
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+ }
+      while (__first2 != __last);
+
+      _ForwardIterator __ret = __first;
+
+      __first2 = __middle;
+
+      while (__first2 != __last)
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+   else if (__first2 == __last)
+     __first2 = __middle;
+ }
+      return __ret;
+    }
+
+
+  template<typename _BidirectionalIterator>
+    _BidirectionalIterator
+    __rotate(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+
+     
+
+
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+
+      std::__reverse(__first, __middle, bidirectional_iterator_tag());
+      std::__reverse(__middle, __last, bidirectional_iterator_tag());
+
+      while (__first != __middle && __middle != __last)
+ {
+   std::iter_swap(__first, --__last);
+   ++__first;
+ }
+
+      if (__first == __middle)
+ {
+   std::__reverse(__middle, __last, bidirectional_iterator_tag());
+   return __last;
+ }
+      else
+ {
+   std::__reverse(__first, __middle, bidirectional_iterator_tag());
+   return __first;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator>
+    _RandomAccessIterator
+    __rotate(_RandomAccessIterator __first,
+      _RandomAccessIterator __middle,
+      _RandomAccessIterator __last,
+      random_access_iterator_tag)
+    {
+
+     
+
+
+      if (__first == __middle)
+ return __last;
+      else if (__last == __middle)
+ return __first;
+
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+      _Distance __n = __last - __first;
+      _Distance __k = __middle - __first;
+
+      if (__k == __n - __k)
+ {
+   std::swap_ranges(__first, __middle, __middle);
+   return __middle;
+ }
+
+      _RandomAccessIterator __p = __first;
+      _RandomAccessIterator __ret = __first + (__last - __middle);
+
+      for (;;)
+ {
+   if (__k < __n - __k)
+     {
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = std::move(*__p);
+    std::move(__p + 1, __p + __n, __p);
+    *(__p + __n - 1) = std::move(__t);
+    return __ret;
+  }
+       _RandomAccessIterator __q = __p + __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    std::iter_swap(__p, __q);
+    ++__p;
+    ++__q;
+  }
+       __n %= __k;
+       if (__n == 0)
+  return __ret;
+       std::swap(__n, __k);
+       __k = __n - __k;
+     }
+   else
+     {
+       __k = __n - __k;
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = std::move(*(__p + __n - 1));
+    std::move_backward(__p, __p + __n - 1, __p + __n);
+    *__p = std::move(__t);
+    return __ret;
+  }
+       _RandomAccessIterator __q = __p + __n;
+       __p = __q - __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    --__p;
+    --__q;
+    std::iter_swap(__p, __q);
+  }
+       __n %= __k;
+       if (__n == 0)
+  return __ret;
+       std::swap(__n, __k);
+     }
+ }
+    }
+# 1429 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    rotate(_ForwardIterator __first, _ForwardIterator __middle,
+    _ForwardIterator __last)
+    {
+
+     
+
+      ;
+      ;
+
+      return std::__rotate(__first, __middle, __last,
+      std::__iterator_category(__first));
+    }
+
+  }
+# 1466 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _OutputIterator>
+    inline _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;
+ }
+    }
+# 1543 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  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 == 1)
+ return __first;
+
+      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;
+ }
+
+      _ForwardIterator __middle = __first;
+      std::advance(__middle, __len / 2);
+      _ForwardIterator __left_split =
+ std::__stable_partition_adaptive(__first, __middle, __pred,
+      __len / 2, __buffer,
+      __buffer_size);
+
+
+
+      _Distance __right_len = __len - __len / 2;
+      _ForwardIterator __right_split =
+ std::__find_if_not_n(__middle, __right_len, __pred);
+
+      if (__right_len)
+ __right_split =
+   std::__stable_partition_adaptive(__right_split, __last, __pred,
+        __right_len,
+        __buffer, __buffer_size);
+
+      std::rotate(__left_split, __middle, __right_split);
+      std::advance(__left_split, std::distance(__middle, __right_split));
+      return __left_split;
+    }
+
+  template<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;
+
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first, __last);
+      return
+ std::__stable_partition_adaptive(__first, __last, __pred,
+      _DistanceType(__buf.requested_size()),
+      __buf.begin(),
+      _DistanceType(__buf.size()));
+    }
+# 1646 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__stable_partition(__first, __last,
+         __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+
+
+  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);
+    }
+
+
+
+  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 iterator_traits<_RandomAccessIterator> _RItTraits;
+      typedef typename _RItTraits::difference_type _DistanceType;
+
+      if (__result_first == __result_last)
+ return __result_last;
+      _RandomAccessIterator __result_real_last = __result_first;
+      while (__first != __last && __result_real_last != __result_last)
+ {
+   *__result_real_last = *__first;
+   ++__result_real_last;
+   ++__first;
+ }
+
+      std::__make_heap(__result_first, __result_real_last, __comp);
+      while (__first != __last)
+ {
+   if (__comp(__first, __result_first))
+     std::__adjust_heap(__result_first, _DistanceType(0),
+          _DistanceType(__result_real_last
+          - __result_first),
+          _InputValueType(*__first), __comp);
+   ++__first;
+ }
+      std::__sort_heap(__result_first, __result_real_last, __comp);
+      return __result_real_last;
+    }
+# 1732 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+
+     
+
+     
+      ;
+      ;
+
+      return std::__partial_sort_copy(__first, __last,
+          __result_first, __result_last,
+          __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 1780 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _RandomAccessIterator,
+    typename _Compare>
+    inline _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last,
+        _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+
+     
+
+     
+
+     
+
+      ;
+      ;
+
+      return std::__partial_sort_copy(__first, __last,
+          __result_first, __result_last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+  template<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, 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,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+    {
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
+ std::__unguarded_linear_insert(__i,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+
+
+
+
+
+  enum { _S_threshold = 16 };
+
+
+  template<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 _Compare>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first,
+     _RandomAccessIterator __last,
+     _RandomAccessIterator __pivot, _Compare __comp)
+    {
+      while (true)
+ {
+   while (__comp(__first, __pivot))
+     ++__first;
+   --__last;
+   while (__comp(__pivot, __last))
+     --__last;
+   if (!(__first < __last))
+     return __first;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline _RandomAccessIterator
+    __unguarded_partition_pivot(_RandomAccessIterator __first,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
+      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
+      __comp);
+      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __partial_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __middle,
+     _RandomAccessIterator __last,
+     _Compare __comp)
+    {
+      std::__heap_select(__first, __middle, __last, __comp);
+      std::__sort_heap(__first, __middle, __comp);
+    }
+
+
+  template<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 _Compare>
+    inline void
+    __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+      if (__first != __last)
+ {
+   std::__introsort_loop(__first, __last,
+    std::__lg(__last - __first) * 2,
+    __comp);
+   std::__final_insertion_sort(__first, __last, __comp);
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+    _RandomAccessIterator __last, _Size __depth_limit,
+    _Compare __comp)
+    {
+      while (__last - __first > 3)
+ {
+   if (__depth_limit == 0)
+     {
+       std::__heap_select(__first, __nth + 1, __last, __comp);
+
+       std::iter_swap(__first, __nth);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   if (__cut <= __nth)
+     __first = __cut;
+   else
+     __last = __cut;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+# 2016 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+     
+     
+
+     
+                    ;
+
+      return std::__lower_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_comp_val(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(__val, __middle))
+     __len = __half;
+   else
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+ }
+      return __first;
+    }
+# 2073 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+     
+     
+      ;
+
+      return std::__upper_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+# 2105 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+     
+     
+
+     
+                    ;
+
+      return std::__upper_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Tp,
+    typename _CompareItTp, typename _CompareTpIt>
+    pair<_ForwardIterator, _ForwardIterator>
+    __equal_range(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val,
+    _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp_it_val(__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else if (__comp_val_it(__val, __middle))
+     __len = __half;
+   else
+     {
+       _ForwardIterator __left
+  = std::__lower_bound(__first, __middle, __val, __comp_it_val);
+       std::advance(__first, __len);
+       _ForwardIterator __right
+  = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
+       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+     }
+ }
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+    }
+# 2179 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+     
+     
+     
+      ;
+      ;
+
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_less_val(),
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+# 2216 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+     
+     
+
+     
+
+     
+                    ;
+     
+                    ;
+
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_comp_val(__comp),
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+# 2252 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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,
+        __gnu_cxx::__ops::__iter_less_val());
+      return __i != __last && !(__val < *__i);
+    }
+# 2287 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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,
+        __gnu_cxx::__ops::__iter_comp_val(__comp));
+      return __i != __last && !bool(__comp(__val, *__i));
+    }
+
+
+
+
+  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, 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, 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,
+         __gnu_cxx::__ops::__iter_comp_val(__comp));
+       __len22 = std::distance(__middle, __second_cut);
+     }
+   else
+     {
+       __len22 = __len2 / 2;
+       std::advance(__second_cut, __len22);
+       __first_cut
+  = std::__upper_bound(__first, __middle, *__second_cut,
+         __gnu_cxx::__ops::__val_comp_iter(__comp));
+       __len11 = std::distance(__first, __first_cut);
+     }
+
+   _BidirectionalIterator __new_middle
+     = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
+         __len1 - __len11, __len22, __buffer,
+         __buffer_size);
+   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
+    __len22, __buffer, __buffer_size, __comp);
+   std::__merge_adaptive(__new_middle, __second_cut, __last,
+    __len1 - __len11,
+    __len2 - __len22, __buffer,
+    __buffer_size, __comp);
+ }
+    }
+
+
+  template<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,
+     __gnu_cxx::__ops::__iter_comp_val(__comp));
+   __len22 = std::distance(__middle, __second_cut);
+ }
+      else
+ {
+   __len22 = __len2 / 2;
+   std::advance(__second_cut, __len22);
+   __first_cut
+     = std::__upper_bound(__first, __middle, *__second_cut,
+     __gnu_cxx::__ops::__val_comp_iter(__comp));
+   __len11 = std::distance(__first, __first_cut);
+ }
+
+      std::rotate(__first_cut, __middle, __second_cut);
+      _BidirectionalIterator __new_middle = __first_cut;
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
+      std::__merge_without_buffer(__first, __first_cut, __new_middle,
+      __len11, __len22, __comp);
+      std::__merge_without_buffer(__new_middle, __second_cut, __last,
+      __len1 - __len11, __len2 - __len22, __comp);
+    }
+
+  template<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);
+
+      typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, __last);
+
+      if (__buf.begin() == 0)
+ std::__merge_without_buffer
+   (__first, __middle, __last, __len1, __len2, __comp);
+      else
+ std::__merge_adaptive
+   (__first, __middle, __last, __len1, __len2, __buf.begin(),
+    _DistanceType(__buf.size()), __comp);
+    }
+# 2584 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      std::__inplace_merge(__first, __middle, __last,
+      __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 2624 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last,
+    _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+
+      std::__inplace_merge(__first, __middle, __last,
+      __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __move_merge(_InputIterator __first1, _InputIterator __last1,
+   _InputIterator __first2, _InputIterator __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = 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, 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,
+    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, 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, 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, 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);
+    }
+# 2795 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+    bool
+    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first2, __first1))
+   return false;
+ else if (__comp(__first1, __first2))
+   ++__first1;
+ else
+   ++__first1, ++__first2;
+
+      return __first2 == __last2;
+    }
+# 2831 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2>
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+
+     
+     
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__includes(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 2873 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+    inline bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2,
+      _Compare __comp)
+    {
+
+     
+     
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__includes(__first1, __last1, __first2, __last2,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 2906 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 (!__comp(__i, --__j))
+  {}
+       std::iter_swap(__i, __j);
+       std::__reverse(__ii, __last,
+        std::__iterator_category(__first));
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::__reverse(__first, __last,
+        std::__iterator_category(__first));
+       return false;
+     }
+ }
+    }
+# 2955 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__next_permutation
+ (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 2986 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+
+      return std::__next_permutation
+ (__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  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 (!__comp(--__j, __i))
+  {}
+       std::iter_swap(__i, __j);
+       std::__reverse(__ii, __last,
+        std::__iterator_category(__first));
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::__reverse(__first, __last,
+        std::__iterator_category(__first));
+       return false;
+     }
+ }
+    }
+# 3053 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__prev_permutation(__first, __last,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3084 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    inline bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+
+      return std::__prev_permutation(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+
+
+  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;
+    }
+# 3133 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    inline _OutputIterator
+    replace_copy(_InputIterator __first, _InputIterator __last,
+   _OutputIterator __result,
+   const _Tp& __old_value, const _Tp& __new_value)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      return std::__replace_copy_if(__first, __last, __result,
+   __gnu_cxx::__ops::__iter_equals_val(__old_value),
+           __new_value);
+    }
+# 3167 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate, typename _Tp>
+    inline _OutputIterator
+    replace_copy_if(_InputIterator __first, _InputIterator __last,
+      _OutputIterator __result,
+      _Predicate __pred, const _Tp& __new_value)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      return std::__replace_copy_if(__first, __last, __result,
+    __gnu_cxx::__ops::__pred_iter(__pred),
+           __new_value);
+    }
+
+  template<typename _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;
+    }
+# 3206 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
+    { return std::is_sorted_until(__first, __last) == __last; }
+# 3220 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+
+  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;
+    }
+# 3249 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+
+      return std::__is_sorted_until(__first, __last,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3272 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    inline _ForwardIterator
+    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
+      _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+
+      return std::__is_sorted_until(__first, __last,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 3296 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _Tp>
+    constexpr
+    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);
+    }
+# 3317 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _Tp, typename _Compare>
+    constexpr
+    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);
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    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);
+    }
+# 3397 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    constexpr
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+
+      return std::__minmax_element(__first, __last,
+       __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 3424 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline pair<_ForwardIterator, _ForwardIterator>
+    minmax_element(_ForwardIterator __first, _ForwardIterator __last,
+     _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+
+      return std::__minmax_element(__first, __last,
+       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+  template<typename _Tp>
+    constexpr
+    inline _Tp
+    min(initializer_list<_Tp> __l)
+    { return *std::min_element(__l.begin(), __l.end()); }
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline _Tp
+    min(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::min_element(__l.begin(), __l.end(), __comp); }
+
+  template<typename _Tp>
+    constexpr
+    inline _Tp
+    max(initializer_list<_Tp> __l)
+    { return *std::max_element(__l.begin(), __l.end()); }
+
+  template<typename _Tp, typename _Compare>
+    constexpr
+    inline _Tp
+    max(initializer_list<_Tp> __l, _Compare __comp)
+    { return *std::max_element(__l.begin(), __l.end(), __comp); }
+
+  template<typename _Tp>
+    constexpr
+    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>
+    constexpr
+    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);
+    }
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+
+
+      for (; __first1 != __last1; ++__first1, ++__first2)
+ if (!__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)
+ {
+   if (__scan != std::__find_if(__first1, __scan,
+     __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+     continue;
+
+   auto __matches
+     = std::__count_if(__first2, __last2,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+   if (0 == __matches ||
+       std::__count_if(__scan, __last1,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+       != __matches)
+     return false;
+ }
+      return true;
+    }
+# 3535 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__is_permutation(__first1, __last1, __first2,
+       __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 3566 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__is_permutation(__first1, __last1, __first2,
+       __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+       _BinaryPredicate __pred)
+    {
+      using _Cat1
+ = typename iterator_traits<_ForwardIterator1>::iterator_category;
+      using _Cat2
+ = typename iterator_traits<_ForwardIterator2>::iterator_category;
+      using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
+      using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
+      constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
+      if (__ra_iters)
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 != __d2)
+     return false;
+ }
+
+
+
+      for (; __first1 != __last1 && __first2 != __last2;
+   ++__first1, ++__first2)
+ if (!__pred(__first1, __first2))
+   break;
+
+      if (__ra_iters)
+ {
+   if (__first1 == __last1)
+     return true;
+ }
+      else
+ {
+   auto __d1 = std::distance(__first1, __last1);
+   auto __d2 = std::distance(__first2, __last2);
+   if (__d1 == 0 && __d2 == 0)
+     return true;
+   if (__d1 != __d2)
+     return false;
+ }
+
+      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
+ {
+   if (__scan != std::__find_if(__first1, __scan,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
+     continue;
+
+   auto __matches = std::__count_if(__first2, __last2,
+  __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
+   if (0 == __matches
+       || std::__count_if(__scan, __last1,
+   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
+       != __matches)
+     return false;
+ }
+      return true;
+    }
+# 3659 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+      ;
+      ;
+
+      return
+ std::__is_permutation(__first1, __last1, __first2, __last2,
+         __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 3686 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline bool
+    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+     _BinaryPredicate __pred)
+    {
+      ;
+      ;
+
+      return std::__is_permutation(__first1, __last1, __first2, __last2,
+       __gnu_cxx::__ops::__iter_comp_iter(__pred));
+    }
+# 3714 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)));
+    }
+
+
+
+
+
+
+
+# 3759 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+    }
+# 3780 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    find(_InputIterator __first, _InputIterator __last,
+  const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+# 3804 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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,
+       __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 3835 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 3875 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 3907 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+
+      return std::__adjacent_find(__first, __last,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 3932 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    inline _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+    _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+
+
+      ;
+
+      return std::__adjacent_find(__first, __last,
+   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
+    }
+# 3957 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Tp>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
+    {
+
+     
+     
+
+      ;
+
+      return std::__count_if(__first, __last,
+        __gnu_cxx::__ops::__iter_equals_val(__value));
+    }
+# 3980 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+
+     
+     
+
+      ;
+
+      return std::__count_if(__first, __last,
+        __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 4020 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__search(__first1, __last1, __first2, __last2,
+      __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 4059 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+    _BinaryPredicate __predicate)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__search(__first1, __last1, __first2, __last2,
+      __gnu_cxx::__ops::__iter_comp_iter(__predicate));
+    }
+# 4094 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+
+      return std::__search_n(__first, __last, __count,
+        __gnu_cxx::__ops::__iter_equals_val(__val));
+    }
+# 4127 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    inline _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val,
+      _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+
+      ;
+
+      return std::__search_n(__first, __last, __count,
+  __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
+    }
+# 4161 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 4198 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 4231 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 4263 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 4295 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Generator>
+    void
+    generate(_ForwardIterator __first, _ForwardIterator __last,
+      _Generator __gen)
+    {
+
+     
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ *__first = __gen();
+    }
+# 4326 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 4362 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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,
+    __gnu_cxx::__ops::__iter_equal_to_iter(),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4402 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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,
+   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4434 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+   {
+
+     _RandomAccessIterator __j = __first
+     + std::rand() % ((__i - __first) + 1);
+     if (__i != __j)
+       std::iter_swap(__i, __j);
+   }
+    }
+# 4468 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+ {
+   _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
+   if (__i != __j)
+     std::iter_swap(__i, __j);
+ }
+    }
+# 4508 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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));
+    }
+# 4541 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      std::__partial_sort(__first, __middle, __last,
+     __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4578 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last,
+   _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+
+      std::__partial_sort(__first, __middle, __last,
+     __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 4613 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      if (__first == __last || __nth == __last)
+ return;
+
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4651 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last, _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+      ;
+
+      if (__first == __last || __nth == __last)
+ return;
+
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 4687 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4716 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+
+      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    __merge(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first2, __first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 4776 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+      ;
+      ;
+
+      return std::__merge(__first1, __last1,
+         __first2, __last2, __result,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4824 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+      ;
+      ;
+
+      return std::__merge(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<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;
+
+      typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;
+      _TmpBuf __buf(__first, __last);
+
+      if (__buf.begin() == 0)
+ std::__inplace_stable_sort(__first, __last, __comp);
+      else
+ std::__stable_sort_adaptive(__first, __last, __buf.begin(),
+        _DistanceType(__buf.size()), __comp);
+    }
+# 4886 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+      std::__stable_sort(__first, __last,
+        __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 4919 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+
+      std::__stable_sort(__first, __last,
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+  _InputIterator2 __first2, _InputIterator2 __last2,
+  _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(__first1, __first2))
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   else if (__comp(__first2, __first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+       ++__first2;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 4986 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__set_union(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5033 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__set_union(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+         _InputIterator2 __first2, _InputIterator2 __last2,
+         _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   ++__first1;
+ else if (__comp(__first2, __first1))
+   ++__first2;
+ else
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__first2;
+     ++__result;
+   }
+      return __result;
+    }
+# 5101 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__set_intersection(__first1, __last1,
+         __first2, __last2, __result,
+         __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5147 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__set_intersection(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(__first2, __first1))
+   ++__first2;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first1, __last1, __result);
+    }
+# 5217 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__set_difference(__first1, __last1,
+       __first2, __last2, __result,
+       __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5265 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__set_difference(__first1, __last1,
+       __first2, __last2, __result,
+       __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator,
+    typename _Compare>
+    _OutputIterator
+    __set_symmetric_difference(_InputIterator1 __first1,
+          _InputIterator1 __last1,
+          _InputIterator2 __first2,
+          _InputIterator2 __last2,
+          _OutputIterator __result,
+          _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first1, __first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(__first2, __first1))
+   {
+     *__result = *__first2;
+     ++__first2;
+     ++__result;
+   }
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 5341 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__set_symmetric_difference(__first1, __last1,
+     __first2, __last2, __result,
+     __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5389 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    inline _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result,
+        _Compare __comp)
+    {
+
+     
+     
+     
+
+     
+
+     
+
+
+     
+
+
+      ;
+      ;
+
+      return std::__set_symmetric_difference(__first1, __last1,
+    __first2, __last2, __result,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    _ForwardIterator
+    __min_element(_ForwardIterator __first, _ForwardIterator __last,
+    _Compare __comp)
+    {
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(__first, __result))
+   __result = __first;
+      return __result;
+    }
+# 5440 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    constexpr
+    _ForwardIterator
+    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+
+      return std::__min_element(__first, __last,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5464 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+
+      return std::__min_element(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    _ForwardIterator
+    __max_element(_ForwardIterator __first, _ForwardIterator __last,
+    _Compare __comp)
+    {
+      if (__first == __last) return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(__result, __first))
+   __result = __first;
+      return __result;
+    }
+# 5502 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    constexpr
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+
+      return std::__max_element(__first, __last,
+    __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 5526 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    constexpr
+    inline _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+
+      return std::__max_element(__first, __last,
+    __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+
+
+}
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/algorithm" 2 3
+# 92 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 173 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+
+
+
+
+
+
+
+
+
+# 181 "../../include/QtCore/../../../../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;
+# 195 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+typedef long long qint64;
+typedef unsigned long long quint64;
+
+
+typedef qint64 qlonglong;
+typedef quint64 qulonglong;
+
+
+
+
+
+
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+typedef unsigned long ulong;
+
+
+
+typedef float qreal;
+# 356 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+extern "C"
+
+__attribute__((visibility("default"))) const char *qVersion() noexcept;
+# 384 "../../include/QtCore/../../../../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> {};
+# 424 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+}
+# 440 "../../include/QtCore/../../../../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 <> struct QIntegerForSize<16> { __extension__ typedef unsigned __int128 Unsigned; __extension__ typedef __int128 Signed; };
+
+template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
+typedef QIntegerForSize<8>::Signed qregisterint;
+typedef QIntegerForSize<8>::Unsigned qregisteruint;
+typedef QIntegerForSizeof<void*>::Unsigned quintptr;
+typedef QIntegerForSizeof<void*>::Signed qptrdiff;
+typedef qptrdiff qintptr;
+# 516 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+typedef int QNoImplicitBoolCast;
+
+
+
+
+
+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 - double(int(d-1)) + 0.5) + int(d-1); }
+constexpr inline int qRound(float d)
+{ return d >= 0.0f ? int(d + 0.5f) : int(d - float(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)); }
+# 609 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+class QDataStream;
+# 637 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+inline void qt_noop(void) {}
+# 664 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+__attribute__((__noreturn__)) __attribute__((visibility("default"))) void qTerminate() noexcept;
+
+
+
+
+
+
+
+__attribute__((visibility("default"))) bool qSharedBuild() noexcept;
+# 711 "../../include/QtCore/../../../../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) noexcept;
+# 732 "../../include/QtCore/../../../../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) noexcept;
+# 765 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+__attribute__((visibility("default"))) void qt_check_pointer(const char *, int);
+__attribute__((visibility("default"))) void qBadAlloc();
+# 778 "../../include/QtCore/../../../../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) __attribute__ ((__warn_unused_result__)) __attribute__((__unused__));
+constexpr static inline bool qFuzzyCompare(double p1, double p2)
+{
+    return (qAbs(p1 - p2) * 1000000000000. <= qMin(qAbs(p1), qAbs(p2)));
+}
+
+constexpr static inline bool qFuzzyCompare(float p1, float p2) __attribute__ ((__warn_unused_result__)) __attribute__((__unused__));
+constexpr static inline bool qFuzzyCompare(float p1, float p2)
+{
+    return (qAbs(p1 - p2) * 100000.f <= qMin(qAbs(p1), qAbs(p2)));
+}
+
+
+
+
+constexpr static inline bool qFuzzyIsNull(double d) __attribute__ ((__warn_unused_result__)) __attribute__((__unused__));
+constexpr static inline bool qFuzzyIsNull(double d)
+{
+    return qAbs(d) <= 0.000000000001;
+}
+
+
+
+
+constexpr static inline bool qFuzzyIsNull(float f) __attribute__ ((__warn_unused_result__)) __attribute__((__unused__));
+constexpr static inline bool qFuzzyIsNull(float f)
+{
+    return qAbs(f) <= 0.00001f;
+}
+
+
+
+
+
+
+static inline bool qIsNull(double d) __attribute__ ((__warn_unused_result__)) __attribute__((__unused__));
+static inline bool qIsNull(double d)
+{
+    union U {
+        double d;
+        quint64 u;
+    };
+    U val;
+    val.d = d;
+    return (val.u & static_cast<unsigned long long>(0x7fffffffffffffffULL)) == 0;
+}
+
+
+
+
+
+
+static inline bool qIsNull(float f) __attribute__ ((__warn_unused_result__)) __attribute__((__unused__));
+static inline bool qIsNull(float f)
+{
+    union U {
+        float f;
+        quint32 u;
+    };
+    U val;
+    val.f = f;
+    return (val.u & 0x7fffffff) == 0;
+}
+# 871 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+namespace QtPrivate
+{
+namespace SwapExceptionTester {
+    using std::swap;
+    template <typename T>
+    void checkSwap(T &t)
+        noexcept(noexcept(swap(t, t)));
+
+}
+}
+
+template <typename T>
+inline void qSwap(T &value1, T &value2)
+    noexcept(noexcept(QtPrivate::SwapExceptionTester::checkSwap(value1)))
+{
+    using std::swap;
+    swap(value1, value2);
+}
+# 897 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+__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);
+# 939 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+template <typename T>
+class QForeachContainer {
+    QForeachContainer &operator=(const QForeachContainer &) = delete;
+public:
+    inline QForeachContainer(const T& t) : c(t), i(c.begin()), e(c.end()), control(1) { }
+    const T c;
+    typename T::const_iterator i, e;
+    int control;
+};
+# 974 "../../include/QtCore/../../../../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(); }
+# 1007 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+__attribute__((visibility("default"))) QString qtTrId(const char *id, int n = -1);
+# 1036 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h"
+template <typename... Args>
+struct QNonConstOverload
+{
+    template <typename R, typename T>
+    constexpr auto operator()(R (T::*ptr)(Args...)) const noexcept -> decltype(ptr)
+    { return ptr; }
+
+    template <typename R, typename T>
+    static constexpr auto of(R (T::*ptr)(Args...)) noexcept -> decltype(ptr)
+    { return ptr; }
+};
+
+template <typename... Args>
+struct QConstOverload
+{
+    template <typename R, typename T>
+    constexpr auto operator()(R (T::*ptr)(Args...) const) const noexcept -> decltype(ptr)
+    { return ptr; }
+
+    template <typename R, typename T>
+    static constexpr auto of(R (T::*ptr)(Args...) const) noexcept -> decltype(ptr)
+    { return ptr; }
+};
+
+template <typename... Args>
+struct QOverload : QConstOverload<Args...>, QNonConstOverload<Args...>
+{
+    using QConstOverload<Args...>::of;
+    using QConstOverload<Args...>::operator();
+    using QNonConstOverload<Args...>::of;
+    using QNonConstOverload<Args...>::operator();
+
+    template <typename R>
+    constexpr auto operator()(R (*ptr)(Args...)) const noexcept -> decltype(ptr)
+    { return ptr; }
+
+    template <typename R>
+    static constexpr auto of(R (*ptr)(Args...)) noexcept -> decltype(ptr)
+    { return ptr; }
+};
+
+
+template <typename... Args> constexpr QOverload<Args...> qOverload __attribute__((__unused__)) = {};
+template <typename... Args> constexpr QConstOverload<Args...> qConstOverload __attribute__((__unused__)) = {};
+template <typename... Args> constexpr QNonConstOverload<Args...> qNonConstOverload __attribute__((__unused__)) = {};
+
+
+
+
+
+class QByteArray;
+__attribute__((visibility("default"))) QByteArray qgetenv(const char *varName);
+__attribute__((visibility("default"))) bool qputenv(const char *varName, const QByteArray& value);
+__attribute__((visibility("default"))) bool qunsetenv(const char *varName);
+
+__attribute__((visibility("default"))) bool qEnvironmentVariableIsEmpty(const char *varName) noexcept;
+__attribute__((visibility("default"))) bool qEnvironmentVariableIsSet(const char *varName) noexcept;
+__attribute__((visibility("default"))) int qEnvironmentVariableIntValue(const char *varName, bool *ok=nullptr) noexcept;
+
+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();
+# 1112 "../../include/QtCore/../../../../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; };
+
+template <bool B, typename T, typename F> struct QConditional { typedef T Type; };
+template <typename T, typename F> struct QConditional<false, T, F> { typedef F Type; };
+
+template <typename T> struct QAddConst { typedef const T Type; };
+}
+
+
+template <typename T>
+constexpr typename QtPrivate::QAddConst<T>::Type &qAsConst(T &t) noexcept { return t; }
+
+template <typename T>
+void qAsConst(const T &&) = delete;
+
+
+
+
+
+# 1 "../../include/QtCore/qtypeinfo.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h"
+# 1 "../../include/QtCore/qtypetraits.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 1
+# 107 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 1
+# 1 "../../include/QtCore/qglobal.h" 2
+# 108 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 2
+
+
+
+
+
+
+
+
+namespace QtPrivate {
+
+
+
+typedef char small_;
+
+struct big_ {
+  char dummy[2];
+};
+
+
+template <class T>
+struct identity_ {
+  typedef T type;
+};
+
+
+
+
+
+
+template<class T, T v>
+struct integral_constant {
+  static const T value = v;
+  typedef T value_type;
+  typedef integral_constant<T, v> type;
+};
+
+template <class T, T v> const T integral_constant<T, v>::value;
+
+
+
+
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+typedef true_type true_;
+typedef false_type false_;
+
+
+
+
+template<bool cond, typename A, typename B>
+struct if_{
+  typedef A type;
+};
+
+template<typename A, typename B>
+struct if_<false, A, B> {
+  typedef B type;
+};
+
+
+
+
+
+
+
+template<typename A, typename B>
+struct type_equals_ : public false_ {
+};
+
+template<typename A>
+struct type_equals_<A, A> : public true_ {
+};
+
+
+
+template<typename A, typename B>
+struct and_ : public integral_constant<bool, (A::value && B::value)> {
+};
+
+
+
+template<typename A, typename B>
+struct or_ : public integral_constant<bool, (A::value || B::value)> {
+};
+
+template <class T> struct is_integral;
+template <class T> struct is_floating_point;
+template <class T> struct is_pointer;
+
+
+
+template <class T> struct is_enum;
+
+template <class T> struct is_reference;
+template <class T> struct is_pod;
+template <class T> struct has_trivial_constructor;
+template <class T> struct has_trivial_copy;
+template <class T> struct has_trivial_assign;
+template <class T> struct has_trivial_destructor;
+template <class T> struct remove_const;
+template <class T> struct remove_volatile;
+template <class T> struct remove_cv;
+template <class T> struct remove_reference;
+template <class T> struct add_reference;
+template <class T> struct remove_pointer;
+template <class T, class U> struct is_same;
+
+template <class From, class To> struct is_convertible;
+
+
+
+
+template <class T> struct is_integral : false_type { };
+template<> struct is_integral<bool> : true_type { };
+template<> struct is_integral<char> : true_type { };
+template<> struct is_integral<unsigned char> : true_type { };
+template<> struct is_integral<signed char> : true_type { };
+
+
+
+
+
+
+template<> struct is_integral<wchar_t> : true_type { };
+
+template<> struct is_integral<short> : true_type { };
+template<> struct is_integral<unsigned short> : true_type { };
+template<> struct is_integral<int> : true_type { };
+template<> struct is_integral<unsigned int> : true_type { };
+template<> struct is_integral<long> : true_type { };
+template<> struct is_integral<unsigned long> : true_type { };
+
+
+
+
+template<> struct is_integral<long long> : true_type { };
+template<> struct is_integral<unsigned long long> : true_type { };
+
+template <class T> struct is_integral<const T> : is_integral<T> { };
+template <class T> struct is_integral<volatile T> : is_integral<T> { };
+template <class T> struct is_integral<const volatile T> : is_integral<T> { };
+
+template<> struct is_integral<char16_t> : true_type { };
+template<> struct is_integral<char32_t> : true_type { };
+
+
+
+
+template <class T> struct is_floating_point : false_type { };
+template<> struct is_floating_point<float> : true_type { };
+template<> struct is_floating_point<double> : true_type { };
+template<> struct is_floating_point<long double> : true_type { };
+template <class T> struct is_floating_point<const T>
+    : is_floating_point<T> { };
+template <class T> struct is_floating_point<volatile T>
+    : is_floating_point<T> { };
+template <class T> struct is_floating_point<const volatile T>
+    : is_floating_point<T> { };
+
+
+
+
+template <class T> struct is_pointer : false_type { };
+template <class T> struct is_pointer<T*> : true_type { };
+template <class T> struct is_pointer<const T> : is_pointer<T> { };
+template <class T> struct is_pointer<volatile T> : is_pointer<T> { };
+template <class T> struct is_pointer<const volatile T> : is_pointer<T> { };
+
+
+
+namespace internal {
+
+template <class T> struct is_class_or_union {
+  template <class U> static small_ tester(void (U::*)());
+  template <class U> static big_ tester(...);
+  static const bool value = sizeof(tester<T>(0)) == sizeof(small_);
+};
+
+
+
+template <bool NotUnum, class T> struct is_enum_impl
+    : is_convertible<typename add_reference<T>::type, int> { };
+
+template <class T> struct is_enum_impl<true, T> : false_type { };
+
+}
+# 311 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h"
+template <class T> struct is_enum
+    : internal::is_enum_impl<
+          is_same<T, void>::value ||
+              is_integral<T>::value ||
+              is_floating_point<T>::value ||
+              is_reference<T>::value ||
+              internal::is_class_or_union<T>::value,
+          T> { };
+
+template <class T> struct is_enum<const T> : is_enum<T> { };
+template <class T> struct is_enum<volatile T> : is_enum<T> { };
+template <class T> struct is_enum<const volatile T> : is_enum<T> { };
+
+
+
+
+template<typename T> struct is_reference : false_type {};
+template<typename T> struct is_reference<T&> : true_type {};
+
+
+template <typename T> struct is_const : false_type {};
+template <typename T> struct is_const<const T> : true_type {};
+template <typename T> struct is_volatile : false_type {};
+template <typename T> struct is_volatile<volatile T> : true_type {};
+
+
+
+
+
+template <class T> struct is_pod
+ : integral_constant<bool, (is_integral<T>::value ||
+                            is_floating_point<T>::value ||
+
+
+                            is_enum<T>::value ||
+
+                            is_pointer<T>::value)> { };
+template <class T> struct is_pod<const T> : is_pod<T> { };
+template <class T> struct is_pod<volatile T> : is_pod<T> { };
+template <class T> struct is_pod<const volatile T> : is_pod<T> { };
+
+
+
+
+
+
+
+template <class T> struct has_trivial_constructor : is_pod<T> { };
+template <class T, class U> struct has_trivial_constructor<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_constructor<T>::value &&
+                       has_trivial_constructor<U>::value)> { };
+template <class A, int N> struct has_trivial_constructor<A[N]>
+  : has_trivial_constructor<A> { };
+template <class T> struct has_trivial_constructor<const T>
+  : has_trivial_constructor<T> { };
+
+
+
+
+
+
+template <class T> struct has_trivial_copy : is_pod<T> { };
+template <class T, class U> struct has_trivial_copy<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_copy<T>::value &&
+                       has_trivial_copy<U>::value)> { };
+template <class A, int N> struct has_trivial_copy<A[N]>
+  : has_trivial_copy<A> { };
+template <class T> struct has_trivial_copy<const T> : has_trivial_copy<T> { };
+
+
+
+
+
+template <class T> struct has_trivial_assign : is_pod<T> { };
+template <class T, class U> struct has_trivial_assign<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_assign<T>::value &&
+                       has_trivial_assign<U>::value)> { };
+template <class A, int N> struct has_trivial_assign<A[N]>
+  : has_trivial_assign<A> { };
+
+
+
+
+
+
+template <class T> struct has_trivial_destructor : is_pod<T> { };
+template <class T, class U> struct has_trivial_destructor<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_destructor<T>::value &&
+                       has_trivial_destructor<U>::value)> { };
+template <class A, int N> struct has_trivial_destructor<A[N]>
+  : has_trivial_destructor<A> { };
+template <class T> struct has_trivial_destructor<const T>
+  : has_trivial_destructor<T> { };
+
+
+template<typename T> struct remove_const { typedef T type; };
+template<typename T> struct remove_const<T const> { typedef T type; };
+template<typename T> struct remove_volatile { typedef T type; };
+template<typename T> struct remove_volatile<T volatile> { typedef T type; };
+template<typename T> struct remove_cv {
+  typedef typename remove_const<typename remove_volatile<T>::type>::type type;
+};
+
+
+
+template<typename T> struct remove_reference { typedef T type; };
+template<typename T> struct remove_reference<T&> { typedef T type; };
+
+template <typename T> struct add_reference { typedef T& type; };
+template <typename T> struct add_reference<T&> { typedef T& type; };
+
+
+template<typename T> struct remove_pointer { typedef T type; };
+template<typename T> struct remove_pointer<T*> { typedef T type; };
+template<typename T> struct remove_pointer<T* const> { typedef T type; };
+template<typename T> struct remove_pointer<T* volatile> { typedef T type; };
+template<typename T> struct remove_pointer<T* const volatile> {
+  typedef T type; };
+
+
+template<typename T, typename U> struct is_same : public false_type { };
+template<typename T> struct is_same<T, T> : public true_type { };
+
+
+
+namespace internal {
+# 451 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h"
+template <typename From, typename To>
+struct ConvertHelper {
+  static small_ Test(To);
+  static big_ Test(...);
+  static From Create();
+};
+}
+
+
+template <typename From, typename To>
+struct is_convertible
+    : integral_constant<bool,
+                        sizeof(internal::ConvertHelper<From, To>::Test(
+                                  internal::ConvertHelper<From, To>::Create()))
+                        == sizeof(small_)> {
+};
+
+
+
+
+
+template <typename T>
+struct not_
+    : integral_constant<bool, !T::value> {};
+
+
+template <bool B>
+struct not_c
+    : integral_constant<bool, !B> {};
+
+
+template <typename T>
+struct is_unsigned
+    : integral_constant<bool, (T(0) < T(-1))> {};
+
+
+template <typename T>
+struct is_signed
+    : not_< is_unsigned<T> > {};
+
+static_assert(bool(( is_unsigned<quint8>::value)), "( is_unsigned<quint8>::value)");
+static_assert(bool((!is_unsigned<qint8>::value)), "(!is_unsigned<qint8>::value)");
+
+static_assert(bool((!is_signed<quint8>::value)), "(!is_signed<quint8>::value)");
+static_assert(bool(( is_signed<qint8>::value)), "( is_signed<qint8>::value)");
+
+static_assert(bool(( is_unsigned<quint16>::value)), "( is_unsigned<quint16>::value)");
+static_assert(bool((!is_unsigned<qint16>::value)), "(!is_unsigned<qint16>::value)");
+
+static_assert(bool((!is_signed<quint16>::value)), "(!is_signed<quint16>::value)");
+static_assert(bool(( is_signed<qint16>::value)), "( is_signed<qint16>::value)");
+
+static_assert(bool(( is_unsigned<quint32>::value)), "( is_unsigned<quint32>::value)");
+static_assert(bool((!is_unsigned<qint32>::value)), "(!is_unsigned<qint32>::value)");
+
+static_assert(bool((!is_signed<quint32>::value)), "(!is_signed<quint32>::value)");
+static_assert(bool(( is_signed<qint32>::value)), "( is_signed<qint32>::value)");
+
+static_assert(bool(( is_unsigned<quint64>::value)), "( is_unsigned<quint64>::value)");
+static_assert(bool((!is_unsigned<qint64>::value)), "(!is_unsigned<qint64>::value)");
+
+static_assert(bool((!is_signed<quint64>::value)), "(!is_signed<quint64>::value)");
+static_assert(bool(( is_signed<qint64>::value)), "( is_signed<qint64>::value)");
+
+template<class T = void> struct is_default_constructible;
+
+template<> struct is_default_constructible<void>
+{
+protected:
+    template<bool> struct test { typedef char type; };
+public:
+    static bool const value = false;
+};
+template<> struct is_default_constructible<>::test<true> { typedef double type; };
+
+template<class T> struct is_default_constructible : is_default_constructible<>
+{
+private:
+    template<class U> static typename test<!!sizeof(::new U())>::type sfinae(U*);
+    template<class U> static char sfinae(...);
+public:
+    static bool const value = sizeof(sfinae<T>(0)) > 1;
+};
+
+
+}
+
+
+# 1 "../../include/QtCore/qtypetraits.h" 2
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h" 2
+# 1 "../../include/QtCore/qisenum.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h" 1
+# 40 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h" 2
+# 63 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h"
+
+
+# 1 "../../include/QtCore/qisenum.h" 2
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h" 2
+
+
+
+
+
+# 57 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h"
+template <typename T>
+class QTypeInfo
+{
+public:
+    enum {
+        isPointer = false,
+        isIntegral = QtPrivate::is_integral<T>::value,
+        isComplex = true,
+        isStatic = true,
+        isRelocatable = __is_enum(T),
+        isLarge = (sizeof(T)>sizeof(void*)),
+        isDummy = false,
+        sizeOf = sizeof(T)
+    };
+};
+
+template<>
+class QTypeInfo<void>
+{
+public:
+    enum {
+        isPointer = false,
+        isIntegral = false,
+        isComplex = false,
+        isStatic = false,
+        isRelocatable = false,
+        isLarge = false,
+        isDummy = false,
+        sizeOf = 0
+    };
+};
+
+template <typename T>
+class QTypeInfo<T*>
+{
+public:
+    enum {
+        isPointer = true,
+        isIntegral = false,
+        isComplex = false,
+        isStatic = false,
+        isRelocatable = true,
+        isLarge = false,
+        isDummy = false,
+        sizeOf = sizeof(T*)
+    };
+};
+# 120 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h"
+template <typename T, typename = void>
+struct QTypeInfoQuery : public QTypeInfo<T>
+{
+    enum { isRelocatable = !QTypeInfo<T>::isStatic };
+};
+
+
+template <typename T>
+struct QTypeInfoQuery<T, typename QtPrivate::QEnableIf<QTypeInfo<T>::isRelocatable || true>::Type> : public QTypeInfo<T>
+{};
+# 151 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h"
+template <class T, class T1, class T2 = T1, class T3 = T1, class T4 = T1>
+class QTypeInfoMerger
+{
+public:
+    enum {
+        isComplex = QTypeInfoQuery<T1>::isComplex || QTypeInfoQuery<T2>::isComplex
+                    || QTypeInfoQuery<T3>::isComplex || QTypeInfoQuery<T4>::isComplex,
+        isStatic = QTypeInfoQuery<T1>::isStatic || QTypeInfoQuery<T2>::isStatic
+                    || QTypeInfoQuery<T3>::isStatic || QTypeInfoQuery<T4>::isStatic,
+        isRelocatable = QTypeInfoQuery<T1>::isRelocatable && QTypeInfoQuery<T2>::isRelocatable
+                    && QTypeInfoQuery<T3>::isRelocatable && QTypeInfoQuery<T4>::isRelocatable,
+        isLarge = sizeof(T) > sizeof(void*),
+        isPointer = false,
+        isIntegral = false,
+        isDummy = false,
+        sizeOf = sizeof(T)
+    };
+};
+# 188 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h"
+template <typename T> class QList; template <typename T> class QTypeInfo< QList<T> > { public: enum { isPointer = false, isIntegral = false, isComplex = true, isRelocatable = 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, isIntegral = false, isComplex = true, isRelocatable = 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, isIntegral = false, isComplex = true, isRelocatable = 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, isIntegral = false, isComplex = true, isRelocatable = 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, isIntegral = false, isComplex = true, isRelocatable = 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, isIntegral = false, isComplex = true, isRelocatable = true, isStatic = false, isLarge = (sizeof(QSet<T>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QSet<T>) }; };
+# 216 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h"
+template <typename K, typename V> class QMap; template <typename K, typename V> class QTypeInfo< QMap<K, V> > { public: enum { isPointer = false, isIntegral = false, isComplex = true, isStatic = (((5<<16)|(7<<8)|(0)) < ((6<<16)|(0<<8)|(0))), isRelocatable = true, isLarge = (sizeof(QMap<K, V>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QMap<K, V>) }; };
+template <typename K, typename V> class QMultiMap; template <typename K, typename V> class QTypeInfo< QMultiMap<K, V> > { public: enum { isPointer = false, isIntegral = false, isComplex = true, isStatic = (((5<<16)|(7<<8)|(0)) < ((6<<16)|(0<<8)|(0))), isRelocatable = true, isLarge = (sizeof(QMultiMap<K, V>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QMultiMap<K, V>) }; };
+template <typename K, typename V> class QHash; template <typename K, typename V> class QTypeInfo< QHash<K, V> > { public: enum { isPointer = false, isIntegral = false, isComplex = true, isStatic = (((5<<16)|(7<<8)|(0)) < ((6<<16)|(0<<8)|(0))), isRelocatable = true, isLarge = (sizeof(QHash<K, V>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QHash<K, V>) }; };
+template <typename K, typename V> class QMultiHash; template <typename K, typename V> class QTypeInfo< QMultiHash<K, V> > { public: enum { isPointer = false, isIntegral = false, isComplex = true, isStatic = (((5<<16)|(7<<8)|(0)) < ((6<<16)|(0<<8)|(0))), isRelocatable = true, isLarge = (sizeof(QMultiHash<K, V>) > sizeof(void*)), isDummy = false, sizeOf = sizeof(QMultiHash<K, V>) }; };
+# 231 "../../include/QtCore/../../../../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,
+    Q_RELOCATABLE_TYPE = 0x8
+};
+# 262 "../../include/QtCore/../../../../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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QFlags<T>)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QFlags<T> >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QFlags<T>) }; static inline const char *name() { return "QFlags<T>"; } };
+# 294 "../../include/QtCore/../../../../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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(bool)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< bool >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(char)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< char >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(signed char)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< signed char >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(uchar)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< uchar >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(short)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< short >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(ushort)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< ushort >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(int)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< int >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(uint)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< uint >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(long)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< long >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(ulong)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< ulong >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(qint64)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< qint64 >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(quint64)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< quint64 >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(float)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< float >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(double)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< double >::value, 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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(long double)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< long double >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(long double) }; static inline const char *name() { return "long double"; } };
+# 325 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h"
+template<> class QTypeInfo<char16_t > { public: enum { isComplex = (((Q_RELOCATABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_RELOCATABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_RELOCATABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(char16_t)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< char16_t >::value, isDummy = (((Q_RELOCATABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(char16_t) }; static inline const char *name() { return "char16_t"; } };
+template<> class QTypeInfo<char32_t > { public: enum { isComplex = (((Q_RELOCATABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_RELOCATABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_RELOCATABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(char32_t)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< char32_t >::value, isDummy = (((Q_RELOCATABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(char32_t) }; static inline const char *name() { return "char32_t"; } };
+
+
+template<> class QTypeInfo<wchar_t > { public: enum { isComplex = (((Q_RELOCATABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_RELOCATABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_RELOCATABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(wchar_t)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< wchar_t >::value, isDummy = (((Q_RELOCATABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(wchar_t) }; static inline const char *name() { return "wchar_t"; } };
+
+
+
+
+# 1 "../../include/QtCore/qtypeinfo.h" 2
+# 1135 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 1 "../../include/QtCore/qsysinfo.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qsysinfo.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qsysinfo.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qsysinfo.h" 2
+
+
+
+
+
+
+
+
+
+
+class QString;
+class __attribute__((visibility("default"))) QSysInfo {
+public:
+    enum Sizes {
+        WordSize = (sizeof(void *)<<3)
+    };
+# 67 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qsysinfo.h"
+    enum Endian {
+        BigEndian,
+        LittleEndian
+
+
+
+
+
+
+        , ByteOrder = LittleEndian
+
+
+
+    };
+
+    enum WinVersion {
+        WV_None = 0x0000,
+
+        WV_32s = 0x0001,
+        WV_95 = 0x0002,
+        WV_98 = 0x0003,
+        WV_Me = 0x0004,
+        WV_DOS_based= 0x000f,
+
+
+        WV_NT = 0x0010,
+        WV_2000 = 0x0020,
+        WV_XP = 0x0030,
+        WV_2003 = 0x0040,
+        WV_VISTA = 0x0080,
+        WV_WINDOWS7 = 0x0090,
+        WV_WINDOWS8 = 0x00a0,
+        WV_WINDOWS8_1 = 0x00b0,
+        WV_WINDOWS10 = 0x00c0,
+        WV_NT_based = 0x00f0,
+
+
+        WV_4_0 = WV_NT,
+        WV_5_0 = WV_2000,
+        WV_5_1 = WV_XP,
+        WV_5_2 = WV_2003,
+        WV_6_0 = WV_VISTA,
+        WV_6_1 = WV_WINDOWS7,
+        WV_6_2 = WV_WINDOWS8,
+        WV_6_3 = WV_WINDOWS8_1,
+        WV_10_0 = WV_WINDOWS10,
+
+        WV_CE = 0x0100,
+        WV_CENET = 0x0200,
+        WV_CE_5 = 0x0300,
+        WV_CE_6 = 0x0400,
+        WV_CE_based = 0x0f00
+    };
+
+
+
+
+    static const WinVersion WindowsVersion = WV_None;
+    static WinVersion windowsVersion() { return WV_None; }
+
+
+
+
+    enum MacVersion {
+        MV_None = 0xffff,
+        MV_Unknown = 0x0000,
+
+
+        MV_9 = (9 == 10 ? 0 + 2 : (9 == 9 ? 1 : 0)),
+        MV_10_0 = (10 == 10 ? 0 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_1 = (10 == 10 ? 1 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_2 = (10 == 10 ? 2 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_3 = (10 == 10 ? 3 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_4 = (10 == 10 ? 4 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_5 = (10 == 10 ? 5 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_6 = (10 == 10 ? 6 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_7 = (10 == 10 ? 7 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_8 = (10 == 10 ? 8 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_9 = (10 == 10 ? 9 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_10 = (10 == 10 ? 10 + 2 : (10 == 9 ? 1 : 0)),
+        MV_10_11 = (10 == 10 ? 11 + 2 : (10 == 9 ? 1 : 0)),
+
+
+        MV_CHEETAH = MV_10_0,
+        MV_PUMA = MV_10_1,
+        MV_JAGUAR = MV_10_2,
+        MV_PANTHER = MV_10_3,
+        MV_TIGER = MV_10_4,
+        MV_LEOPARD = MV_10_5,
+        MV_SNOWLEOPARD = MV_10_6,
+        MV_LION = MV_10_7,
+        MV_MOUNTAINLION = MV_10_8,
+        MV_MAVERICKS = MV_10_9,
+        MV_YOSEMITE = MV_10_10,
+        MV_ELCAPITAN = MV_10_11,
+
+
+        MV_IOS = 1 << 8,
+        MV_IOS_4_3 = (QSysInfo::MV_IOS | 4 << 4 | 3),
+        MV_IOS_5_0 = (QSysInfo::MV_IOS | 5 << 4 | 0),
+        MV_IOS_5_1 = (QSysInfo::MV_IOS | 5 << 4 | 1),
+        MV_IOS_6_0 = (QSysInfo::MV_IOS | 6 << 4 | 0),
+        MV_IOS_6_1 = (QSysInfo::MV_IOS | 6 << 4 | 1),
+        MV_IOS_7_0 = (QSysInfo::MV_IOS | 7 << 4 | 0),
+        MV_IOS_7_1 = (QSysInfo::MV_IOS | 7 << 4 | 1),
+        MV_IOS_8_0 = (QSysInfo::MV_IOS | 8 << 4 | 0),
+        MV_IOS_8_1 = (QSysInfo::MV_IOS | 8 << 4 | 1),
+        MV_IOS_8_2 = (QSysInfo::MV_IOS | 8 << 4 | 2),
+        MV_IOS_8_3 = (QSysInfo::MV_IOS | 8 << 4 | 3),
+        MV_IOS_8_4 = (QSysInfo::MV_IOS | 8 << 4 | 4),
+        MV_IOS_9_0 = (QSysInfo::MV_IOS | 9 << 4 | 0)
+    };
+
+
+
+
+    static const MacVersion MacintoshVersion = MV_None;
+    static MacVersion macVersion() { return MV_None; }
+
+
+    static QString buildCpuArchitecture();
+    static QString currentCpuArchitecture();
+    static QString buildAbi();
+
+    static QString kernelType();
+    static QString kernelVersion();
+    static QString productType();
+    static QString productVersion();
+    static QString prettyProductName();
+
+    static QString machineHostName();
+};
+
+
+# 1 "../../include/QtCore/qsysinfo.h" 2
+# 1136 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 1 "../../include/QtCore/qlogging.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qlogging.h" 1
+# 40 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qlogging.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qlogging.h" 2
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qlogging.h"
+
+
+
+
+
+
+
+class QDebug;
+class QNoDebug;
+
+enum QtMsgType { QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtInfoMsg, QtSystemMsg = QtCriticalMsg };
+
+class QMessageLogContext
+{
+    QMessageLogContext(const QMessageLogContext &) = delete; QMessageLogContext &operator=(const QMessageLogContext &) = delete;
+public:
+    constexpr QMessageLogContext()
+        : version(2), line(0), file(nullptr), function(nullptr), category(nullptr) {}
+    constexpr QMessageLogContext(const char *fileName, int lineNumber, const char *functionName, const char *categoryName)
+        : version(2), 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 QLoggingCategory;
+
+class __attribute__((visibility("default"))) QMessageLogger
+{
+    QMessageLogger(const QMessageLogger &) = delete; QMessageLogger &operator=(const QMessageLogger &) = delete;
+public:
+    constexpr 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, ...) const __attribute__((format(printf, (2), (3))));
+    void noDebug(const char *, ...) const __attribute__((format(printf, (2), (3))))
+    {}
+    void info(const char *msg, ...) const __attribute__((format(printf, (2), (3))));
+    void warning(const char *msg, ...) const __attribute__((format(printf, (2), (3))));
+    void critical(const char *msg, ...) const __attribute__((format(printf, (2), (3))));
+
+    typedef const QLoggingCategory &(*CategoryFunction)();
+
+    void debug(const QLoggingCategory &cat, const char *msg, ...) const __attribute__((format(printf, (3), (4))));
+    void debug(CategoryFunction catFunc, const char *msg, ...) const __attribute__((format(printf, (3), (4))));
+    void info(const QLoggingCategory &cat, const char *msg, ...) const __attribute__((format(printf, (3), (4))));
+    void info(CategoryFunction catFunc, const char *msg, ...) const __attribute__((format(printf, (3), (4))));
+    void warning(const QLoggingCategory &cat, const char *msg, ...) const __attribute__((format(printf, (3), (4))));
+    void warning(CategoryFunction catFunc, const char *msg, ...) const __attribute__((format(printf, (3), (4))));
+    void critical(const QLoggingCategory &cat, const char *msg, ...) const __attribute__((format(printf, (3), (4))));
+    void critical(CategoryFunction catFunc, const char *msg, ...) const __attribute__((format(printf, (3), (4))));
+
+
+    __attribute__((__noreturn__))
+
+    void fatal(const char *msg, ...) const noexcept __attribute__((format(printf, (2), (3))));
+
+
+    QDebug debug() const;
+    QDebug debug(const QLoggingCategory &cat) const;
+    QDebug debug(CategoryFunction catFunc) const;
+    QDebug info() const;
+    QDebug info(const QLoggingCategory &cat) const;
+    QDebug info(CategoryFunction catFunc) const;
+    QDebug warning() const;
+    QDebug warning(const QLoggingCategory &cat) const;
+    QDebug warning(CategoryFunction catFunc) const;
+    QDebug critical() const;
+    QDebug critical(const QLoggingCategory &cat) const;
+    QDebug critical(CategoryFunction catFunc) const;
+
+    QNoDebug noDebug() const noexcept;
+
+
+private:
+    QMessageLogContext context;
+};
+# 179 "../../include/QtCore/../../../../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 (*QtMessageHandler)(QtMsgType, const QMessageLogContext &, const QString &);
+__attribute__((visibility("default"))) QtMessageHandler qInstallMessageHandler(QtMessageHandler);
+
+__attribute__((visibility("default"))) void qSetMessagePattern(const QString &messagePattern);
+__attribute__((visibility("default"))) QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context,
+                                        const QString &buf);
+
+
+# 1 "../../include/QtCore/qlogging.h" 2
+# 1137 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+
+# 1 "../../include/QtCore/qflags.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qflags.h" 1
+# 40 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qflags.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qflags.h" 2
+
+
+
+
+# 1 "../../include/QtCore/qtypeinfo.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h"
+# 1 "../../include/QtCore/qtypetraits.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 1
+# 107 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 108 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 2
+# 1 "../../include/QtCore/qtypetraits.h" 2
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h" 2
+# 1 "../../include/QtCore/qisenum.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h" 1
+# 40 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h" 2
+# 1 "../../include/QtCore/qisenum.h" 2
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h" 2
+# 1 "../../include/QtCore/qtypeinfo.h" 2
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qflags.h" 2
+# 1 "../../include/QtCore/qtypetraits.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 1
+# 107 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 108 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 2
+# 1 "../../include/QtCore/qtypetraits.h" 2
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qflags.h" 2
+
+
+
+
+
+
+
+class QFlag
+{
+    int i;
+public:
+    constexpr inline QFlag(int ai) noexcept : i(ai) {}
+    constexpr inline operator int() const noexcept { return i; }
+# 69 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qflags.h"
+    constexpr inline QFlag(uint ai) noexcept : i(int(ai)) {}
+    constexpr inline QFlag(short ai) noexcept : i(int(ai)) {}
+    constexpr inline QFlag(ushort ai) noexcept : i(int(uint(ai))) {}
+    constexpr inline operator uint() const noexcept { return uint(i); }
+
+};
+template<> class QTypeInfo<QFlag > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QFlag)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QFlag >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QFlag) }; static inline const char *name() { return "QFlag"; } };
+
+class QIncompatibleFlag
+{
+    int i;
+public:
+    constexpr inline explicit QIncompatibleFlag(int i) noexcept;
+    constexpr inline operator int() const noexcept { return i; }
+};
+template<> class QTypeInfo<QIncompatibleFlag > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QIncompatibleFlag)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QIncompatibleFlag >::value, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QIncompatibleFlag) }; static inline const char *name() { return "QIncompatibleFlag"; } };
+
+constexpr inline QIncompatibleFlag::QIncompatibleFlag(int ai) noexcept : i(ai) {}
+
+
+
+
+template<typename Enum>
+class QFlags
+{
+    static_assert(bool((sizeof(Enum) <= sizeof(int))), "QFlags uses an int as storage, so an enum with underlying " "long long will overflow.")
+
+                                                 ;
+    struct Private;
+    typedef int (Private::*Zero);
+public:
+
+
+
+
+
+    typedef typename QtPrivate::if_<
+            QtPrivate::is_unsigned<Enum>::value,
+            unsigned int,
+            signed int
+        >::type Int;
+
+    typedef Enum enum_type;
+
+
+
+
+
+    constexpr inline QFlags(Enum f) noexcept : i(Int(f)) {}
+    constexpr inline QFlags(Zero = nullptr) noexcept : i(0) {}
+    constexpr inline QFlags(QFlag f) noexcept : i(f) {}
+
+
+    constexpr inline QFlags(std::initializer_list<Enum> flags) noexcept
+        : i(initializer_list_helper(flags.begin(), flags.end())) {}
+
+
+    constexpr inline QFlags &operator&=(int mask) noexcept { i &= mask; return *this; }
+    constexpr inline QFlags &operator&=(uint mask) noexcept { i &= mask; return *this; }
+    constexpr inline QFlags &operator&=(Enum mask) noexcept { i &= Int(mask); return *this; }
+    constexpr inline QFlags &operator|=(QFlags f) noexcept { i |= f.i; return *this; }
+    constexpr inline QFlags &operator|=(Enum f) noexcept { i |= Int(f); return *this; }
+    constexpr inline QFlags &operator^=(QFlags f) noexcept { i ^= f.i; return *this; }
+    constexpr inline QFlags &operator^=(Enum f) noexcept { i ^= Int(f); return *this; }
+
+    constexpr inline operator Int() const noexcept { return i; }
+
+    constexpr inline QFlags operator|(QFlags f) const noexcept { return QFlags(QFlag(i | f.i)); }
+    constexpr inline QFlags operator|(Enum f) const noexcept { return QFlags(QFlag(i | Int(f))); }
+    constexpr inline QFlags operator^(QFlags f) const noexcept { return QFlags(QFlag(i ^ f.i)); }
+    constexpr inline QFlags operator^(Enum f) const noexcept { return QFlags(QFlag(i ^ Int(f))); }
+    constexpr inline QFlags operator&(int mask) const noexcept { return QFlags(QFlag(i & mask)); }
+    constexpr inline QFlags operator&(uint mask) const noexcept { return QFlags(QFlag(i & mask)); }
+    constexpr inline QFlags operator&(Enum f) const noexcept { return QFlags(QFlag(i & Int(f))); }
+    constexpr inline QFlags operator~() const noexcept { return QFlags(QFlag(~i)); }
+
+    constexpr inline bool operator!() const noexcept { return !i; }
+
+    constexpr inline bool testFlag(Enum f) const noexcept { return (i & Int(f)) == Int(f) && (Int(f) != 0 || i == Int(f) ); }
+    constexpr inline QFlags &setFlag(Enum f, bool on = true) noexcept
+    {
+        return on ? (*this |= f) : (*this &= ~f);
+    }
+
+private:
+
+    constexpr static inline Int initializer_list_helper(typename std::initializer_list<Enum>::const_iterator it,
+                                                               typename std::initializer_list<Enum>::const_iterator end)
+    noexcept
+    {
+        return (it == end ? Int(0) : (Int(*it) | initializer_list_helper(it + 1, end)));
+    }
+
+
+    Int i;
+};
+# 188 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qflags.h"
+
+# 1 "../../include/QtCore/qflags.h" 2
+# 1139 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+
+
+
+
+# 1 "../../include/QtCore/qbasicatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qbasicatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qbasicatomic.h"
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+# 1 "../../include/QtCore/qatomic.h" 2
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qbasicatomic.h" 2
+# 53 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qbasicatomic.h"
+# 1 "../../include/QtCore/qatomic_cxx11.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/arch/qatomic_cxx11.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/arch/qatomic_cxx11.h"
+# 1 "../../include/QtCore/qgenericatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qgenericatomic.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qgenericatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qgenericatomic.h" 2
+# 1 "../../include/QtCore/qtypeinfo.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h"
+# 1 "../../include/QtCore/qtypetraits.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 1
+# 107 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 108 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 2
+# 1 "../../include/QtCore/qtypetraits.h" 2
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h" 2
+# 1 "../../include/QtCore/qisenum.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h" 1
+# 40 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h" 2
+# 1 "../../include/QtCore/qisenum.h" 2
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypeinfo.h" 2
+# 1 "../../include/QtCore/qtypeinfo.h" 2
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qgenericatomic.h" 2
+
+
+# 56 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qgenericatomic.h"
+template<int> struct QAtomicOpsSupport { enum { IsSupported = 0 }; };
+template<> struct QAtomicOpsSupport<4> { enum { IsSupported = 1 }; };
+
+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; };
+
+    template <typename T> static void acquireMemoryFence(const T &_q_value) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+    }
+    template <typename T> static void releaseMemoryFence(const T &_q_value) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+    }
+    template <typename T> static void orderedMemoryFence(const T &) noexcept
+    {
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T load(const T &_q_value) noexcept
+    {
+        return _q_value;
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    void store(T &_q_value, X newValue) noexcept
+    {
+        _q_value = newValue;
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T loadAcquire(const T &_q_value) noexcept
+    {
+        T tmp = *static_cast<const volatile T *>(&_q_value);
+        BaseClass::acquireMemoryFence(_q_value);
+        return tmp;
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    void storeRelease(T &_q_value, X newValue) noexcept
+    {
+        BaseClass::releaseMemoryFence(_q_value);
+        *static_cast<volatile T *>(&_q_value) = newValue;
+    }
+
+    static inline constexpr bool isReferenceCountingNative() noexcept
+    { return BaseClass::isFetchAndAddNative(); }
+    static inline constexpr bool isReferenceCountingWaitFree() noexcept
+    { return BaseClass::isFetchAndAddWaitFree(); }
+    template <typename T> static inline __attribute__((always_inline))
+    bool ref(T &_q_value) noexcept
+    {
+        return BaseClass::fetchAndAddRelaxed(_q_value, 1) != T(-1);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    bool deref(T &_q_value) noexcept
+    {
+         return BaseClass::fetchAndAddRelaxed(_q_value, -1) != 1;
+    }
+# 141 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qgenericatomic.h"
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue) noexcept
+    {
+        bool tmp = BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
+        BaseClass::acquireMemoryFence(_q_value);
+        return tmp;
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    bool testAndSetRelease(T &_q_value, X expectedValue, X newValue) noexcept
+    {
+        BaseClass::releaseMemoryFence(_q_value);
+        return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+        return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue);
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    bool testAndSetAcquire(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept
+    {
+        bool tmp = BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue, currentValue);
+        BaseClass::acquireMemoryFence(_q_value);
+        return tmp;
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    bool testAndSetRelease(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept
+    {
+        BaseClass::releaseMemoryFence(_q_value);
+        return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue, currentValue);
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    bool testAndSetOrdered(T &_q_value, X expectedValue, X newValue, X *currentValue) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+        return BaseClass::testAndSetRelaxed(_q_value, expectedValue, newValue, currentValue);
+    }
+
+    static inline constexpr bool isFetchAndStoreNative() noexcept { return false; }
+    static inline constexpr bool isFetchAndStoreWaitFree() noexcept { return false; }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    T fetchAndStoreRelaxed(T &_q_value, X newValue) noexcept
+    {
+
+        for(;;) {
+            T tmp = load(_q_value);
+            if (BaseClass::testAndSetRelaxed(_q_value, tmp, newValue))
+                return tmp;
+        }
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    T fetchAndStoreAcquire(T &_q_value, X newValue) noexcept
+    {
+        T tmp = BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
+        BaseClass::acquireMemoryFence(_q_value);
+        return tmp;
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    T fetchAndStoreRelease(T &_q_value, X newValue) noexcept
+    {
+        BaseClass::releaseMemoryFence(_q_value);
+        return BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
+    }
+
+    template <typename T, typename X> static inline __attribute__((always_inline))
+    T fetchAndStoreOrdered(T &_q_value, X newValue) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+        return BaseClass::fetchAndStoreRelaxed(_q_value, newValue);
+    }
+
+    static inline constexpr bool isFetchAndAddNative() noexcept { return false; }
+    static inline constexpr bool isFetchAndAddWaitFree() noexcept { return false; }
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndAddRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+
+        for(;;) {
+            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))
+    T fetchAndAddAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        T tmp = BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
+        BaseClass::acquireMemoryFence(_q_value);
+        return tmp;
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndAddRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        BaseClass::releaseMemoryFence(_q_value);
+        return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndAddOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+        return BaseClass::fetchAndAddRelaxed(_q_value, valueToAdd);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndSubRelaxed(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT operand) noexcept
+    {
+
+        return fetchAndAddRelaxed(_q_value, -operand);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndSubAcquire(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT operand) noexcept
+    {
+        T tmp = BaseClass::fetchAndSubRelaxed(_q_value, operand);
+        BaseClass::acquireMemoryFence(_q_value);
+        return tmp;
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndSubRelease(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT operand) noexcept
+    {
+        BaseClass::releaseMemoryFence(_q_value);
+        return BaseClass::fetchAndSubRelaxed(_q_value, operand);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndSubOrdered(T &_q_value, typename QAtomicAdditiveType<T>::AdditiveT operand) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+        return BaseClass::fetchAndSubRelaxed(_q_value, operand);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndAndRelaxed(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+
+        T tmp = BaseClass::load(_q_value);
+        for(;;) {
+            if (BaseClass::testAndSetRelaxed(_q_value, tmp, T(tmp & operand), &tmp))
+                return tmp;
+        }
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndAndAcquire(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+        T tmp = BaseClass::fetchAndAndRelaxed(_q_value, operand);
+        BaseClass::acquireMemoryFence(_q_value);
+        return tmp;
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndAndRelease(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+        BaseClass::releaseMemoryFence(_q_value);
+        return BaseClass::fetchAndAndRelaxed(_q_value, operand);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndAndOrdered(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+        return BaseClass::fetchAndAndRelaxed(_q_value, operand);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndOrRelaxed(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+
+        T tmp = BaseClass::load(_q_value);
+        for(;;) {
+            if (BaseClass::testAndSetRelaxed(_q_value, tmp, T(tmp | operand), &tmp))
+                return tmp;
+        }
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndOrAcquire(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+        T tmp = BaseClass::fetchAndOrRelaxed(_q_value, operand);
+        BaseClass::acquireMemoryFence(_q_value);
+        return tmp;
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndOrRelease(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+        BaseClass::releaseMemoryFence(_q_value);
+        return BaseClass::fetchAndOrRelaxed(_q_value, operand);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndOrOrdered(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+        return BaseClass::fetchAndOrRelaxed(_q_value, operand);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndXorRelaxed(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+
+        T tmp = BaseClass::load(_q_value);
+        for(;;) {
+            if (BaseClass::testAndSetRelaxed(_q_value, tmp, T(tmp ^ operand), &tmp))
+                return tmp;
+        }
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndXorAcquire(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+        T tmp = BaseClass::fetchAndXorRelaxed(_q_value, operand);
+        BaseClass::acquireMemoryFence(_q_value);
+        return tmp;
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndXorRelease(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+        BaseClass::releaseMemoryFence(_q_value);
+        return BaseClass::fetchAndXorRelaxed(_q_value, operand);
+    }
+
+    template <typename T> static inline __attribute__((always_inline))
+    T fetchAndXorOrdered(T &_q_value, typename QtPrivate::QEnableIf<QTypeInfo<T>::isIntegral, T>::Type operand) noexcept
+    {
+        BaseClass::orderedMemoryFence(_q_value);
+        return BaseClass::fetchAndXorRelaxed(_q_value, operand);
+    }
+};
+
+
+# 1 "../../include/QtCore/qgenericatomic.h" 2
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/arch/qatomic_cxx11.h" 2
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/atomic" 1 3
+# 35 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/atomic" 3
+       
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/atomic" 3
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_base.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_base.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_base.h" 3
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_base.h" 3
+
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_base.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 55 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_base.h" 3
+  typedef enum memory_order
+    {
+      memory_order_relaxed,
+      memory_order_consume,
+      memory_order_acquire,
+      memory_order_release,
+      memory_order_acq_rel,
+      memory_order_seq_cst
+    } memory_order;
+
+  enum __memory_order_modifier
+    {
+      __memory_order_mask = 0x0ffff,
+      __memory_order_modifier_mask = 0xffff0000,
+      __memory_order_hle_acquire = 0x10000,
+      __memory_order_hle_release = 0x20000
+    };
+
+  constexpr memory_order
+  operator|(memory_order __m, __memory_order_modifier __mod)
+  {
+    return memory_order(__m | int(__mod));
+  }
+
+  constexpr memory_order
+  operator&(memory_order __m, __memory_order_modifier __mod)
+  {
+    return memory_order(__m & int(__mod));
+  }
+
+
+  constexpr memory_order
+  __cmpexch_failure_order2(memory_order __m) noexcept
+  {
+    return __m == memory_order_acq_rel ? memory_order_acquire
+      : __m == memory_order_release ? memory_order_relaxed : __m;
+  }
+
+  constexpr memory_order
+  __cmpexch_failure_order(memory_order __m) noexcept
+  {
+    return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask)
+      | (__m & __memory_order_modifier_mask));
+  }
+
+  inline __attribute__((__always_inline__)) void
+  atomic_thread_fence(memory_order __m) noexcept
+  { __atomic_thread_fence(__m); }
+
+  inline __attribute__((__always_inline__)) void
+  atomic_signal_fence(memory_order __m) noexcept
+  { __atomic_signal_fence(__m); }
+
+
+  template<typename _Tp>
+    inline _Tp
+    kill_dependency(_Tp __y) noexcept
+    {
+      _Tp __ret(__y);
+      return __ret;
+    }
+
+
+
+  template<typename _IntTp>
+    struct __atomic_base;
+
+
+
+
+  template<typename _Tp>
+    struct atomic;
+
+  template<typename _Tp>
+    struct atomic<_Tp*>;
+
+
+
+    typedef bool __atomic_flag_data_type;
+# 148 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_base.h" 3
+  extern "C" {
+
+  struct __atomic_flag_base
+  {
+    __atomic_flag_data_type _M_i;
+  };
+
+  }
+
+
+
+
+  struct atomic_flag : public __atomic_flag_base
+  {
+    atomic_flag() noexcept = default;
+    ~atomic_flag() noexcept = default;
+    atomic_flag(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) = delete;
+    atomic_flag& operator=(const atomic_flag&) volatile = delete;
+
+
+    constexpr atomic_flag(bool __i) noexcept
+      : __atomic_flag_base{ _S_init(__i) }
+    { }
+
+    inline __attribute__((__always_inline__)) bool
+    test_and_set(memory_order __m = memory_order_seq_cst) noexcept
+    {
+      return __atomic_test_and_set (&_M_i, __m);
+    }
+
+    inline __attribute__((__always_inline__)) bool
+    test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+      return __atomic_test_and_set (&_M_i, __m);
+    }
+
+    inline __attribute__((__always_inline__)) void
+    clear(memory_order __m = memory_order_seq_cst) noexcept
+    {
+      memory_order __b = __m & __memory_order_mask;
+      ;
+      ;
+      ;
+
+      __atomic_clear (&_M_i, __m);
+    }
+
+    inline __attribute__((__always_inline__)) void
+    clear(memory_order __m = memory_order_seq_cst) volatile noexcept
+    {
+      memory_order __b = __m & __memory_order_mask;
+      ;
+      ;
+      ;
+
+      __atomic_clear (&_M_i, __m);
+    }
+
+  private:
+    static constexpr __atomic_flag_data_type
+    _S_init(bool __i)
+    { return __i ? 1 : 0; }
+  };
+# 237 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/atomic_base.h" 3
+  template<typename _ITp>
+    struct __atomic_base
+    {
+    private:
+      typedef _ITp __int_type;
+
+      static constexpr int _S_alignment =
+ sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);
+
+      alignas(_S_alignment) __int_type _M_i;
+
+    public:
+      __atomic_base() noexcept = default;
+      ~__atomic_base() noexcept = default;
+      __atomic_base(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) volatile = delete;
+
+
+      constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { }
+
+      operator __int_type() const noexcept
+      { return load(); }
+
+      operator __int_type() const volatile noexcept
+      { return load(); }
+
+      __int_type
+      operator=(__int_type __i) noexcept
+      {
+ store(__i);
+ return __i;
+      }
+
+      __int_type
+      operator=(__int_type __i) volatile noexcept
+      {
+ store(__i);
+ return __i;
+      }
+
+      __int_type
+      operator++(int) noexcept
+      { return fetch_add(1); }
+
+      __int_type
+      operator++(int) volatile noexcept
+      { return fetch_add(1); }
+
+      __int_type
+      operator--(int) noexcept
+      { return fetch_sub(1); }
+
+      __int_type
+      operator--(int) volatile noexcept
+      { return fetch_sub(1); }
+
+      __int_type
+      operator++() noexcept
+      { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, memory_order_seq_cst); }
+
+      __int_type
+      operator+=(__int_type __i) noexcept
+      { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator+=(__int_type __i) volatile noexcept
+      { return __atomic_add_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator-=(__int_type __i) noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator-=(__int_type __i) volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator&=(__int_type __i) noexcept
+      { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator&=(__int_type __i) volatile noexcept
+      { return __atomic_and_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator|=(__int_type __i) noexcept
+      { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator|=(__int_type __i) volatile noexcept
+      { return __atomic_or_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator^=(__int_type __i) noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      __int_type
+      operator^=(__int_type __i) volatile noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, memory_order_seq_cst); }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-__alignof(_M_i)));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-__alignof(_M_i)));
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ __atomic_store_n(&_M_i, __i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__int_type __i,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ __atomic_store_n(&_M_i, __i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+       memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+
+ return __atomic_load_n(&_M_i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+
+ return __atomic_load_n(&_M_i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      exchange(__int_type __i,
+        memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return __atomic_exchange_n(&_M_i, __i, __m);
+      }
+
+
+      inline __attribute__((__always_inline__)) __int_type
+      exchange(__int_type __i,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return __atomic_exchange_n(&_M_i, __i, __m);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+       memory_order __m1, memory_order __m2) noexcept
+      {
+       memory_order __b2 = __m2 & __memory_order_mask;
+       memory_order __b1 = __m1 & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+       memory_order __m1,
+       memory_order __m2) volatile noexcept
+      {
+       memory_order __b2 = __m2 & __memory_order_mask;
+       memory_order __b1 = __m1 & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+       memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return compare_exchange_weak(__i1, __i2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_weak(__int_type& __i1, __int_type __i2,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return compare_exchange_weak(__i1, __i2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+         memory_order __m1, memory_order __m2) noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+         memory_order __m1,
+         memory_order __m2) volatile noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+         memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return compare_exchange_strong(__i1, __i2, __m,
+           __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__int_type& __i1, __int_type __i2,
+   memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return compare_exchange_strong(__i1, __i2, __m,
+           __cmpexch_failure_order(__m));
+      }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_add(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_add(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_add(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_add(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_sub(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_sub(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_sub(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_sub(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_and(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_and(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_and(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_and(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_or(__int_type __i,
+        memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_or(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_or(__int_type __i,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_or(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_xor(__int_type __i,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_xor(&_M_i, __i, __m); }
+
+      inline __attribute__((__always_inline__)) __int_type
+      fetch_xor(__int_type __i,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_xor(&_M_i, __i, __m); }
+    };
+
+
+
+  template<typename _PTp>
+    struct __atomic_base<_PTp*>
+    {
+    private:
+      typedef _PTp* __pointer_type;
+
+      __pointer_type _M_p;
+
+
+      constexpr ptrdiff_t
+      _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); }
+
+      constexpr ptrdiff_t
+      _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); }
+
+    public:
+      __atomic_base() noexcept = default;
+      ~__atomic_base() noexcept = default;
+      __atomic_base(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) = delete;
+      __atomic_base& operator=(const __atomic_base&) volatile = delete;
+
+
+      constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { }
+
+      operator __pointer_type() const noexcept
+      { return load(); }
+
+      operator __pointer_type() const volatile noexcept
+      { return load(); }
+
+      __pointer_type
+      operator=(__pointer_type __p) noexcept
+      {
+ store(__p);
+ return __p;
+      }
+
+      __pointer_type
+      operator=(__pointer_type __p) volatile noexcept
+      {
+ store(__p);
+ return __p;
+      }
+
+      __pointer_type
+      operator++(int) noexcept
+      { return fetch_add(1); }
+
+      __pointer_type
+      operator++(int) volatile noexcept
+      { return fetch_add(1); }
+
+      __pointer_type
+      operator--(int) noexcept
+      { return fetch_sub(1); }
+
+      __pointer_type
+      operator--(int) volatile noexcept
+      { return fetch_sub(1); }
+
+      __pointer_type
+      operator++() noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+      memory_order_seq_cst); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+      memory_order_seq_cst); }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_p),
+     reinterpret_cast<void *>(-__alignof(_M_p)));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_p),
+     reinterpret_cast<void *>(-__alignof(_M_p)));
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+
+ ;
+ ;
+ ;
+
+ __atomic_store_n(&_M_p, __p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ __atomic_store_n(&_M_p, __p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+
+ return __atomic_load_n(&_M_p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+        memory_order __b = __m & __memory_order_mask;
+ ;
+ ;
+
+ return __atomic_load_n(&_M_p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return __atomic_exchange_n(&_M_p, __p, __m);
+      }
+
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return __atomic_exchange_n(&_M_p, __p, __m);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1,
+         memory_order __m2) noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1,
+         memory_order __m2) volatile noexcept
+      {
+        memory_order __b2 = __m2 & __memory_order_mask;
+        memory_order __b1 = __m1 & __memory_order_mask;
+
+ ;
+ ;
+ ;
+
+ return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, __m1, __m2);
+      }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_add(&_M_p, _M_type_size(__d), __m); }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
+
+      inline __attribute__((__always_inline__)) __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), __m); }
+    };
+
+
+
+
+}
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/atomic" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct atomic;
+
+
+
+  template<>
+  struct atomic<bool>
+  {
+  private:
+    __atomic_base<bool> _M_base;
+
+  public:
+    atomic() noexcept = default;
+    ~atomic() noexcept = default;
+    atomic(const atomic&) = delete;
+    atomic& operator=(const atomic&) = delete;
+    atomic& operator=(const atomic&) volatile = delete;
+
+    constexpr atomic(bool __i) noexcept : _M_base(__i) { }
+
+    bool
+    operator=(bool __i) noexcept
+    { return _M_base.operator=(__i); }
+
+    bool
+    operator=(bool __i) volatile noexcept
+    { return _M_base.operator=(__i); }
+
+    operator bool() const noexcept
+    { return _M_base.load(); }
+
+    operator bool() const volatile noexcept
+    { return _M_base.load(); }
+
+    bool
+    is_lock_free() const noexcept { return _M_base.is_lock_free(); }
+
+    bool
+    is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }
+
+    void
+    store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
+    { _M_base.store(__i, __m); }
+
+    void
+    store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
+    { _M_base.store(__i, __m); }
+
+    bool
+    load(memory_order __m = memory_order_seq_cst) const noexcept
+    { return _M_base.load(__m); }
+
+    bool
+    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+    { return _M_base.load(__m); }
+
+    bool
+    exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.exchange(__i, __m); }
+
+    bool
+    exchange(bool __i,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.exchange(__i, __m); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
+     memory_order __m2) noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
+     memory_order __m2) volatile noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2,
+     memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_weak(bool& __i1, bool __i2,
+       memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
+       memory_order __m2) noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
+       memory_order __m2) volatile noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2,
+       memory_order __m = memory_order_seq_cst) noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
+
+    bool
+    compare_exchange_strong(bool& __i1, bool __i2,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }
+  };
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct atomic
+    {
+    private:
+
+      static constexpr int _S_min_alignment
+ = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
+ ? 0 : sizeof(_Tp);
+
+      static constexpr int _S_alignment
+        = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);
+
+      alignas(_S_alignment) _Tp _M_i;
+
+      static_assert(__is_trivially_copyable(_Tp),
+      "std::atomic requires a trivially copyable type");
+
+      static_assert(sizeof(_Tp) > 0,
+      "Incomplete or zero-sized types are not supported");
+
+    public:
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(_Tp __i) noexcept : _M_i(__i) { }
+
+      operator _Tp() const noexcept
+      { return load(); }
+
+      operator _Tp() const volatile noexcept
+      { return load(); }
+
+      _Tp
+      operator=(_Tp __i) noexcept
+      { store(__i); return __i; }
+
+      _Tp
+      operator=(_Tp __i) volatile noexcept
+      { store(__i); return __i; }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-__alignof(_M_i)));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-__alignof(_M_i)));
+      }
+
+      void
+      store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
+      { __atomic_store(&_M_i, &__i, __m); }
+
+      void
+      store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
+      { __atomic_store(&_M_i, &__i, __m); }
+
+      _Tp
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      {
+        _Tp tmp;
+ __atomic_load(&_M_i, &tmp, __m);
+ return tmp;
+      }
+
+      _Tp
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      {
+        _Tp tmp;
+ __atomic_load(&_M_i, &tmp, __m);
+ return tmp;
+      }
+
+      _Tp
+      exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
+      {
+        _Tp tmp;
+ __atomic_exchange(&_M_i, &__i, &tmp, __m);
+ return tmp;
+      }
+
+      _Tp
+      exchange(_Tp __i,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+        _Tp tmp;
+ __atomic_exchange(&_M_i, &__i, &tmp, __m);
+ return tmp;
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
+       memory_order __f) noexcept
+      {
+ return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
+       memory_order __f) volatile noexcept
+      {
+ return __atomic_compare_exchange(&_M_i, &__e, &__i, true, __s, __f);
+      }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i,
+       memory_order __m = memory_order_seq_cst) noexcept
+      { return compare_exchange_weak(__e, __i, __m,
+                                     __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_weak(_Tp& __e, _Tp __i,
+       memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return compare_exchange_weak(__e, __i, __m,
+                                     __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
+         memory_order __f) noexcept
+      {
+ return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
+      }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
+         memory_order __f) volatile noexcept
+      {
+ return __atomic_compare_exchange(&_M_i, &__e, &__i, false, __s, __f);
+      }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i,
+          memory_order __m = memory_order_seq_cst) noexcept
+      { return compare_exchange_strong(__e, __i, __m,
+                                       __cmpexch_failure_order(__m)); }
+
+      bool
+      compare_exchange_strong(_Tp& __e, _Tp __i,
+       memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return compare_exchange_strong(__e, __i, __m,
+                                       __cmpexch_failure_order(__m)); }
+    };
+
+
+
+  template<typename _Tp>
+    struct atomic<_Tp*>
+    {
+      typedef _Tp* __pointer_type;
+      typedef __atomic_base<_Tp*> __base_type;
+      __base_type _M_b;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }
+
+      operator __pointer_type() const noexcept
+      { return __pointer_type(_M_b); }
+
+      operator __pointer_type() const volatile noexcept
+      { return __pointer_type(_M_b); }
+
+      __pointer_type
+      operator=(__pointer_type __p) noexcept
+      { return _M_b.operator=(__p); }
+
+      __pointer_type
+      operator=(__pointer_type __p) volatile noexcept
+      { return _M_b.operator=(__p); }
+
+      __pointer_type
+      operator++(int) noexcept
+      { return _M_b++; }
+
+      __pointer_type
+      operator++(int) volatile noexcept
+      { return _M_b++; }
+
+      __pointer_type
+      operator--(int) noexcept
+      { return _M_b--; }
+
+      __pointer_type
+      operator--(int) volatile noexcept
+      { return _M_b--; }
+
+      __pointer_type
+      operator++() noexcept
+      { return ++_M_b; }
+
+      __pointer_type
+      operator++() volatile noexcept
+      { return ++_M_b; }
+
+      __pointer_type
+      operator--() noexcept
+      { return --_M_b; }
+
+      __pointer_type
+      operator--() volatile noexcept
+      { return --_M_b; }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) noexcept
+      { return _M_b.operator+=(__d); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) volatile noexcept
+      { return _M_b.operator+=(__d); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) noexcept
+      { return _M_b.operator-=(__d); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) volatile noexcept
+      { return _M_b.operator-=(__d); }
+
+      bool
+      is_lock_free() const noexcept
+      { return _M_b.is_lock_free(); }
+
+      bool
+      is_lock_free() const volatile noexcept
+      { return _M_b.is_lock_free(); }
+
+      void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.store(__p, __m); }
+
+      void
+      store(__pointer_type __p,
+     memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.store(__p, __m); }
+
+      __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const noexcept
+      { return _M_b.load(__m); }
+
+      __pointer_type
+      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
+      { return _M_b.load(__m); }
+
+      __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.exchange(__p, __m); }
+
+      __pointer_type
+      exchange(__pointer_type __p,
+        memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.exchange(__p, __m); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+       memory_order __m1, memory_order __m2) noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+       memory_order __m1,
+       memory_order __m2) volatile noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+       memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return compare_exchange_weak(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return compare_exchange_weak(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1, memory_order __m2) noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m1,
+         memory_order __m2) volatile noexcept
+      { return _M_b.compare_exchange_strong(__p1, __p2, __m1, __m2); }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+         memory_order __m = memory_order_seq_cst) noexcept
+      {
+ return _M_b.compare_exchange_strong(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      bool
+      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
+      memory_order __m = memory_order_seq_cst) volatile noexcept
+      {
+ return _M_b.compare_exchange_strong(__p1, __p2, __m,
+         __cmpexch_failure_order(__m));
+      }
+
+      __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.fetch_add(__d, __m); }
+
+      __pointer_type
+      fetch_add(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.fetch_add(__d, __m); }
+
+      __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) noexcept
+      { return _M_b.fetch_sub(__d, __m); }
+
+      __pointer_type
+      fetch_sub(ptrdiff_t __d,
+  memory_order __m = memory_order_seq_cst) volatile noexcept
+      { return _M_b.fetch_sub(__d, __m); }
+    };
+
+
+
+  template<>
+    struct atomic<char> : __atomic_base<char>
+    {
+      typedef char __integral_type;
+      typedef __atomic_base<char> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<signed char> : __atomic_base<signed char>
+    {
+      typedef signed char __integral_type;
+      typedef __atomic_base<signed char> __base_type;
+
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned char> : __atomic_base<unsigned char>
+    {
+      typedef unsigned char __integral_type;
+      typedef __atomic_base<unsigned char> __base_type;
+
+      atomic() noexcept= default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<short> : __atomic_base<short>
+    {
+      typedef short __integral_type;
+      typedef __atomic_base<short> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned short> : __atomic_base<unsigned short>
+    {
+      typedef unsigned short __integral_type;
+      typedef __atomic_base<unsigned short> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<int> : __atomic_base<int>
+    {
+      typedef int __integral_type;
+      typedef __atomic_base<int> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned int> : __atomic_base<unsigned int>
+    {
+      typedef unsigned int __integral_type;
+      typedef __atomic_base<unsigned int> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<long> : __atomic_base<long>
+    {
+      typedef long __integral_type;
+      typedef __atomic_base<long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned long> : __atomic_base<unsigned long>
+    {
+      typedef unsigned long __integral_type;
+      typedef __atomic_base<unsigned long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<long long> : __atomic_base<long long>
+    {
+      typedef long long __integral_type;
+      typedef __atomic_base<long long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<unsigned long long> : __atomic_base<unsigned long long>
+    {
+      typedef unsigned long long __integral_type;
+      typedef __atomic_base<unsigned long long> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<wchar_t> : __atomic_base<wchar_t>
+    {
+      typedef wchar_t __integral_type;
+      typedef __atomic_base<wchar_t> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<char16_t> : __atomic_base<char16_t>
+    {
+      typedef char16_t __integral_type;
+      typedef __atomic_base<char16_t> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+  template<>
+    struct atomic<char32_t> : __atomic_base<char32_t>
+    {
+      typedef char32_t __integral_type;
+      typedef __atomic_base<char32_t> __base_type;
+
+      atomic() noexcept = default;
+      ~atomic() noexcept = default;
+      atomic(const atomic&) = delete;
+      atomic& operator=(const atomic&) = delete;
+      atomic& operator=(const atomic&) volatile = delete;
+
+      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }
+
+      using __base_type::operator __integral_type;
+      using __base_type::operator=;
+    };
+
+
+
+  typedef atomic<bool> atomic_bool;
+
+
+  typedef atomic<char> atomic_char;
+
+
+  typedef atomic<signed char> atomic_schar;
+
+
+  typedef atomic<unsigned char> atomic_uchar;
+
+
+  typedef atomic<short> atomic_short;
+
+
+  typedef atomic<unsigned short> atomic_ushort;
+
+
+  typedef atomic<int> atomic_int;
+
+
+  typedef atomic<unsigned int> atomic_uint;
+
+
+  typedef atomic<long> atomic_long;
+
+
+  typedef atomic<unsigned long> atomic_ulong;
+
+
+  typedef atomic<long long> atomic_llong;
+
+
+  typedef atomic<unsigned long long> atomic_ullong;
+
+
+  typedef atomic<wchar_t> atomic_wchar_t;
+
+
+  typedef atomic<char16_t> atomic_char16_t;
+
+
+  typedef atomic<char32_t> atomic_char32_t;
+
+
+
+  typedef atomic<int_least8_t> atomic_int_least8_t;
+
+
+  typedef atomic<uint_least8_t> atomic_uint_least8_t;
+
+
+  typedef atomic<int_least16_t> atomic_int_least16_t;
+
+
+  typedef atomic<uint_least16_t> atomic_uint_least16_t;
+
+
+  typedef atomic<int_least32_t> atomic_int_least32_t;
+
+
+  typedef atomic<uint_least32_t> atomic_uint_least32_t;
+
+
+  typedef atomic<int_least64_t> atomic_int_least64_t;
+
+
+  typedef atomic<uint_least64_t> atomic_uint_least64_t;
+
+
+
+  typedef atomic<int_fast8_t> atomic_int_fast8_t;
+
+
+  typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
+
+
+  typedef atomic<int_fast16_t> atomic_int_fast16_t;
+
+
+  typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
+
+
+  typedef atomic<int_fast32_t> atomic_int_fast32_t;
+
+
+  typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
+
+
+  typedef atomic<int_fast64_t> atomic_int_fast64_t;
+
+
+  typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
+
+
+
+  typedef atomic<intptr_t> atomic_intptr_t;
+
+
+  typedef atomic<uintptr_t> atomic_uintptr_t;
+
+
+  typedef atomic<size_t> atomic_size_t;
+
+
+  typedef atomic<intmax_t> atomic_intmax_t;
+
+
+  typedef atomic<uintmax_t> atomic_uintmax_t;
+
+
+  typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
+
+
+
+  inline bool
+  atomic_flag_test_and_set_explicit(atomic_flag* __a,
+        memory_order __m) noexcept
+  { return __a->test_and_set(__m); }
+
+  inline bool
+  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
+        memory_order __m) noexcept
+  { return __a->test_and_set(__m); }
+
+  inline void
+  atomic_flag_clear_explicit(atomic_flag* __a, memory_order __m) noexcept
+  { __a->clear(__m); }
+
+  inline void
+  atomic_flag_clear_explicit(volatile atomic_flag* __a,
+        memory_order __m) noexcept
+  { __a->clear(__m); }
+
+  inline bool
+  atomic_flag_test_and_set(atomic_flag* __a) noexcept
+  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
+
+  inline bool
+  atomic_flag_test_and_set(volatile atomic_flag* __a) noexcept
+  { return atomic_flag_test_and_set_explicit(__a, memory_order_seq_cst); }
+
+  inline void
+  atomic_flag_clear(atomic_flag* __a) noexcept
+  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
+
+  inline void
+  atomic_flag_clear(volatile atomic_flag* __a) noexcept
+  { atomic_flag_clear_explicit(__a, memory_order_seq_cst); }
+
+
+
+  template<typename _ITp>
+    inline bool
+    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
+    { return __a->is_lock_free(); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
+    { return __a->is_lock_free(); }
+
+  template<typename _ITp>
+    inline void
+    atomic_init(atomic<_ITp>* __a, _ITp __i) noexcept
+    { __a->store(__i, memory_order_relaxed); }
+
+  template<typename _ITp>
+    inline void
+    atomic_init(volatile atomic<_ITp>* __a, _ITp __i) noexcept
+    { __a->store(__i, memory_order_relaxed); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store_explicit(atomic<_ITp>* __a, _ITp __i,
+     memory_order __m) noexcept
+    { __a->store(__i, __m); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store_explicit(volatile atomic<_ITp>* __a, _ITp __i,
+     memory_order __m) noexcept
+    { __a->store(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
+    { return __a->load(__m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load_explicit(const volatile atomic<_ITp>* __a,
+    memory_order __m) noexcept
+    { return __a->load(__m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange_explicit(atomic<_ITp>* __a, _ITp __i,
+        memory_order __m) noexcept
+    { return __a->exchange(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange_explicit(volatile atomic<_ITp>* __a, _ITp __i,
+        memory_order __m) noexcept
+    { return __a->exchange(__i, __m); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
+       _ITp* __i1, _ITp __i2,
+       memory_order __m1,
+       memory_order __m2) noexcept
+    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
+       _ITp* __i1, _ITp __i2,
+       memory_order __m1,
+       memory_order __m2) noexcept
+    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
+         _ITp* __i1, _ITp __i2,
+         memory_order __m1,
+         memory_order __m2) noexcept
+    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
+         _ITp* __i1, _ITp __i2,
+         memory_order __m1,
+         memory_order __m2) noexcept
+    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }
+
+
+  template<typename _ITp>
+    inline void
+    atomic_store(atomic<_ITp>* __a, _ITp __i) noexcept
+    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline void
+    atomic_store(volatile atomic<_ITp>* __a, _ITp __i) noexcept
+    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load(const atomic<_ITp>* __a) noexcept
+    { return atomic_load_explicit(__a, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_load(const volatile atomic<_ITp>* __a) noexcept
+    { return atomic_load_explicit(__a, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange(atomic<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_exchange(volatile atomic<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak(atomic<_ITp>* __a,
+     _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
+         memory_order_seq_cst,
+         memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
+     _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
+         memory_order_seq_cst,
+         memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong(atomic<_ITp>* __a,
+       _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
+           memory_order_seq_cst,
+           memory_order_seq_cst);
+    }
+
+  template<typename _ITp>
+    inline bool
+    atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
+       _ITp* __i1, _ITp __i2) noexcept
+    {
+      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
+           memory_order_seq_cst,
+           memory_order_seq_cst);
+    }
+
+
+
+
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_sub(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_sub(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_and(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_and(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+        memory_order __m) noexcept
+    { return __a->fetch_or(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+        memory_order __m) noexcept
+    { return __a->fetch_or(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_xor(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a, _ITp __i,
+         memory_order __m) noexcept
+    { return __a->fetch_xor(__i, __m); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_add(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_sub(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_and(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_or(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor(__atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
+
+  template<typename _ITp>
+    inline _ITp
+    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a, _ITp __i) noexcept
+    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }
+
+
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add_explicit(volatile atomic<_ITp*>* __a, ptrdiff_t __d,
+         memory_order __m) noexcept
+    { return __a->fetch_add(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_add(__d); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_add(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_add(__d); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub_explicit(volatile atomic<_ITp*>* __a,
+         ptrdiff_t __d, memory_order __m) noexcept
+    { return __a->fetch_sub(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub_explicit(atomic<_ITp*>* __a, ptrdiff_t __d,
+         memory_order __m) noexcept
+    { return __a->fetch_sub(__d, __m); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub(volatile atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_sub(__d); }
+
+  template<typename _ITp>
+    inline _ITp*
+    atomic_fetch_sub(atomic<_ITp*>* __a, ptrdiff_t __d) noexcept
+    { return __a->fetch_sub(__d); }
+
+
+
+}
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/arch/qatomic_cxx11.h" 2
+
+
+# 72 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/arch/qatomic_cxx11.h"
+
+# 72 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/arch/qatomic_cxx11.h"
+template<> struct QAtomicOpsSupport<1> { enum { IsSupported = 1 }; };
+template<> struct QAtomicOpsSupport<2> { enum { IsSupported = 1 }; };
+template<> struct QAtomicOpsSupport<8> { enum { IsSupported = 1 }; };
+# 96 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/arch/qatomic_cxx11.h"
+template <typename X> struct QAtomicOps
+{
+    typedef std::atomic<X> Type;
+
+    template <typename T> static inline
+    T load(const std::atomic<T> &_q_value) noexcept
+    {
+        return _q_value.load(std::memory_order_relaxed);
+    }
+
+    template <typename T> static inline
+    T load(const volatile std::atomic<T> &_q_value) noexcept
+    {
+        return _q_value.load(std::memory_order_relaxed);
+    }
+
+    template <typename T> static inline
+    T loadAcquire(const std::atomic<T> &_q_value) noexcept
+    {
+        return _q_value.load(std::memory_order_acquire);
+    }
+
+    template <typename T> static inline
+    T loadAcquire(const volatile std::atomic<T> &_q_value) noexcept
+    {
+        return _q_value.load(std::memory_order_acquire);
+    }
+
+    template <typename T> static inline
+    void store(std::atomic<T> &_q_value, T newValue) noexcept
+    {
+        _q_value.store(newValue, std::memory_order_relaxed);
+    }
+
+    template <typename T> static inline
+    void storeRelease(std::atomic<T> &_q_value, T newValue) noexcept
+    {
+        _q_value.store(newValue, std::memory_order_release);
+    }
+
+    static inline constexpr bool isReferenceCountingNative() noexcept { return true; }
+    static inline constexpr bool isReferenceCountingWaitFree() noexcept { return false; }
+    template <typename T>
+    static inline bool ref(std::atomic<T> &_q_value)
+    {
+        return ++_q_value != 0;
+    }
+
+    template <typename T>
+    static inline bool deref(std::atomic<T> &_q_value) noexcept
+    {
+        return --_q_value != 0;
+    }
+
+    static inline constexpr bool isTestAndSetNative() noexcept { return false; }
+    static inline constexpr bool isTestAndSetWaitFree() noexcept { return false; }
+
+    template <typename T>
+    static bool testAndSetRelaxed(std::atomic<T> &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept
+    {
+        bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_relaxed);
+        if (currentValue)
+            *currentValue = expectedValue;
+        return tmp;
+    }
+
+    template <typename T>
+    static bool testAndSetAcquire(std::atomic<T> &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept
+    {
+        bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acquire);
+        if (currentValue)
+            *currentValue = expectedValue;
+        return tmp;
+    }
+
+    template <typename T>
+    static bool testAndSetRelease(std::atomic<T> &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept
+    {
+        bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_release);
+        if (currentValue)
+            *currentValue = expectedValue;
+        return tmp;
+    }
+
+    template <typename T>
+    static bool testAndSetOrdered(std::atomic<T> &_q_value, T expectedValue, T newValue, T *currentValue = nullptr) noexcept
+    {
+        bool tmp = _q_value.compare_exchange_strong(expectedValue, newValue, std::memory_order_acq_rel);
+        if (currentValue)
+            *currentValue = expectedValue;
+        return tmp;
+    }
+
+    static inline constexpr bool isFetchAndStoreNative() noexcept { return false; }
+    static inline constexpr bool isFetchAndStoreWaitFree() noexcept { return false; }
+
+    template <typename T>
+    static T fetchAndStoreRelaxed(std::atomic<T> &_q_value, T newValue) noexcept
+    {
+        return _q_value.exchange(newValue, std::memory_order_relaxed);
+    }
+
+    template <typename T>
+    static T fetchAndStoreAcquire(std::atomic<T> &_q_value, T newValue) noexcept
+    {
+        return _q_value.exchange(newValue, std::memory_order_acquire);
+    }
+
+    template <typename T>
+    static T fetchAndStoreRelease(std::atomic<T> &_q_value, T newValue) noexcept
+    {
+        return _q_value.exchange(newValue, std::memory_order_release);
+    }
+
+    template <typename T>
+    static T fetchAndStoreOrdered(std::atomic<T> &_q_value, T newValue) noexcept
+    {
+        return _q_value.exchange(newValue, std::memory_order_acq_rel);
+    }
+
+    static inline constexpr bool isFetchAndAddNative() noexcept { return false; }
+    static inline constexpr bool isFetchAndAddWaitFree() noexcept { return false; }
+
+    template <typename T> static inline
+    T fetchAndAddRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_add(valueToAdd, std::memory_order_relaxed);
+    }
+
+    template <typename T> static inline
+    T fetchAndAddAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_add(valueToAdd, std::memory_order_acquire);
+    }
+
+    template <typename T> static inline
+    T fetchAndAddRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_add(valueToAdd, std::memory_order_release);
+    }
+
+    template <typename T> static inline
+    T fetchAndAddOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_add(valueToAdd, std::memory_order_acq_rel);
+    }
+
+    template <typename T> static inline
+    T fetchAndSubRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_sub(valueToAdd, std::memory_order_relaxed);
+    }
+
+    template <typename T> static inline
+    T fetchAndSubAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_sub(valueToAdd, std::memory_order_acquire);
+    }
+
+    template <typename T> static inline
+    T fetchAndSubRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_sub(valueToAdd, std::memory_order_release);
+    }
+
+    template <typename T> static inline
+    T fetchAndSubOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_sub(valueToAdd, std::memory_order_acq_rel);
+    }
+
+    template <typename T> static inline
+    T fetchAndAndRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_and(valueToAdd, std::memory_order_relaxed);
+    }
+
+    template <typename T> static inline
+    T fetchAndAndAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_and(valueToAdd, std::memory_order_acquire);
+    }
+
+    template <typename T> static inline
+    T fetchAndAndRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_and(valueToAdd, std::memory_order_release);
+    }
+
+    template <typename T> static inline
+    T fetchAndAndOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_and(valueToAdd, std::memory_order_acq_rel);
+    }
+
+    template <typename T> static inline
+    T fetchAndOrRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_or(valueToAdd, std::memory_order_relaxed);
+    }
+
+    template <typename T> static inline
+    T fetchAndOrAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_or(valueToAdd, std::memory_order_acquire);
+    }
+
+    template <typename T> static inline
+    T fetchAndOrRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_or(valueToAdd, std::memory_order_release);
+    }
+
+    template <typename T> static inline
+    T fetchAndOrOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_or(valueToAdd, std::memory_order_acq_rel);
+    }
+
+    template <typename T> static inline
+    T fetchAndXorRelaxed(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_xor(valueToAdd, std::memory_order_relaxed);
+    }
+
+    template <typename T> static inline
+    T fetchAndXorAcquire(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_xor(valueToAdd, std::memory_order_acquire);
+    }
+
+    template <typename T> static inline
+    T fetchAndXorRelease(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_xor(valueToAdd, std::memory_order_release);
+    }
+
+    template <typename T> static inline
+    T fetchAndXorOrdered(std::atomic<T> &_q_value, typename QAtomicAdditiveType<T>::AdditiveT valueToAdd) noexcept
+    {
+        return _q_value.fetch_xor(valueToAdd, std::memory_order_acq_rel);
+    }
+};
+
+
+
+
+
+
+
+
+# 1 "../../include/QtCore/qatomic_cxx11.h" 2
+# 54 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qbasicatomic.h" 2
+# 64 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qbasicatomic.h"
+
+# 86 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qbasicatomic.h"
+template <typename T>
+class QBasicAtomicInteger
+{
+public:
+    typedef QAtomicOps<T> Ops;
+
+    static_assert(bool(QTypeInfo<T>::isIntegral), "template parameter is not an integral type");
+    static_assert(bool(QAtomicOpsSupport<sizeof(T)>::IsSupported), "template parameter is an integral of a size not supported on this platform");
+
+    typename Ops::Type _q_value;
+
+
+
+    T load() const noexcept { return Ops::load(_q_value); }
+    void store(T newValue) noexcept { Ops::store(_q_value, newValue); }
+
+    T loadAcquire() const noexcept { return Ops::loadAcquire(_q_value); }
+    void storeRelease(T newValue) noexcept { Ops::storeRelease(_q_value, newValue); }
+    operator T() const noexcept { return loadAcquire(); }
+    T operator=(T newValue) noexcept { storeRelease(newValue); return newValue; }
+
+    static constexpr bool isReferenceCountingNative() noexcept { return Ops::isReferenceCountingNative(); }
+    static constexpr bool isReferenceCountingWaitFree() noexcept { return Ops::isReferenceCountingWaitFree(); }
+
+    bool ref() noexcept { return Ops::ref(_q_value); }
+    bool deref() noexcept { return Ops::deref(_q_value); }
+
+    static constexpr bool isTestAndSetNative() noexcept { return Ops::isTestAndSetNative(); }
+    static constexpr bool isTestAndSetWaitFree() noexcept { return Ops::isTestAndSetWaitFree(); }
+
+    bool testAndSetRelaxed(T expectedValue, T newValue) noexcept
+    { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue); }
+    bool testAndSetAcquire(T expectedValue, T newValue) noexcept
+    { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue); }
+    bool testAndSetRelease(T expectedValue, T newValue) noexcept
+    { return Ops::testAndSetRelease(_q_value, expectedValue, newValue); }
+    bool testAndSetOrdered(T expectedValue, T newValue) noexcept
+    { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue); }
+
+    bool testAndSetRelaxed(T expectedValue, T newValue, T &currentValue) noexcept
+    { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue, &currentValue); }
+    bool testAndSetAcquire(T expectedValue, T newValue, T &currentValue) noexcept
+    { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue, &currentValue); }
+    bool testAndSetRelease(T expectedValue, T newValue, T &currentValue) noexcept
+    { return Ops::testAndSetRelease(_q_value, expectedValue, newValue, &currentValue); }
+    bool testAndSetOrdered(T expectedValue, T newValue, T &currentValue) noexcept
+    { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue, &currentValue); }
+
+    static constexpr bool isFetchAndStoreNative() noexcept { return Ops::isFetchAndStoreNative(); }
+    static constexpr bool isFetchAndStoreWaitFree() noexcept { return Ops::isFetchAndStoreWaitFree(); }
+
+    T fetchAndStoreRelaxed(T newValue) noexcept
+    { return Ops::fetchAndStoreRelaxed(_q_value, newValue); }
+    T fetchAndStoreAcquire(T newValue) noexcept
+    { return Ops::fetchAndStoreAcquire(_q_value, newValue); }
+    T fetchAndStoreRelease(T newValue) noexcept
+    { return Ops::fetchAndStoreRelease(_q_value, newValue); }
+    T fetchAndStoreOrdered(T newValue) noexcept
+    { return Ops::fetchAndStoreOrdered(_q_value, newValue); }
+
+    static constexpr bool isFetchAndAddNative() noexcept { return Ops::isFetchAndAddNative(); }
+    static constexpr bool isFetchAndAddWaitFree() noexcept { return Ops::isFetchAndAddWaitFree(); }
+
+    T fetchAndAddRelaxed(T valueToAdd) noexcept
+    { return Ops::fetchAndAddRelaxed(_q_value, valueToAdd); }
+    T fetchAndAddAcquire(T valueToAdd) noexcept
+    { return Ops::fetchAndAddAcquire(_q_value, valueToAdd); }
+    T fetchAndAddRelease(T valueToAdd) noexcept
+    { return Ops::fetchAndAddRelease(_q_value, valueToAdd); }
+    T fetchAndAddOrdered(T valueToAdd) noexcept
+    { return Ops::fetchAndAddOrdered(_q_value, valueToAdd); }
+
+    T fetchAndSubRelaxed(T valueToAdd) noexcept
+    { return Ops::fetchAndSubRelaxed(_q_value, valueToAdd); }
+    T fetchAndSubAcquire(T valueToAdd) noexcept
+    { return Ops::fetchAndSubAcquire(_q_value, valueToAdd); }
+    T fetchAndSubRelease(T valueToAdd) noexcept
+    { return Ops::fetchAndSubRelease(_q_value, valueToAdd); }
+    T fetchAndSubOrdered(T valueToAdd) noexcept
+    { return Ops::fetchAndSubOrdered(_q_value, valueToAdd); }
+
+    T fetchAndAndRelaxed(T valueToAdd) noexcept
+    { return Ops::fetchAndAndRelaxed(_q_value, valueToAdd); }
+    T fetchAndAndAcquire(T valueToAdd) noexcept
+    { return Ops::fetchAndAndAcquire(_q_value, valueToAdd); }
+    T fetchAndAndRelease(T valueToAdd) noexcept
+    { return Ops::fetchAndAndRelease(_q_value, valueToAdd); }
+    T fetchAndAndOrdered(T valueToAdd) noexcept
+    { return Ops::fetchAndAndOrdered(_q_value, valueToAdd); }
+
+    T fetchAndOrRelaxed(T valueToAdd) noexcept
+    { return Ops::fetchAndOrRelaxed(_q_value, valueToAdd); }
+    T fetchAndOrAcquire(T valueToAdd) noexcept
+    { return Ops::fetchAndOrAcquire(_q_value, valueToAdd); }
+    T fetchAndOrRelease(T valueToAdd) noexcept
+    { return Ops::fetchAndOrRelease(_q_value, valueToAdd); }
+    T fetchAndOrOrdered(T valueToAdd) noexcept
+    { return Ops::fetchAndOrOrdered(_q_value, valueToAdd); }
+
+    T fetchAndXorRelaxed(T valueToAdd) noexcept
+    { return Ops::fetchAndXorRelaxed(_q_value, valueToAdd); }
+    T fetchAndXorAcquire(T valueToAdd) noexcept
+    { return Ops::fetchAndXorAcquire(_q_value, valueToAdd); }
+    T fetchAndXorRelease(T valueToAdd) noexcept
+    { return Ops::fetchAndXorRelease(_q_value, valueToAdd); }
+    T fetchAndXorOrdered(T valueToAdd) noexcept
+    { return Ops::fetchAndXorOrdered(_q_value, valueToAdd); }
+
+    T operator++() noexcept
+    { return fetchAndAddOrdered(1) + 1; }
+    T operator++(int) noexcept
+    { return fetchAndAddOrdered(1); }
+    T operator--() noexcept
+    { return fetchAndSubOrdered(1) - 1; }
+    T operator--(int) noexcept
+    { return fetchAndSubOrdered(1); }
+
+    T operator+=(T v) noexcept
+    { return fetchAndAddOrdered(v) + v; }
+    T operator-=(T v) noexcept
+    { return fetchAndSubOrdered(v) - v; }
+    T operator&=(T v) noexcept
+    { return fetchAndAndOrdered(v) & v; }
+    T operator|=(T v) noexcept
+    { return fetchAndOrOrdered(v) | v; }
+    T operator^=(T v) noexcept
+    { return fetchAndXorOrdered(v) ^ v; }
+
+
+
+    QBasicAtomicInteger() = default;
+    constexpr QBasicAtomicInteger(T value) noexcept : _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 noexcept { return _q_value; }
+    void store(Type newValue) noexcept { _q_value = newValue; }
+    operator Type() const noexcept { return loadAcquire(); }
+    Type operator=(Type newValue) noexcept { storeRelease(newValue); return newValue; }
+
+
+    Type loadAcquire() const noexcept { return Ops::loadAcquire(_q_value); }
+    void storeRelease(Type newValue) noexcept { Ops::storeRelease(_q_value, newValue); }
+
+    static constexpr bool isTestAndSetNative() noexcept { return Ops::isTestAndSetNative(); }
+    static constexpr bool isTestAndSetWaitFree() noexcept { return Ops::isTestAndSetWaitFree(); }
+
+    bool testAndSetRelaxed(Type expectedValue, Type newValue) noexcept
+    { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue); }
+    bool testAndSetAcquire(Type expectedValue, Type newValue) noexcept
+    { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue); }
+    bool testAndSetRelease(Type expectedValue, Type newValue) noexcept
+    { return Ops::testAndSetRelease(_q_value, expectedValue, newValue); }
+    bool testAndSetOrdered(Type expectedValue, Type newValue) noexcept
+    { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue); }
+
+    bool testAndSetRelaxed(Type expectedValue, Type newValue, Type &currentValue) noexcept
+    { return Ops::testAndSetRelaxed(_q_value, expectedValue, newValue, &currentValue); }
+    bool testAndSetAcquire(Type expectedValue, Type newValue, Type &currentValue) noexcept
+    { return Ops::testAndSetAcquire(_q_value, expectedValue, newValue, &currentValue); }
+    bool testAndSetRelease(Type expectedValue, Type newValue, Type &currentValue) noexcept
+    { return Ops::testAndSetRelease(_q_value, expectedValue, newValue, &currentValue); }
+    bool testAndSetOrdered(Type expectedValue, Type newValue, Type &currentValue) noexcept
+    { return Ops::testAndSetOrdered(_q_value, expectedValue, newValue, &currentValue); }
+
+    static constexpr bool isFetchAndStoreNative() noexcept { return Ops::isFetchAndStoreNative(); }
+    static constexpr bool isFetchAndStoreWaitFree() noexcept { return Ops::isFetchAndStoreWaitFree(); }
+
+    Type fetchAndStoreRelaxed(Type newValue) noexcept
+    { return Ops::fetchAndStoreRelaxed(_q_value, newValue); }
+    Type fetchAndStoreAcquire(Type newValue) noexcept
+    { return Ops::fetchAndStoreAcquire(_q_value, newValue); }
+    Type fetchAndStoreRelease(Type newValue) noexcept
+    { return Ops::fetchAndStoreRelease(_q_value, newValue); }
+    Type fetchAndStoreOrdered(Type newValue) noexcept
+    { return Ops::fetchAndStoreOrdered(_q_value, newValue); }
+
+    static constexpr bool isFetchAndAddNative() noexcept { return Ops::isFetchAndAddNative(); }
+    static constexpr bool isFetchAndAddWaitFree() noexcept { return Ops::isFetchAndAddWaitFree(); }
+
+    Type fetchAndAddRelaxed(qptrdiff valueToAdd) noexcept
+    { return Ops::fetchAndAddRelaxed(_q_value, valueToAdd); }
+    Type fetchAndAddAcquire(qptrdiff valueToAdd) noexcept
+    { return Ops::fetchAndAddAcquire(_q_value, valueToAdd); }
+    Type fetchAndAddRelease(qptrdiff valueToAdd) noexcept
+    { return Ops::fetchAndAddRelease(_q_value, valueToAdd); }
+    Type fetchAndAddOrdered(qptrdiff valueToAdd) noexcept
+    { return Ops::fetchAndAddOrdered(_q_value, valueToAdd); }
+
+    Type fetchAndSubRelaxed(qptrdiff valueToAdd) noexcept
+    { return Ops::fetchAndSubRelaxed(_q_value, valueToAdd); }
+    Type fetchAndSubAcquire(qptrdiff valueToAdd) noexcept
+    { return Ops::fetchAndSubAcquire(_q_value, valueToAdd); }
+    Type fetchAndSubRelease(qptrdiff valueToAdd) noexcept
+    { return Ops::fetchAndSubRelease(_q_value, valueToAdd); }
+    Type fetchAndSubOrdered(qptrdiff valueToAdd) noexcept
+    { return Ops::fetchAndSubOrdered(_q_value, valueToAdd); }
+
+    Type operator++() noexcept
+    { return fetchAndAddOrdered(1) + 1; }
+    Type operator++(int) noexcept
+    { return fetchAndAddOrdered(1); }
+    Type operator--() noexcept
+    { return fetchAndSubOrdered(1) - 1; }
+    Type operator--(int) noexcept
+    { return fetchAndSubOrdered(1); }
+    Type operator+=(qptrdiff valueToAdd) noexcept
+    { return fetchAndAddOrdered(valueToAdd) + valueToAdd; }
+    Type operator-=(qptrdiff valueToSub) noexcept
+    { return fetchAndSubOrdered(valueToSub) - valueToSub; }
+
+
+    QBasicAtomicPointer() = default;
+    constexpr QBasicAtomicPointer(Type value) noexcept : _q_value(value) {}
+    QBasicAtomicPointer(const QBasicAtomicPointer &) = delete;
+    QBasicAtomicPointer &operator=(const QBasicAtomicPointer &) = delete;
+    QBasicAtomicPointer &operator=(const QBasicAtomicPointer &) volatile = delete;
+
+};
+
+
+
+
+
+
+# 1 "../../include/QtCore/qbasicatomic.h" 2
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+
+
+
+
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+#pragma GCC diagnostic push
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+
+
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+#pragma GCC diagnostic ignored "-Wextra"
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+
+
+
+template <typename T>
+class QAtomicInteger : public QBasicAtomicInteger<T>
+{
+public:
+
+
+    constexpr QAtomicInteger(T value = 0) noexcept : QBasicAtomicInteger<T>(value) {}
+
+
+
+
+
+
+
+    inline QAtomicInteger(const QAtomicInteger &other) noexcept
+
+        : QBasicAtomicInteger<T>()
+
+    {
+        this->storeRelease(other.loadAcquire());
+    }
+
+    inline QAtomicInteger &operator=(const QAtomicInteger &other) noexcept
+    {
+        this->storeRelease(other.loadAcquire());
+        return *this;
+    }
+# 151 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+};
+
+class QAtomicInt : public QAtomicInteger<int>
+{
+public:
+
+
+
+
+    constexpr
+
+    QAtomicInt(int value = 0) noexcept : QAtomicInteger<int>(value) {}
+};
+
+
+template <typename T>
+class QAtomicPointer : public QBasicAtomicPointer<T>
+{
+public:
+
+    constexpr QAtomicPointer(T *value = 0) noexcept : QBasicAtomicPointer<T>(value) {}
+
+
+
+
+
+
+    inline QAtomicPointer(const QAtomicPointer<T> &other) noexcept
+    {
+        this->storeRelease(other.loadAcquire());
+    }
+
+    inline QAtomicPointer<T> &operator=(const QAtomicPointer<T> &other) noexcept
+    {
+        this->storeRelease(other.loadAcquire());
+        return *this;
+    }
+# 219 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+};
+
+
+# 221 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+#pragma GCC diagnostic pop
+# 221 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+
+# 233 "../../include/QtCore/../../../../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;
+}
+# 252 "../../include/QtCore/../../../../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 "../../include/QtCore/qatomic.h" 2
+# 1141 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 1 "../../include/QtCore/qglobalstatic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobalstatic.h" 1
+# 40 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobalstatic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobalstatic.h" 2
+
+
+
+
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+# 1 "../../include/QtCore/qatomic.h" 2
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobalstatic.h" 2
+
+
+
+namespace QtGlobalStatic {
+enum GuardValues {
+    Destroyed = -2,
+    Initialized = -1,
+    Uninitialized = 0,
+    Initializing = 1
+};
+}
+# 127 "../../include/QtCore/../../../../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() <= QtGlobalStatic::Destroyed; }
+    bool exists() const { return guard.load() == QtGlobalStatic::Initialized; }
+    operator Type *() { if (isDestroyed()) return 0; return innerFunction(); }
+    Type *operator()() { if (isDestroyed()) return 0; return innerFunction(); }
+    Type *operator->()
+    {
+      do { } while ((false) && (!isDestroyed()));
+      return innerFunction();
+    }
+    Type &operator*()
+    {
+      do { } while ((false) && (!isDestroyed()));
+      return *innerFunction();
+    }
+};
+# 161 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobalstatic.h"
+
+# 1 "../../include/QtCore/qglobalstatic.h" 2
+# 1142 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 1 "../../include/QtCore/qnumeric.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qnumeric.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qnumeric.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qnumeric.h" 2
+
+
+
+
+__attribute__((visibility("default"))) bool qIsInf(double d);
+__attribute__((visibility("default"))) bool qIsNaN(double d);
+__attribute__((visibility("default"))) bool qIsFinite(double d);
+__attribute__((visibility("default"))) bool qIsInf(float f);
+__attribute__((visibility("default"))) bool qIsNaN(float f);
+__attribute__((visibility("default"))) bool qIsFinite(float f);
+__attribute__((visibility("default"))) double qSNaN();
+__attribute__((visibility("default"))) double qQNaN();
+__attribute__((visibility("default"))) double qInf();
+
+__attribute__((visibility("default"))) quint32 qFloatDistance(float a, float b);
+__attribute__((visibility("default"))) quint64 qFloatDistance(double a, double b);
+
+
+
+
+
+
+# 1 "../../include/QtCore/qnumeric.h" 2
+# 1143 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 1 "../../include/QtCore/qversiontagging.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qversiontagging.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qversiontagging.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qversiontagging.h" 2
+
+
+
+
+
+# 88 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qversiontagging.h"
+
+# 1 "../../include/QtCore/qversiontagging.h" 2
+# 1144 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qglobal.h" 2
+# 1 "../../include/QtCore/qglobal.h" 2
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonvalue.h" 2
+# 1 "../../include/QtCore/qstring.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h" 1
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+# 1 "../../include/QtCore/qchar.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qchar.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qchar.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qchar.h" 2
+
+
+
+
+class QString;
+
+struct QLatin1Char
+{
+public:
+    constexpr inline explicit QLatin1Char(char c) noexcept : ch(c) {}
+    constexpr inline char toLatin1() const noexcept { return ch; }
+    constexpr inline ushort unicode() const noexcept { 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,
+        SoftHyphen = 0x00ad,
+        ReplacementCharacter = 0xfffd,
+        ObjectReplacementCharacter = 0xfffc,
+        ByteOrderMark = 0xfeff,
+        ByteOrderSwapped = 0xfffe,
+        ParagraphSeparator = 0x2029,
+        LineSeparator = 0x2028,
+        LastValidCodePoint = 0x10ffff
+    };
+
+    constexpr QChar() noexcept : ucs(0) {}
+    constexpr QChar(ushort rc) noexcept : ucs(rc) {}
+    constexpr QChar(uchar c, uchar r) noexcept : ucs(ushort((r << 8) | c)) {}
+    constexpr QChar(short rc) noexcept : ucs(ushort(rc)) {}
+    constexpr QChar(uint rc) noexcept : ucs(ushort(rc & 0xffff)) {}
+    constexpr QChar(int rc) noexcept : ucs(ushort(rc & 0xffff)) {}
+    constexpr QChar(SpecialCharacter s) noexcept : ucs(ushort(s)) {}
+    constexpr QChar(QLatin1Char ch) noexcept : ucs(ch.unicode()) {}
+
+
+    __attribute__ ((__deprecated__)) constexpr explicit QChar(char c) noexcept : ucs(uchar(c)) { }
+
+    __attribute__ ((__deprecated__)) constexpr explicit QChar(uchar c) noexcept : 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 Script
+    {
+        Script_Unknown,
+        Script_Inherited,
+        Script_Common,
+
+        Script_Latin,
+        Script_Greek,
+        Script_Cyrillic,
+        Script_Armenian,
+        Script_Hebrew,
+        Script_Arabic,
+        Script_Syriac,
+        Script_Thaana,
+        Script_Devanagari,
+        Script_Bengali,
+        Script_Gurmukhi,
+        Script_Gujarati,
+        Script_Oriya,
+        Script_Tamil,
+        Script_Telugu,
+        Script_Kannada,
+        Script_Malayalam,
+        Script_Sinhala,
+        Script_Thai,
+        Script_Lao,
+        Script_Tibetan,
+        Script_Myanmar,
+        Script_Georgian,
+        Script_Hangul,
+        Script_Ethiopic,
+        Script_Cherokee,
+        Script_CanadianAboriginal,
+        Script_Ogham,
+        Script_Runic,
+        Script_Khmer,
+        Script_Mongolian,
+        Script_Hiragana,
+        Script_Katakana,
+        Script_Bopomofo,
+        Script_Han,
+        Script_Yi,
+        Script_OldItalic,
+        Script_Gothic,
+        Script_Deseret,
+        Script_Tagalog,
+        Script_Hanunoo,
+        Script_Buhid,
+        Script_Tagbanwa,
+        Script_Coptic,
+
+
+        Script_Limbu,
+        Script_TaiLe,
+        Script_LinearB,
+        Script_Ugaritic,
+        Script_Shavian,
+        Script_Osmanya,
+        Script_Cypriot,
+        Script_Braille,
+
+
+        Script_Buginese,
+        Script_NewTaiLue,
+        Script_Glagolitic,
+        Script_Tifinagh,
+        Script_SylotiNagri,
+        Script_OldPersian,
+        Script_Kharoshthi,
+
+
+        Script_Balinese,
+        Script_Cuneiform,
+        Script_Phoenician,
+        Script_PhagsPa,
+        Script_Nko,
+
+
+        Script_Sundanese,
+        Script_Lepcha,
+        Script_OlChiki,
+        Script_Vai,
+        Script_Saurashtra,
+        Script_KayahLi,
+        Script_Rejang,
+        Script_Lycian,
+        Script_Carian,
+        Script_Lydian,
+        Script_Cham,
+
+
+        Script_TaiTham,
+        Script_TaiViet,
+        Script_Avestan,
+        Script_EgyptianHieroglyphs,
+        Script_Samaritan,
+        Script_Lisu,
+        Script_Bamum,
+        Script_Javanese,
+        Script_MeeteiMayek,
+        Script_ImperialAramaic,
+        Script_OldSouthArabian,
+        Script_InscriptionalParthian,
+        Script_InscriptionalPahlavi,
+        Script_OldTurkic,
+        Script_Kaithi,
+
+
+        Script_Batak,
+        Script_Brahmi,
+        Script_Mandaic,
+
+
+        Script_Chakma,
+        Script_MeroiticCursive,
+        Script_MeroiticHieroglyphs,
+        Script_Miao,
+        Script_Sharada,
+        Script_SoraSompeng,
+        Script_Takri,
+
+
+        Script_CaucasianAlbanian,
+        Script_BassaVah,
+        Script_Duployan,
+        Script_Elbasan,
+        Script_Grantha,
+        Script_PahawhHmong,
+        Script_Khojki,
+        Script_LinearA,
+        Script_Mahajani,
+        Script_Manichaean,
+        Script_MendeKikakui,
+        Script_Modi,
+        Script_Mro,
+        Script_OldNorthArabian,
+        Script_Nabataean,
+        Script_Palmyrene,
+        Script_PauCinHau,
+        Script_OldPermic,
+        Script_PsalterPahlavi,
+        Script_Siddham,
+        Script_Khudawadi,
+        Script_Tirhuta,
+        Script_WarangCiti,
+
+
+        Script_Ahom,
+        Script_AnatolianHieroglyphs,
+        Script_Hatran,
+        Script_Multani,
+        Script_OldHungarian,
+        Script_SignWriting,
+
+        ScriptCount
+    };
+
+    enum Direction
+    {
+        DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
+        DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN,
+        DirLRI, DirRLI, DirFSI, DirPDI
+    };
+
+    enum Decomposition
+    {
+        NoDecomposition,
+        Canonical,
+        Font,
+        NoBreak,
+        Initial,
+        Medial,
+        Final,
+        Isolated,
+        Circle,
+        Super,
+        Sub,
+        Vertical,
+        Wide,
+        Narrow,
+        Small,
+        Square,
+        Compat,
+        Fraction
+    };
+
+    enum JoiningType {
+        Joining_None,
+        Joining_Causing,
+        Joining_Dual,
+        Joining_Right,
+        Joining_Left,
+        Joining_Transparent
+    };
+
+
+    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,
+        Unicode_5_1,
+        Unicode_5_2,
+        Unicode_6_0,
+        Unicode_6_1,
+        Unicode_6_2,
+        Unicode_6_3,
+        Unicode_7_0,
+        Unicode_8_0
+    };
+
+
+    inline Category category() const noexcept { return QChar::category(ucs); }
+    inline Direction direction() const noexcept { return QChar::direction(ucs); }
+    inline JoiningType joiningType() const noexcept { return QChar::joiningType(ucs); }
+
+    __attribute__ ((__deprecated__)) inline Joining joining() const noexcept
+    {
+        switch (QChar::joiningType(ucs)) {
+        case QChar::Joining_Causing: return QChar::Center;
+        case QChar::Joining_Dual: return QChar::Dual;
+        case QChar::Joining_Right: return QChar::Right;
+        case QChar::Joining_None:
+        case QChar::Joining_Left:
+        case QChar::Joining_Transparent:
+        default: return QChar::OtherJoining;
+        }
+    }
+
+    inline unsigned char combiningClass() const noexcept { return QChar::combiningClass(ucs); }
+
+    inline QChar mirroredChar() const noexcept { return QChar::mirroredChar(ucs); }
+    inline bool hasMirrored() const noexcept { return QChar::hasMirrored(ucs); }
+
+    QString decomposition() const;
+    inline Decomposition decompositionTag() const noexcept { return QChar::decompositionTag(ucs); }
+
+    inline int digitValue() const noexcept { return QChar::digitValue(ucs); }
+    inline QChar toLower() const noexcept { return QChar::toLower(ucs); }
+    inline QChar toUpper() const noexcept { return QChar::toUpper(ucs); }
+    inline QChar toTitleCase() const noexcept { return QChar::toTitleCase(ucs); }
+    inline QChar toCaseFolded() const noexcept { return QChar::toCaseFolded(ucs); }
+
+    inline Script script() const noexcept { return QChar::script(ucs); }
+
+    inline UnicodeVersion unicodeVersion() const noexcept { return QChar::unicodeVersion(ucs); }
+
+
+
+
+    constexpr inline char toLatin1() const noexcept { return ucs > 0xff ? '\0' : char(ucs); }
+    constexpr inline ushort unicode() const noexcept { return ucs; }
+    constexpr inline ushort &unicode() noexcept { return ucs; }
+
+
+
+
+
+    static constexpr inline QChar fromLatin1(char c) noexcept { return QChar(ushort(uchar(c))); }
+
+    constexpr inline bool isNull() const noexcept { return ucs == 0; }
+
+    inline bool isPrint() const noexcept { return QChar::isPrint(ucs); }
+    constexpr inline bool isSpace() const noexcept { return QChar::isSpace(ucs); }
+    inline bool isMark() const noexcept { return QChar::isMark(ucs); }
+    inline bool isPunct() const noexcept { return QChar::isPunct(ucs); }
+    inline bool isSymbol() const noexcept { return QChar::isSymbol(ucs); }
+    constexpr inline bool isLetter() const noexcept { return QChar::isLetter(ucs); }
+    constexpr inline bool isNumber() const noexcept { return QChar::isNumber(ucs); }
+    constexpr inline bool isLetterOrNumber() const noexcept { return QChar::isLetterOrNumber(ucs); }
+    constexpr inline bool isDigit() const noexcept { return QChar::isDigit(ucs); }
+    constexpr inline bool isLower() const noexcept { return QChar::isLower(ucs); }
+    constexpr inline bool isUpper() const noexcept { return QChar::isUpper(ucs); }
+    constexpr inline bool isTitleCase() const noexcept { return QChar::isTitleCase(ucs); }
+
+    constexpr inline bool isNonCharacter() const noexcept { return QChar::isNonCharacter(ucs); }
+    constexpr inline bool isHighSurrogate() const noexcept { return QChar::isHighSurrogate(ucs); }
+    constexpr inline bool isLowSurrogate() const noexcept { return QChar::isLowSurrogate(ucs); }
+    constexpr inline bool isSurrogate() const noexcept { return QChar::isSurrogate(ucs); }
+
+    constexpr inline uchar cell() const noexcept { return uchar(ucs & 0xff); }
+    constexpr inline uchar row() const noexcept { return uchar((ucs>>8)&0xff); }
+    constexpr inline void setCell(uchar acell) noexcept { ucs = ushort((ucs & 0xff00) + acell); }
+    constexpr inline void setRow(uchar arow) noexcept { ucs = ushort((ushort(arow)<<8) + (ucs&0xff)); }
+
+    static constexpr inline bool isNonCharacter(uint ucs4) noexcept
+    {
+        return ucs4 >= 0xfdd0 && (ucs4 <= 0xfdef || (ucs4 & 0xfffe) == 0xfffe);
+    }
+    static constexpr inline bool isHighSurrogate(uint ucs4) noexcept
+    {
+        return ((ucs4 & 0xfffffc00) == 0xd800);
+    }
+    static constexpr inline bool isLowSurrogate(uint ucs4) noexcept
+    {
+        return ((ucs4 & 0xfffffc00) == 0xdc00);
+    }
+    static constexpr inline bool isSurrogate(uint ucs4) noexcept
+    {
+        return (ucs4 - 0xd800u < 2048u);
+    }
+    static constexpr inline bool requiresSurrogates(uint ucs4) noexcept
+    {
+        return (ucs4 >= 0x10000);
+    }
+    static constexpr inline uint surrogateToUcs4(ushort high, ushort low) noexcept
+    {
+        return (uint(high)<<10) + low - 0x35fdc00;
+    }
+    static constexpr inline uint surrogateToUcs4(QChar high, QChar low) noexcept
+    {
+        return surrogateToUcs4(high.ucs, low.ucs);
+    }
+    static constexpr inline ushort highSurrogate(uint ucs4) noexcept
+    {
+        return ushort((ucs4>>10) + 0xd7c0);
+    }
+    static constexpr inline ushort lowSurrogate(uint ucs4) noexcept
+    {
+        return ushort(ucs4%0x400 + 0xdc00);
+    }
+
+    static Category category(uint ucs4) noexcept __attribute__((const));
+    static Direction direction(uint ucs4) noexcept __attribute__((const));
+    static JoiningType joiningType(uint ucs4) noexcept __attribute__((const));
+
+    __attribute__ ((__deprecated__)) static Joining joining(uint ucs4) noexcept __attribute__((const));
+
+    static unsigned char combiningClass(uint ucs4) noexcept __attribute__((const));
+
+    static uint mirroredChar(uint ucs4) noexcept __attribute__((const));
+    static bool hasMirrored(uint ucs4) noexcept __attribute__((const));
+
+    static QString decomposition(uint ucs4);
+    static Decomposition decompositionTag(uint ucs4) noexcept __attribute__((const));
+
+    static int digitValue(uint ucs4) noexcept __attribute__((const));
+    static uint toLower(uint ucs4) noexcept __attribute__((const));
+    static uint toUpper(uint ucs4) noexcept __attribute__((const));
+    static uint toTitleCase(uint ucs4) noexcept __attribute__((const));
+    static uint toCaseFolded(uint ucs4) noexcept __attribute__((const));
+
+    static Script script(uint ucs4) noexcept __attribute__((const));
+
+    static UnicodeVersion unicodeVersion(uint ucs4) noexcept __attribute__((const));
+
+    static UnicodeVersion currentUnicodeVersion() noexcept __attribute__((const));
+
+    static bool isPrint(uint ucs4) noexcept __attribute__((const));
+    static constexpr inline bool isSpace(uint ucs4) noexcept __attribute__((const))
+    {
+
+        return ucs4 == 0x20 || (ucs4 <= 0x0d && ucs4 >= 0x09)
+                || (ucs4 > 127 && (ucs4 == 0x85 || ucs4 == 0xa0 || QChar::isSpace_helper(ucs4)));
+    }
+    static bool isMark(uint ucs4) noexcept __attribute__((const));
+    static bool isPunct(uint ucs4) noexcept __attribute__((const));
+    static bool isSymbol(uint ucs4) noexcept __attribute__((const));
+    static constexpr inline bool isLetter(uint ucs4) noexcept __attribute__((const))
+    {
+        return (ucs4 >= 'A' && ucs4 <= 'z' && (ucs4 >= 'a' || ucs4 <= 'Z'))
+                || (ucs4 > 127 && QChar::isLetter_helper(ucs4));
+    }
+    static constexpr inline bool isNumber(uint ucs4) noexcept __attribute__((const))
+    { return (ucs4 <= '9' && ucs4 >= '0') || (ucs4 > 127 && QChar::isNumber_helper(ucs4)); }
+    static constexpr inline bool isLetterOrNumber(uint ucs4) noexcept __attribute__((const))
+    {
+        return (ucs4 >= 'A' && ucs4 <= 'z' && (ucs4 >= 'a' || ucs4 <= 'Z'))
+                || (ucs4 >= '0' && ucs4 <= '9')
+                || (ucs4 > 127 && QChar::isLetterOrNumber_helper(ucs4));
+    }
+    static constexpr inline bool isDigit(uint ucs4) noexcept __attribute__((const))
+    { return (ucs4 <= '9' && ucs4 >= '0') || (ucs4 > 127 && QChar::category(ucs4) == Number_DecimalDigit); }
+    static constexpr inline bool isLower(uint ucs4) noexcept __attribute__((const))
+    { return (ucs4 <= 'z' && ucs4 >= 'a') || (ucs4 > 127 && QChar::category(ucs4) == Letter_Lowercase); }
+    static constexpr inline bool isUpper(uint ucs4) noexcept __attribute__((const))
+    { return (ucs4 <= 'Z' && ucs4 >= 'A') || (ucs4 > 127 && QChar::category(ucs4) == Letter_Uppercase); }
+    static constexpr inline bool isTitleCase(uint ucs4) noexcept __attribute__((const))
+    { return ucs4 > 127 && QChar::category(ucs4) == Letter_Titlecase; }
+
+private:
+    static bool isSpace_helper(uint ucs4) noexcept __attribute__((const));
+    static bool isLetter_helper(uint ucs4) noexcept __attribute__((const));
+    static bool isNumber_helper(uint ucs4) noexcept __attribute__((const));
+    static bool isLetterOrNumber_helper(uint ucs4) noexcept __attribute__((const));
+
+
+
+
+
+
+    friend constexpr bool operator==(QChar, QChar) noexcept;
+    friend constexpr bool operator< (QChar, QChar) noexcept;
+    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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QChar)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QChar >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QChar) }; static inline const char *name() { return "QChar"; } };
+
+constexpr inline bool operator==(QChar c1, QChar c2) noexcept { return c1.ucs == c2.ucs; }
+constexpr inline bool operator< (QChar c1, QChar c2) noexcept { return c1.ucs < c2.ucs; }
+
+constexpr inline bool operator!=(QChar c1, QChar c2) noexcept { return !operator==(c1, c2); }
+constexpr inline bool operator>=(QChar c1, QChar c2) noexcept { return !operator< (c1, c2); }
+constexpr inline bool operator> (QChar c1, QChar c2) noexcept { return operator< (c2, c1); }
+constexpr inline bool operator<=(QChar c1, QChar c2) noexcept { return !operator< (c2, c1); }
+
+
+__attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, QChar);
+__attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QChar &);
+
+
+
+# 1 "../../include/QtCore/qchar.h" 2
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h" 2
+# 1 "../../include/QtCore/qbytearray.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h"
+# 1 "../../include/QtCore/qrefcount.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qrefcount.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qrefcount.h"
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+# 1 "../../include/QtCore/qatomic.h" 2
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qrefcount.h" 2
+
+
+
+
+namespace QtPrivate
+{
+
+class RefCount
+{
+public:
+    inline bool ref() noexcept {
+        int count = atomic.load();
+
+        if (count == 0)
+            return false;
+
+        if (count != -1)
+            atomic.ref();
+        return true;
+    }
+
+    inline bool deref() noexcept {
+        int count = atomic.load();
+
+        if (count == 0)
+            return false;
+
+        if (count == -1)
+            return true;
+        return atomic.deref();
+    }
+
+
+    bool setSharable(bool sharable) noexcept
+    {
+        do { } while ((false) && (!isShared()));
+        if (sharable)
+            return atomic.testAndSetRelaxed(0, 1);
+        else
+            return atomic.testAndSetRelaxed(1, 0);
+    }
+
+    bool isSharable() const noexcept
+    {
+
+        return atomic.load() != 0;
+    }
+
+
+    bool isStatic() const noexcept
+    {
+
+        return atomic.load() == -1;
+    }
+
+    bool isShared() const noexcept
+    {
+        int count = atomic.load();
+        return (count != 1) && (count != 0);
+    }
+
+    void initializeOwned() noexcept { atomic.store(1); }
+    void initializeUnsharable() noexcept { atomic.store(0); }
+
+    QBasicAtomicInt atomic;
+};
+
+}
+
+
+
+
+# 1 "../../include/QtCore/qrefcount.h" 2
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h" 2
+# 1 "../../include/QtCore/qnamespace.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qnamespace.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qnamespace.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qnamespace.h" 2
+
+
+
+
+
+
+
+
+struct QMetaObject;
+const QMetaObject *qt_getQtMetaObject() noexcept;
+# 64 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qnamespace.h"
+namespace
+
+
+
+Qt {
+
+
+
+
+
+
+    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 TabFocusBehavior {
+        NoTabFocus = 0x00,
+        TabFocusTextControls = 0x01,
+        TabFocusListControls = 0x02,
+        TabFocusAllControls = 0xff
+    };
+
+    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,
+        AlignBaseline = 0x0100,
+
+
+
+
+        AlignVertical_Mask = AlignTop | AlignBottom | AlignVCenter | AlignBaseline,
+
+        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 WhiteSpaceMode {
+        WhiteSpaceNormal,
+        WhiteSpacePre,
+        WhiteSpaceNoWrap,
+        WhiteSpaceModeUndefined = -1
+    };
+
+    enum HitTestAccuracy { ExactHit, FuzzyHit };
+
+    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,
+        ForeignWindow = 0x00000020 | Window,
+        CoverWindow = 0x00000040 | Window,
+
+        WindowType_Mask = 0x000000ff,
+        MSWindowsFixedSizeDialogHint = 0x00000100,
+        MSWindowsOwnDC = 0x00000200,
+        BypassWindowManagerHint = 0x00000400,
+        X11BypassWindowManagerHint = BypassWindowManagerHint,
+        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,
+        MaximizeUsingFullscreenGeometryHint = 0x00400000,
+
+        CustomizeWindowHint = 0x02000000,
+        WindowStaysOnBottomHint = 0x04000000,
+        WindowCloseButtonHint = 0x08000000,
+        MacWindowToolBarButtonHint = 0x10000000,
+        BypassGraphicsProxyWidget = 0x20000000,
+        NoDropShadowWindowHint = 0x40000000,
+        WindowFullscreenButtonHint = 0x80000000,
+
+
+
+        WindowOkButtonHint = 0x00080000,
+        WindowCancelButtonHint = 0x00100000
+    };
+
+    typedef QFlags<WindowType> WindowFlags;
+
+    enum WindowState {
+        WindowNoState = 0x00000000,
+        WindowMinimized = 0x00000001,
+        WindowMaximized = 0x00000002,
+        WindowFullScreen = 0x00000004,
+        WindowActive = 0x00000008
+    };
+
+    typedef QFlags<WindowState> WindowStates;
+
+    enum ApplicationState {
+        ApplicationSuspended = 0x00000000,
+        ApplicationHidden = 0x00000001,
+        ApplicationInactive = 0x00000002,
+        ApplicationActive = 0x00000004
+    };
+
+    typedef QFlags<ApplicationState> ApplicationStates;
+
+    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_X11DoNotAcceptFocus = 126,
+        WA_MacNoShadow = 127,
+
+        WA_AlwaysStackOnTop = 128,
+
+
+        WA_AttributeCount
+    };
+
+    enum ApplicationAttribute
+    {
+        AA_ImmediateWidgetCreation = 0,
+        AA_MSWindowsUseDirect3DByDefault = 1,
+        AA_DontShowIconsInMenus = 2,
+        AA_NativeWindows = 3,
+        AA_DontCreateNativeWidgetSiblings = 4,
+        AA_PluginApplication = 5,
+        AA_MacPluginApplication = AA_PluginApplication,
+        AA_DontUseNativeMenuBar = 6,
+        AA_MacDontSwapCtrlAndMeta = 7,
+        AA_Use96Dpi = 8,
+        AA_X11InitThreads = 10,
+        AA_SynthesizeTouchForUnhandledMouseEvents = 11,
+        AA_SynthesizeMouseForUnhandledTouchEvents = 12,
+        AA_UseHighDpiPixmaps = 13,
+        AA_ForceRasterWidgets = 14,
+        AA_UseDesktopOpenGL = 15,
+        AA_UseOpenGLES = 16,
+        AA_UseSoftwareOpenGL = 17,
+        AA_ShareOpenGLContexts = 18,
+        AA_SetPalette = 19,
+        AA_EnableHighDpiScaling = 20,
+        AA_DisableHighDpiScaling = 21,
+        AA_UseStyleSheetPropagationInWidgetStyles = 22,
+        AA_DontUseNativeDialogs = 23,
+        AA_SynthesizeMouseForUnhandledTabletEvents = 24,
+
+
+        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,
+# 806 "../../include/QtCore/../../../../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_MicMute = 0x01000113,
+
+        Key_Red = 0x01000114,
+        Key_Green = 0x01000115,
+        Key_Yellow = 0x01000116,
+        Key_Blue = 0x01000117,
+
+        Key_ChannelUp = 0x01000118,
+        Key_ChannelDown = 0x01000119,
+
+        Key_Guide = 0x0100011a,
+        Key_Info = 0x0100011b,
+        Key_Settings = 0x0100011c,
+
+        Key_MicVolumeUp = 0x0100011d,
+        Key_MicVolumeDown = 0x0100011e,
+
+        Key_New = 0x01000120,
+        Key_Open = 0x01000121,
+        Key_Find = 0x01000122,
+        Key_Undo = 0x01000123,
+        Key_Redo = 0x01000124,
+
+        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_Exit = 0x0102000a,
+
+
+        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,
+        RFC2822Date
+    };
+
+    enum TimeSpec {
+        LocalTime,
+        UTC,
+        OffsetFromUTC,
+        TimeZone
+    };
+
+    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 Edge {
+        TopEdge = 0x00001,
+        LeftEdge = 0x00002,
+        RightEdge = 0x00004,
+        BottomEdge = 0x00008
+    };
+
+    typedef QFlags<Edge> Edges;
+
+    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 ItemSelectionOperation {
+        ReplaceSelection,
+        AddToSelection
+    };
+
+    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,
+
+        ImAbsolutePosition = 0x400,
+        ImTextBeforeCursor = 0x800,
+        ImTextAfterCursor = 0x1000,
+        ImEnterKeyType = 0x2000,
+        ImAnchorRectangle = 0x4000,
+
+        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,
+
+        ImhMultiLine = 0x400,
+
+        ImhDigitsOnly = 0x10000,
+        ImhFormattedNumbersOnly = 0x20000,
+        ImhUppercaseOnly = 0x40000,
+        ImhLowercaseOnly = 0x80000,
+        ImhDialableCharactersOnly = 0x100000,
+        ImhEmailCharactersOnly = 0x200000,
+        ImhUrlCharactersOnly = 0x400000,
+        ImhLatinOnly = 0x800000,
+
+        ImhExclusiveInputMask = 0xffff0000
+    };
+    typedef QFlags<InputMethodHint> InputMethodHints;
+
+    enum EnterKeyType {
+        EnterKeyDefault,
+        EnterKeyReturn,
+        EnterKeyDone,
+        EnterKeyGo,
+        EnterKeySend,
+        EnterKeySearch,
+        EnterKeyNext,
+        EnterKeyPrevious
+    };
+
+    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,
+        ItemIsAutoTristate = 64,
+
+        ItemIsTristate = ItemIsAutoTristate,
+
+        ItemNeverHasChildren = 128,
+        ItemIsUserTristate = 256
+    };
+    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;
+
+
+
+
+    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 class Initialization {
+        Uninitialized
+    };
+    static constexpr __attribute__((__unused__)) Initialization Uninitialized = 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 NativeGestureType
+    {
+        BeginNativeGesture,
+        EndNativeGesture,
+        PanNativeGesture,
+        ZoomNativeGesture,
+        SmartZoomNativeGesture,
+        RotateNativeGesture,
+        SwipeNativeGesture
+    };
+
+
+
+    enum NavigationMode
+    {
+        NavigationModeNone,
+        NavigationModeKeypadTabOrder,
+        NavigationModeKeypadDirectional,
+        NavigationModeCursorAuto,
+        NavigationModeCursorForceVisible
+    };
+
+    enum CursorMoveStyle {
+        LogicalMoveStyle,
+        VisualMoveStyle
+    };
+
+    enum TimerType {
+        PreciseTimer,
+        CoarseTimer,
+        VeryCoarseTimer
+    };
+
+    enum ScrollPhase {
+        NoScrollPhase = 0,
+        ScrollBegin,
+        ScrollUpdate,
+        ScrollEnd
+    };
+
+    enum MouseEventSource {
+        MouseEventNotSynthesized,
+        MouseEventSynthesizedBySystem,
+        MouseEventSynthesizedByQt,
+        MouseEventSynthesizedByApplication
+    };
+
+    enum MouseEventFlag {
+        MouseEventCreatedDoubleClick = 0x01,
+        MouseEventFlagMask = 0xFF
+    };
+    typedef QFlags<MouseEventFlag> MouseEventFlags;
+
+
+
+    inline const QMetaObject *qt_getEnumMetaObject(ScrollBarPolicy) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ScrollBarPolicy) noexcept { return "ScrollBarPolicy"; }
+    inline const QMetaObject *qt_getEnumMetaObject(FocusPolicy) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(FocusPolicy) noexcept { return "FocusPolicy"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ContextMenuPolicy) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ContextMenuPolicy) noexcept { return "ContextMenuPolicy"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ArrowType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ArrowType) noexcept { return "ArrowType"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ToolButtonStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ToolButtonStyle) noexcept { return "ToolButtonStyle"; }
+    inline const QMetaObject *qt_getEnumMetaObject(PenStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(PenStyle) noexcept { return "PenStyle"; }
+    inline const QMetaObject *qt_getEnumMetaObject(PenCapStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(PenCapStyle) noexcept { return "PenCapStyle"; }
+    inline const QMetaObject *qt_getEnumMetaObject(PenJoinStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(PenJoinStyle) noexcept { return "PenJoinStyle"; }
+    inline const QMetaObject *qt_getEnumMetaObject(BrushStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(BrushStyle) noexcept { return "BrushStyle"; }
+    inline const QMetaObject *qt_getEnumMetaObject(FillRule) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(FillRule) noexcept { return "FillRule"; }
+    inline const QMetaObject *qt_getEnumMetaObject(MaskMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MaskMode) noexcept { return "MaskMode"; }
+    inline const QMetaObject *qt_getEnumMetaObject(BGMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(BGMode) noexcept { return "BGMode"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ClipOperation) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ClipOperation) noexcept { return "ClipOperation"; }
+    inline const QMetaObject *qt_getEnumMetaObject(SizeMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(SizeMode) noexcept { return "SizeMode"; }
+    inline const QMetaObject *qt_getEnumMetaObject(Axis) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Axis) noexcept { return "Axis"; }
+    inline const QMetaObject *qt_getEnumMetaObject(Corner) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Corner) noexcept { return "Corner"; }
+    inline const QMetaObject *qt_getEnumMetaObject(Edge) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Edge) noexcept { return "Edge"; }
+    inline const QMetaObject *qt_getEnumMetaObject(LayoutDirection) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(LayoutDirection) noexcept { return "LayoutDirection"; }
+    inline const QMetaObject *qt_getEnumMetaObject(SizeHint) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(SizeHint) noexcept { return "SizeHint"; }
+    inline const QMetaObject *qt_getEnumMetaObject(Orientation) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Orientation) noexcept { return "Orientation"; }
+    inline const QMetaObject *qt_getEnumMetaObject(DropAction) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DropAction) noexcept { return "DropAction"; }
+    inline const QMetaObject *qt_getEnumMetaObject(Alignment) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Alignment) noexcept { return "Alignment"; }
+    inline const QMetaObject *qt_getEnumMetaObject(Orientations) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Orientations) noexcept { return "Orientations"; }
+    inline const QMetaObject *qt_getEnumMetaObject(DropActions) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DropActions) noexcept { return "DropActions"; }
+    inline const QMetaObject *qt_getEnumMetaObject(Edges) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Edges) noexcept { return "Edges"; }
+    inline const QMetaObject *qt_getEnumMetaObject(DockWidgetAreas) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DockWidgetAreas) noexcept { return "DockWidgetAreas"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ToolBarAreas) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ToolBarAreas) noexcept { return "ToolBarAreas"; }
+    inline const QMetaObject *qt_getEnumMetaObject(DockWidgetArea) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DockWidgetArea) noexcept { return "DockWidgetArea"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ToolBarArea) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ToolBarArea) noexcept { return "ToolBarArea"; }
+    inline const QMetaObject *qt_getEnumMetaObject(TextFormat) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TextFormat) noexcept { return "TextFormat"; }
+    inline const QMetaObject *qt_getEnumMetaObject(TextElideMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TextElideMode) noexcept { return "TextElideMode"; }
+    inline const QMetaObject *qt_getEnumMetaObject(DateFormat) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DateFormat) noexcept { return "DateFormat"; }
+    inline const QMetaObject *qt_getEnumMetaObject(TimeSpec) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TimeSpec) noexcept { return "TimeSpec"; }
+    inline const QMetaObject *qt_getEnumMetaObject(DayOfWeek) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(DayOfWeek) noexcept { return "DayOfWeek"; }
+    inline const QMetaObject *qt_getEnumMetaObject(CursorShape) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(CursorShape) noexcept { return "CursorShape"; }
+    inline const QMetaObject *qt_getEnumMetaObject(GlobalColor) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(GlobalColor) noexcept { return "GlobalColor"; }
+    inline const QMetaObject *qt_getEnumMetaObject(AspectRatioMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(AspectRatioMode) noexcept { return "AspectRatioMode"; }
+    inline const QMetaObject *qt_getEnumMetaObject(TransformationMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TransformationMode) noexcept { return "TransformationMode"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ImageConversionFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ImageConversionFlags) noexcept { return "ImageConversionFlags"; }
+    inline const QMetaObject *qt_getEnumMetaObject(Key) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(Key) noexcept { return "Key"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ShortcutContext) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ShortcutContext) noexcept { return "ShortcutContext"; }
+    inline const QMetaObject *qt_getEnumMetaObject(TextInteractionFlag) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TextInteractionFlag) noexcept { return "TextInteractionFlag"; }
+    inline const QMetaObject *qt_getEnumMetaObject(TextInteractionFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TextInteractionFlags) noexcept { return "TextInteractionFlags"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ItemSelectionMode) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ItemSelectionMode) noexcept { return "ItemSelectionMode"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ItemSelectionOperation) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ItemSelectionOperation) noexcept { return "ItemSelectionOperation"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ItemFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ItemFlags) noexcept { return "ItemFlags"; }
+    inline const QMetaObject *qt_getEnumMetaObject(CheckState) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(CheckState) noexcept { return "CheckState"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ItemDataRole) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ItemDataRole) noexcept { return "ItemDataRole"; }
+    inline const QMetaObject *qt_getEnumMetaObject(SortOrder) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(SortOrder) noexcept { return "SortOrder"; }
+    inline const QMetaObject *qt_getEnumMetaObject(CaseSensitivity) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(CaseSensitivity) noexcept { return "CaseSensitivity"; }
+    inline const QMetaObject *qt_getEnumMetaObject(MatchFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MatchFlags) noexcept { return "MatchFlags"; }
+    inline const QMetaObject *qt_getEnumMetaObject(KeyboardModifiers) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(KeyboardModifiers) noexcept { return "KeyboardModifiers"; }
+    inline const QMetaObject *qt_getEnumMetaObject(MouseButtons) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MouseButtons) noexcept { return "MouseButtons"; }
+    inline const QMetaObject *qt_getEnumMetaObject(WindowType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowType) noexcept { return "WindowType"; }
+    inline const QMetaObject *qt_getEnumMetaObject(WindowState) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowState) noexcept { return "WindowState"; }
+    inline const QMetaObject *qt_getEnumMetaObject(WindowModality) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowModality) noexcept { return "WindowModality"; }
+    inline const QMetaObject *qt_getEnumMetaObject(WidgetAttribute) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WidgetAttribute) noexcept { return "WidgetAttribute"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ApplicationAttribute) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ApplicationAttribute) noexcept { return "ApplicationAttribute"; }
+    inline const QMetaObject *qt_getEnumMetaObject(WindowFlags) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowFlags) noexcept { return "WindowFlags"; }
+    inline const QMetaObject *qt_getEnumMetaObject(WindowStates) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(WindowStates) noexcept { return "WindowStates"; }
+    inline const QMetaObject *qt_getEnumMetaObject(FocusReason) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(FocusReason) noexcept { return "FocusReason"; }
+    inline const QMetaObject *qt_getEnumMetaObject(InputMethodHint) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(InputMethodHint) noexcept { return "InputMethodHint"; }
+    inline const QMetaObject *qt_getEnumMetaObject(InputMethodQuery) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(InputMethodQuery) noexcept { return "InputMethodQuery"; }
+    inline const QMetaObject *qt_getEnumMetaObject(InputMethodHints) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(InputMethodHints) noexcept { return "InputMethodHints"; }
+    inline const QMetaObject *qt_getEnumMetaObject(EnterKeyType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(EnterKeyType) noexcept { return "EnterKeyType"; }
+    inline const QMetaObject *qt_getEnumMetaObject(InputMethodQueries) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(InputMethodQueries) noexcept { return "InputMethodQueries"; }
+    inline const QMetaObject *qt_getEnumMetaObject(TouchPointStates) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TouchPointStates) noexcept { return "TouchPointStates"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ScreenOrientation) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ScreenOrientation) noexcept { return "ScreenOrientation"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ScreenOrientations) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ScreenOrientations) noexcept { return "ScreenOrientations"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ConnectionType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ConnectionType) noexcept { return "ConnectionType"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ApplicationState) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ApplicationState) noexcept { return "ApplicationState"; }
+
+    inline const QMetaObject *qt_getEnumMetaObject(GestureState) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(GestureState) noexcept { return "GestureState"; }
+    inline const QMetaObject *qt_getEnumMetaObject(GestureType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(GestureType) noexcept { return "GestureType"; }
+    inline const QMetaObject *qt_getEnumMetaObject(NativeGestureType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(NativeGestureType) noexcept { return "NativeGestureType"; }
+
+    inline const QMetaObject *qt_getEnumMetaObject(CursorMoveStyle) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(CursorMoveStyle) noexcept { return "CursorMoveStyle"; }
+    inline const QMetaObject *qt_getEnumMetaObject(TimerType) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TimerType) noexcept { return "TimerType"; }
+    inline const QMetaObject *qt_getEnumMetaObject(ScrollPhase) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(ScrollPhase) noexcept { return "ScrollPhase"; }
+    inline const QMetaObject *qt_getEnumMetaObject(MouseEventSource) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MouseEventSource) noexcept { return "MouseEventSource"; }
+    inline const QMetaObject *qt_getEnumMetaObject(MouseEventFlag) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(MouseEventFlag) noexcept { return "MouseEventFlag"; }
+    inline const QMetaObject *qt_getEnumMetaObject(TabFocusBehavior) noexcept { return qt_getQtMetaObject(); } inline constexpr const char *qt_getEnumName(TabFocusBehavior) noexcept { return "TabFocusBehavior"; }
+
+
+}
+
+
+
+
+
+
+
+constexpr inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, Qt::MouseButtons::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::MouseButtons::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, Qt::Orientations::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::Orientations::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, Qt::KeyboardModifiers::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::KeyboardModifiers::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, Qt::WindowFlags::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::WindowFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, Qt::Alignment::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::Alignment::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::Edges::enum_type> operator|(Qt::Edges::enum_type f1, Qt::Edges::enum_type f2) noexcept { return QFlags<Qt::Edges::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::Edges::enum_type> operator|(Qt::Edges::enum_type f1, QFlags<Qt::Edges::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::Edges::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, Qt::ImageConversionFlags::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::ImageConversionFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, Qt::DockWidgetAreas::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::DockWidgetAreas::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, Qt::ToolBarAreas::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::ToolBarAreas::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, Qt::WindowStates::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::WindowStates::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::ScreenOrientations::enum_type> operator|(Qt::ScreenOrientations::enum_type f1, Qt::ScreenOrientations::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::ScreenOrientations::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, Qt::DropActions::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::DropActions::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, Qt::ItemFlags::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::ItemFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, Qt::MatchFlags::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::MatchFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, Qt::TextInteractionFlags::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::TextInteractionFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::InputMethodQueries::enum_type> operator|(Qt::InputMethodQueries::enum_type f1, Qt::InputMethodQueries::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::InputMethodQueries::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::InputMethodHints::enum_type> operator|(Qt::InputMethodHints::enum_type f1, Qt::InputMethodHints::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::InputMethodHints::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::TouchPointStates::enum_type> operator|(Qt::TouchPointStates::enum_type f1, Qt::TouchPointStates::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::TouchPointStates::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+constexpr inline QFlags<Qt::MouseEventFlags::enum_type> operator|(Qt::MouseEventFlags::enum_type f1, Qt::MouseEventFlags::enum_type f2) noexcept { return QFlags<Qt::MouseEventFlags::enum_type>(f1) | f2; } constexpr inline QFlags<Qt::MouseEventFlags::enum_type> operator|(Qt::MouseEventFlags::enum_type f1, QFlags<Qt::MouseEventFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::MouseEventFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+
+constexpr inline QFlags<Qt::GestureFlags::enum_type> operator|(Qt::GestureFlags::enum_type f1, Qt::GestureFlags::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(Qt::GestureFlags::enum_type f1, int f2) noexcept { 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 "../../include/QtCore/qnamespace.h" 2
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h" 2
+# 1 "../../include/QtCore/qarraydata.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qarraydata.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qarraydata.h"
+# 1 "../../include/QtCore/qrefcount.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qarraydata.h" 2
+# 1 "/mnt/odroid-c2/usr/include/string.h" 1 3 4
+# 27 "/mnt/odroid-c2/usr/include/string.h" 3 4
+
+# 27 "/mnt/odroid-c2/usr/include/string.h" 3 4
+extern "C" {
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stddef.h" 1 3 4
+# 33 "/mnt/odroid-c2/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__)) void *
+memchr (void *__s, int __c, size_t __n) throw ()
+{
+  return __builtin_memchr (__s, __c, __n);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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)));
+
+# 162 "/mnt/odroid-c2/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)));
+# 206 "/mnt/odroid-c2/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__)) char *
+strchr (char *__s, int __c) throw ()
+{
+  return __builtin_strchr (__s, __c);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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__)) char *
+strrchr (char *__s, int __c) throw ()
+{
+  return __builtin_strrchr (__s, __c);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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__)) char *
+strpbrk (char *__s, const char *__accept) throw ()
+{
+  return __builtin_strpbrk (__s, __accept);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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__)) char *
+strstr (char *__haystack, const char *__needle) throw ()
+{
+  return __builtin_strstr (__haystack, __needle);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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)));
+# 377 "/mnt/odroid-c2/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 ();
+
+# 433 "/mnt/odroid-c2/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__)) char *
+index (char *__s, int __c) throw ()
+{
+  return __builtin_index (__s, __c);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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__)) char *
+rindex (char *__s, int __c) throw ()
+{
+  return __builtin_rindex (__s, __c);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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)));
+# 648 "/mnt/odroid-c2/usr/include/string.h" 3 4
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
+__mempcpy_inline (void *__restrict __dest,
+    const void *__restrict __src, size_t __n)
+{
+  return (char *) memcpy (__dest, __src, __n) + __n;
+}
+
+
+
+
+}
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qarraydata.h" 2
+
+
+
+
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qarraydata.h"
+struct __attribute__((visibility("default"))) QArrayData
+{
+    QtPrivate::RefCount ref;
+    int size;
+    uint alloc : 31;
+    uint capacityReserved : 1;
+
+    qptrdiff offset;
+
+    void *data()
+    {
+        do { } while ((false) && (size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData)))
+                                                                      ;
+        return reinterpret_cast<char *>(this) + offset;
+    }
+
+    const void *data() const
+    {
+        do { } while ((false) && (size == 0 || offset < 0 || size_t(offset) >= sizeof(QArrayData)))
+                                                                      ;
+        return reinterpret_cast<const char *>(this) + offset;
+    }
+
+
+
+
+    bool isMutable() const
+    {
+        return alloc != 0;
+    }
+
+    enum AllocationOption {
+        CapacityReserved = 0x1,
+
+        Unsharable = 0x2,
+
+        RawData = 0x4,
+        Grow = 0x8,
+
+        Default = 0
+    };
+
+    typedef QFlags<AllocationOption> AllocationOptions;
+
+    size_t detachCapacity(size_t newSize) const
+    {
+        if (capacityReserved && newSize < alloc)
+            return alloc;
+        return newSize;
+    }
+
+    AllocationOptions detachFlags() const
+    {
+        AllocationOptions result;
+        if (capacityReserved)
+            result |= CapacityReserved;
+        return result;
+    }
+
+    AllocationOptions cloneFlags() const
+    {
+        AllocationOptions result;
+        if (capacityReserved)
+            result |= CapacityReserved;
+        return result;
+    }
+
+    static QArrayData *allocate(size_t objectSize, size_t alignment,
+            size_t capacity, AllocationOptions options = Default)
+        noexcept __attribute__ ((__warn_unused_result__));
+    static void deallocate(QArrayData *data, size_t objectSize,
+            size_t alignment) noexcept;
+
+    static const QArrayData shared_null[2];
+    static QArrayData *sharedNull() noexcept { return const_cast<QArrayData*>(shared_null); }
+};
+
+constexpr inline QFlags<QArrayData::AllocationOptions::enum_type> operator|(QArrayData::AllocationOptions::enum_type f1, QArrayData::AllocationOptions::enum_type f2) noexcept { return QFlags<QArrayData::AllocationOptions::enum_type>(f1) | f2; } constexpr inline QFlags<QArrayData::AllocationOptions::enum_type> operator|(QArrayData::AllocationOptions::enum_type f1, QFlags<QArrayData::AllocationOptions::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QArrayData::AllocationOptions::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+
+template <class T>
+struct QTypedArrayData
+    : QArrayData
+{
+# 201 "../../include/QtCore/../../../../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(iterator = iterator()) { return data(); }
+    iterator end(iterator = iterator()) { return data() + size; }
+    const_iterator begin(const_iterator = const_iterator()) const { return data(); }
+    const_iterator end(const_iterator = const_iterator()) const { return data() + size; }
+    const_iterator constBegin(const_iterator = const_iterator()) const { return data(); }
+    const_iterator constEnd(const_iterator = const_iterator()) const { return data() + size; }
+
+    class AlignmentDummy { QArrayData header; T data; };
+
+    static QTypedArrayData *allocate(size_t capacity,
+            AllocationOptions options = Default) __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 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,
+            AllocationOptions options = Default)
+    {
+        static_assert(bool(sizeof(QTypedArrayData) == sizeof(QArrayData)), "sizeof(QTypedArrayData) == sizeof(QArrayData)");
+        QTypedArrayData *result = allocate(0, options | RawData);
+        if (result) {
+            do { } while ((false) && (!result->ref.isShared()));
+
+            result->offset = reinterpret_cast<const char *>(data)
+                - reinterpret_cast<const char *>(result);
+            result->size = int(n);
+        }
+        return result;
+    }
+
+    static QTypedArrayData *sharedNull() noexcept
+    {
+        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;
+};
+# 360 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qarraydata.h"
+namespace QtPrivate {
+struct __attribute__((visibility("default"))) QContainerImplHelper
+{
+    enum CutResult { Null, Empty, Full, Subset };
+    static CutResult mid(int originalLength, int *position, int *length);
+};
+}
+
+
+# 1 "../../include/QtCore/qarraydata.h" 2
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h" 2
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/stdarg.h" 1 3 4
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h" 2
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iterator" 1 3
+# 58 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iterator" 3
+       
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iterator" 3
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 1 3
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+       
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ios" 1 3
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ios" 3
+       
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ios" 3
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+
+
+
+
+
+
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+  class locale
+  {
+  public:
+
+
+    typedef int category;
+
+
+    class facet;
+    class id;
+    class _Impl;
+
+    friend class facet;
+    friend class _Impl;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+# 98 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    static const category none = 0;
+    static const category ctype = 1L << 0;
+    static const category numeric = 1L << 1;
+    static const category collate = 1L << 2;
+    static const category time = 1L << 3;
+    static const category monetary = 1L << 4;
+    static const category messages = 1L << 5;
+    static const category all = (ctype | numeric | collate |
+        time | monetary | messages);
+# 117 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    locale() throw();
+# 126 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    locale(const locale& __other) throw();
+# 136 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    explicit
+    locale(const char* __s);
+# 151 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    locale(const locale& __base, const char* __s, category __cat);
+# 162 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    explicit
+    locale(const std::string& __s) : locale(__s.c_str()) { }
+# 177 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    locale(const locale& __base, const std::string& __s, category __cat)
+    : locale(__base, __s.c_str(), __cat) { }
+# 192 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    locale(const locale& __base, const locale& __add, category __cat);
+# 205 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale(const locale& __other, _Facet* __f);
+
+
+    ~locale() throw();
+# 219 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    const locale&
+    operator=(const locale& __other) throw();
+# 234 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale
+      combine(const locale& __other) const;
+
+
+
+
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    name() const;
+# 254 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    bool
+    operator==(const locale& __other) const throw();
+
+
+
+
+
+
+
+    bool
+    operator!=(const locale& __other) const throw()
+    { return !(this->operator==(__other)); }
+# 282 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    template<typename _Char, typename _Traits, typename _Alloc>
+      bool
+      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
+   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
+# 298 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    static locale
+    global(const locale& __loc);
+
+
+
+
+    static const locale&
+    classic();
+
+  private:
+
+    _Impl* _M_impl;
+
+
+    static _Impl* _S_classic;
+
+
+    static _Impl* _S_global;
+
+
+
+
+
+    static const char* const* const _S_categories;
+# 333 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    enum { _S_categories_size = 6 + 6 };
+
+
+    static __gthread_once_t _S_once;
+
+
+    explicit
+    locale(_Impl*) throw();
+
+    static void
+    _S_initialize();
+
+    static void
+    _S_initialize_once() throw();
+
+    static category
+    _S_normalize_category(category);
+
+    void
+    _M_coalesce(const locale& __base, const locale& __add, category __cat);
+
+
+    static const id* const _S_twinned_facets[];
+
+  };
+# 371 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+  class locale::facet
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    mutable _Atomic_word _M_refcount;
+
+
+    static __c_locale _S_c_locale;
+
+
+    static const char _S_c_name[2];
+
+
+    static __gthread_once_t _S_once;
+
+
+    static void
+    _S_initialize_once();
+
+  protected:
+# 402 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+    explicit
+    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
+    { }
+
+
+    virtual
+    ~facet();
+
+    static void
+    _S_create_c_locale(__c_locale& __cloc, const char* __s,
+         __c_locale __old = 0);
+
+    static __c_locale
+    _S_clone_c_locale(__c_locale& __cloc) throw();
+
+    static void
+    _S_destroy_c_locale(__c_locale& __cloc);
+
+    static __c_locale
+    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
+
+
+
+    static __c_locale
+    _S_get_c_locale();
+
+    __attribute__ ((__const__)) static const char*
+    _S_get_c_name() throw();
+
+  private:
+    void
+    _M_add_reference() const throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() const throw()
+    {
+
+      ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+          ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+
+    facet(const facet&);
+
+    facet&
+    operator=(const facet&);
+
+    class __shim;
+
+    const facet* _M_sso_shim(const id*) const;
+    const facet* _M_cow_shim(const id*) const;
+  };
+# 474 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+  class locale::id
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+
+
+
+    mutable size_t _M_index;
+
+
+    static _Atomic_word _S_refcount;
+
+    void
+    operator=(const id&);
+
+    id(const id&);
+
+  public:
+
+
+
+    id() { }
+
+    size_t
+    _M_id() const throw();
+  };
+
+
+
+  class locale::_Impl
+  {
+  public:
+
+    friend class locale;
+    friend class locale::facet;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+
+  private:
+
+    _Atomic_word _M_refcount;
+    const facet** _M_facets;
+    size_t _M_facets_size;
+    const facet** _M_caches;
+    char** _M_names;
+    static const locale::id* const _S_id_ctype[];
+    static const locale::id* const _S_id_numeric[];
+    static const locale::id* const _S_id_collate[];
+    static const locale::id* const _S_id_time[];
+    static const locale::id* const _S_id_monetary[];
+    static const locale::id* const _S_id_messages[];
+    static const locale::id* const* const _S_facet_categories[];
+
+    void
+    _M_add_reference() throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() throw()
+    {
+
+      ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+          ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+
+    _Impl(const _Impl&, size_t);
+    _Impl(const char*, size_t);
+    _Impl(size_t) throw();
+
+   ~_Impl() throw();
+
+    _Impl(const _Impl&);
+
+    void
+    operator=(const _Impl&);
+
+    bool
+    _M_check_same_name()
+    {
+      bool __ret = true;
+      if (_M_names[1])
+
+ for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
+   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
+      return __ret;
+    }
+
+    void
+    _M_replace_categories(const _Impl*, category);
+
+    void
+    _M_replace_category(const _Impl*, const locale::id* const*);
+
+    void
+    _M_replace_facet(const _Impl*, const locale::id*);
+
+    void
+    _M_install_facet(const locale::id*, const facet*);
+
+    template<typename _Facet>
+      void
+      _M_init_facet(_Facet* __facet)
+      { _M_install_facet(&_Facet::id, __facet); }
+
+    template<typename _Facet>
+      void
+      _M_init_facet_unchecked(_Facet* __facet)
+      {
+ __facet->_M_add_reference();
+ _M_facets[_Facet::id._M_id()] = __facet;
+      }
+
+    void
+    _M_install_cache(const facet*, size_t);
+
+    void _M_init_extra(facet**);
+    void _M_init_extra(void*, void*, const char*, const char*);
+  };
+# 632 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+  template<typename _CharT>
+    class __cxx11:: collate : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+    protected:
+
+
+      __c_locale _M_c_locale_collate;
+
+    public:
+
+      static locale::id id;
+# 659 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+      explicit
+      collate(size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
+      { }
+# 673 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+      explicit
+      collate(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
+      { }
+# 690 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+      int
+      compare(const _CharT* __lo1, const _CharT* __hi1,
+       const _CharT* __lo2, const _CharT* __hi2) const
+      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
+# 709 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+      string_type
+      transform(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_transform(__lo, __hi); }
+# 723 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+      long
+      hash(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_hash(__lo, __hi); }
+
+
+      int
+      _M_compare(const _CharT*, const _CharT*) const throw();
+
+      size_t
+      _M_transform(_CharT*, const _CharT*, size_t) const throw();
+
+  protected:
+
+      virtual
+      ~collate()
+      { _S_destroy_c_locale(_M_c_locale_collate); }
+# 752 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+      virtual int
+      do_compare(const _CharT* __lo1, const _CharT* __hi1,
+   const _CharT* __lo2, const _CharT* __hi2) const;
+# 766 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 3
+      virtual string_type
+      do_transform(const _CharT* __lo, const _CharT* __hi) const;
+# 779 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 __cxx11:: collate_byname : public collate<_CharT>
+    {
+    public:
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+      explicit
+      collate_byname(const char* __s, size_t __refs = 0)
+      : collate<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_collate);
+     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
+   }
+      }
+
+
+      explicit
+      collate_byname(const string& __s, size_t __refs = 0)
+      : collate_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~collate_byname() { }
+    };
+
+
+}
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.tcc" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.tcc" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+    }
+# 102 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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]));
+
+
+
+    }
+# 130 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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&);
+
+
+
+
+}
+# 843 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_classes.h" 2 3
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 2 3
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/system_error" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/system_error" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/system_error" 3
+
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/error_constants.h" 1 3
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/error_constants.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cerrno" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cerrno" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cerrno" 3
+
+# 1 "/mnt/odroid-c2/usr/include/errno.h" 1 3 4
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cerrno" 2 3
+# 35 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/error_constants.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  enum class errc
+    {
+      address_family_not_supported = 97,
+      address_in_use = 98,
+      address_not_available = 99,
+      already_connected = 106,
+      argument_list_too_long = 7,
+      argument_out_of_domain = 33,
+      bad_address = 14,
+      bad_file_descriptor = 9,
+
+
+      bad_message = 74,
+
+
+      broken_pipe = 32,
+      connection_aborted = 103,
+      connection_already_in_progress = 114,
+      connection_refused = 111,
+      connection_reset = 104,
+      cross_device_link = 18,
+      destination_address_required = 89,
+      device_or_resource_busy = 16,
+      directory_not_empty = 39,
+      executable_format_error = 8,
+      file_exists = 17,
+      file_too_large = 27,
+      filename_too_long = 36,
+      function_not_supported = 38,
+      host_unreachable = 113,
+
+
+      identifier_removed = 43,
+
+
+      illegal_byte_sequence = 84,
+      inappropriate_io_control_operation = 25,
+      interrupted = 4,
+      invalid_argument = 22,
+      invalid_seek = 29,
+      io_error = 5,
+      is_a_directory = 21,
+      message_size = 90,
+      network_down = 100,
+      network_reset = 102,
+      network_unreachable = 101,
+      no_buffer_space = 105,
+      no_child_process = 10,
+
+
+      no_link = 67,
+
+
+      no_lock_available = 37,
+
+
+      no_message_available = 61,
+
+
+      no_message = 42,
+      no_protocol_option = 92,
+      no_space_on_device = 28,
+
+
+      no_stream_resources = 63,
+
+
+      no_such_device_or_address = 6,
+      no_such_device = 19,
+      no_such_file_or_directory = 2,
+      no_such_process = 3,
+      not_a_directory = 20,
+      not_a_socket = 88,
+
+
+      not_a_stream = 60,
+
+
+      not_connected = 107,
+      not_enough_memory = 12,
+
+
+      not_supported = 95,
+
+
+
+      operation_canceled = 125,
+
+
+      operation_in_progress = 115,
+      operation_not_permitted = 1,
+      operation_not_supported = 95,
+      operation_would_block = 11,
+
+
+      owner_dead = 130,
+
+
+      permission_denied = 13,
+
+
+      protocol_error = 71,
+
+
+      protocol_not_supported = 93,
+      read_only_file_system = 30,
+      resource_deadlock_would_occur = 35,
+      resource_unavailable_try_again = 11,
+      result_out_of_range = 34,
+
+
+      state_not_recoverable = 131,
+
+
+
+      stream_timeout = 62,
+
+
+
+      text_file_busy = 26,
+
+
+      timed_out = 110,
+      too_many_files_open_in_system = 23,
+      too_many_files_open = 24,
+      too_many_links = 31,
+      too_many_symbolic_link_levels = 40,
+
+
+      value_too_large = 75,
+
+
+      wrong_protocol_type = 91
+    };
+
+
+}
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/system_error" 2 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/stdexcept" 1 3
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/stdexcept" 3
+       
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/stdexcept" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  struct __cow_string
+  {
+    union {
+      const char* _M_p;
+      char _M_bytes[sizeof(const char*)];
+    };
+
+    __cow_string();
+    __cow_string(const std::string&);
+    __cow_string(const char*, size_t);
+    __cow_string(const __cow_string&) noexcept;
+    __cow_string& operator=(const __cow_string&) noexcept;
+    ~__cow_string();
+
+    __cow_string(__cow_string&&) noexcept;
+    __cow_string& operator=(__cow_string&&) noexcept;
+
+  };
+
+  typedef basic_string<char> __sso_string;
+# 113 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/stdexcept" 3
+  class logic_error : public exception
+  {
+    __cow_string _M_msg;
+
+  public:
+
+    explicit
+    logic_error(const string& __arg);
+
+
+    explicit
+    logic_error(const char*);
+
+
+
+    logic_error(const logic_error&) noexcept;
+    logic_error& operator=(const logic_error&) noexcept;
+
+
+    virtual ~logic_error() noexcept;
+
+
+
+    virtual const char*
+    what() const noexcept;
+  };
+
+
+
+  class domain_error : public logic_error
+  {
+  public:
+    explicit domain_error(const string& __arg);
+
+    explicit domain_error(const char*);
+
+    virtual ~domain_error() noexcept;
+  };
+
+
+  class invalid_argument : public logic_error
+  {
+  public:
+    explicit invalid_argument(const string& __arg);
+
+    explicit invalid_argument(const char*);
+
+    virtual ~invalid_argument() noexcept;
+  };
+
+
+
+  class length_error : public logic_error
+  {
+  public:
+    explicit length_error(const string& __arg);
+
+    explicit length_error(const char*);
+
+    virtual ~length_error() noexcept;
+  };
+
+
+
+  class out_of_range : public logic_error
+  {
+  public:
+    explicit out_of_range(const string& __arg);
+
+    explicit out_of_range(const char*);
+
+    virtual ~out_of_range() noexcept;
+  };
+
+
+
+
+
+
+  class runtime_error : public exception
+  {
+    __cow_string _M_msg;
+
+  public:
+
+    explicit
+    runtime_error(const string& __arg);
+
+
+    explicit
+    runtime_error(const char*);
+
+
+
+    runtime_error(const runtime_error&) noexcept;
+    runtime_error& operator=(const runtime_error&) noexcept;
+
+
+    virtual ~runtime_error() noexcept;
+
+
+
+    virtual const char*
+    what() const noexcept;
+  };
+
+
+  class range_error : public runtime_error
+  {
+  public:
+    explicit range_error(const string& __arg);
+
+    explicit range_error(const char*);
+
+    virtual ~range_error() noexcept;
+  };
+
+
+  class overflow_error : public runtime_error
+  {
+  public:
+    explicit overflow_error(const string& __arg);
+
+    explicit overflow_error(const char*);
+
+    virtual ~overflow_error() noexcept;
+  };
+
+
+  class underflow_error : public runtime_error
+  {
+  public:
+    explicit underflow_error(const string& __arg);
+
+    explicit underflow_error(const char*);
+
+    virtual ~underflow_error() noexcept;
+  };
+
+
+
+
+}
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/system_error" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  class error_code;
+  class error_condition;
+  class system_error;
+
+
+  template<typename _Tp>
+    struct is_error_code_enum : public false_type { };
+
+
+  template<typename _Tp>
+    struct is_error_condition_enum : public false_type { };
+
+  template<>
+    struct is_error_condition_enum<errc>
+    : public true_type { };
+
+  inline namespace _V2 {
+
+
+  class error_category
+  {
+  public:
+    constexpr error_category() noexcept = default;
+
+    virtual ~error_category();
+
+    error_category(const error_category&) = delete;
+    error_category& operator=(const error_category&) = delete;
+
+    virtual const char*
+    name() const noexcept = 0;
+
+
+
+
+
+
+  private:
+    __attribute ((__abi_tag__ ("cxx11")))
+    virtual __cow_string
+    _M_message(int) const;
+
+  public:
+    __attribute ((__abi_tag__ ("cxx11")))
+    virtual string
+    message(int) const = 0;
+# 102 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/system_error" 3
+  public:
+    virtual error_condition
+    default_error_condition(int __i) const noexcept;
+
+    virtual bool
+    equivalent(int __i, const error_condition& __cond) const noexcept;
+
+    virtual bool
+    equivalent(const error_code& __code, int __i) const noexcept;
+
+    bool
+    operator<(const error_category& __other) const noexcept
+    { return less<const error_category*>()(this, &__other); }
+
+    bool
+    operator==(const error_category& __other) const noexcept
+    { return this == &__other; }
+
+    bool
+    operator!=(const error_category& __other) const noexcept
+    { return this != &__other; }
+  };
+
+
+  __attribute__ ((__const__)) const error_category& system_category() noexcept;
+  __attribute__ ((__const__)) const error_category& generic_category() noexcept;
+
+  }
+
+  error_code make_error_code(errc) noexcept;
+
+  template<typename _Tp>
+    struct hash;
+
+
+
+  struct error_code
+  {
+    error_code() noexcept
+    : _M_value(0), _M_cat(&system_category()) { }
+
+    error_code(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+
+    template<typename _ErrorCodeEnum, typename = typename
+      enable_if<is_error_code_enum<_ErrorCodeEnum>::value>::type>
+      error_code(_ErrorCodeEnum __e) noexcept
+      { *this = make_error_code(__e); }
+
+    void
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat;
+    }
+
+    void
+    clear() noexcept
+    { assign(0, system_category()); }
+
+
+    template<typename _ErrorCodeEnum>
+      typename enable_if<is_error_code_enum<_ErrorCodeEnum>::value,
+    error_code&>::type
+      operator=(_ErrorCodeEnum __e) noexcept
+      { return *this = make_error_code(__e); }
+
+    int
+    value() const noexcept { return _M_value; }
+
+    const error_category&
+    category() const noexcept { return *_M_cat; }
+
+    error_condition
+    default_error_condition() const noexcept;
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    message() const
+    { return category().message(value()); }
+
+    explicit operator bool() const noexcept
+    { return _M_value != 0 ? true : false; }
+
+
+  private:
+    friend class hash<error_code>;
+
+    int _M_value;
+    const error_category* _M_cat;
+  };
+
+
+  inline error_code
+  make_error_code(errc __e) noexcept
+  { return error_code(static_cast<int>(__e), generic_category()); }
+
+  inline bool
+  operator<(const error_code& __lhs, const error_code& __rhs) noexcept
+  {
+    return (__lhs.category() < __rhs.category()
+     || (__lhs.category() == __rhs.category()
+  && __lhs.value() < __rhs.value()));
+  }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
+    { return (__os << __e.category().name() << ':' << __e.value()); }
+
+  error_condition make_error_condition(errc) noexcept;
+
+
+
+  struct error_condition
+  {
+    error_condition() noexcept
+    : _M_value(0), _M_cat(&generic_category()) { }
+
+    error_condition(int __v, const error_category& __cat) noexcept
+    : _M_value(__v), _M_cat(&__cat) { }
+
+    template<typename _ErrorConditionEnum, typename = typename
+  enable_if<is_error_condition_enum<_ErrorConditionEnum>::value>::type>
+      error_condition(_ErrorConditionEnum __e) noexcept
+      { *this = make_error_condition(__e); }
+
+    void
+    assign(int __v, const error_category& __cat) noexcept
+    {
+      _M_value = __v;
+      _M_cat = &__cat;
+    }
+
+
+    template<typename _ErrorConditionEnum>
+      typename enable_if<is_error_condition_enum
+    <_ErrorConditionEnum>::value, error_condition&>::type
+      operator=(_ErrorConditionEnum __e) noexcept
+      { return *this = make_error_condition(__e); }
+
+    void
+    clear() noexcept
+    { assign(0, generic_category()); }
+
+
+    int
+    value() const noexcept { return _M_value; }
+
+    const error_category&
+    category() const noexcept { return *_M_cat; }
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    message() const
+    { return category().message(value()); }
+
+    explicit operator bool() const noexcept
+    { return _M_value != 0 ? true : false; }
+
+
+  private:
+    int _M_value;
+    const error_category* _M_cat;
+  };
+
+
+  inline error_condition
+  make_error_condition(errc __e) noexcept
+  { return error_condition(static_cast<int>(__e), generic_category()); }
+
+  inline bool
+  operator<(const error_condition& __lhs,
+     const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() < __rhs.category()
+     || (__lhs.category() == __rhs.category()
+  && __lhs.value() < __rhs.value()));
+  }
+
+
+  inline bool
+  operator==(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return (__lhs.category() == __rhs.category()
+     && __lhs.value() == __rhs.value()); }
+
+  inline bool
+  operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category().equivalent(__lhs.value(), __rhs)
+     || __rhs.category().equivalent(__lhs, __rhs.value()));
+  }
+
+  inline bool
+  operator==(const error_condition& __lhs, const error_code& __rhs) noexcept
+  {
+    return (__rhs.category().equivalent(__rhs.value(), __lhs)
+     || __lhs.category().equivalent(__rhs, __lhs.value()));
+  }
+
+  inline bool
+  operator==(const error_condition& __lhs,
+      const error_condition& __rhs) noexcept
+  {
+    return (__lhs.category() == __rhs.category()
+     && __lhs.value() == __rhs.value());
+  }
+
+  inline bool
+  operator!=(const error_code& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+  inline bool
+  operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+  inline bool
+  operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+  inline bool
+  operator!=(const error_condition& __lhs,
+      const error_condition& __rhs) noexcept
+  { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  class system_error : public std::runtime_error
+  {
+  private:
+    error_code _M_code;
+
+  public:
+    system_error(error_code __ec = error_code())
+    : runtime_error(__ec.message()), _M_code(__ec) { }
+
+    system_error(error_code __ec, const string& __what)
+    : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { }
+
+    system_error(error_code __ec, const char* __what)
+    : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }
+
+    system_error(int __v, const error_category& __ecat, const char* __what)
+    : system_error(error_code(__v, __ecat), __what) { }
+
+    system_error(int __v, const error_category& __ecat)
+    : runtime_error(error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+
+    system_error(int __v, const error_category& __ecat, const string& __what)
+    : runtime_error(__what + ": " + error_code(__v, __ecat).message()),
+      _M_code(__v, __ecat) { }
+
+    virtual ~system_error() noexcept;
+
+    const error_code&
+    code() const noexcept { return _M_code; }
+  };
+
+
+}
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<>
+    struct hash<error_code>
+    : public __hash_base<size_t, error_code>
+    {
+      size_t
+      operator()(const error_code& __e) const noexcept
+      {
+ const size_t __tmp = std::_Hash_impl::hash(__e._M_value);
+ return std::_Hash_impl::__hash_combine(__e._M_cat, __tmp);
+      }
+    };
+
+
+}
+# 47 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  enum _Ios_Fmtflags
+    {
+      _S_boolalpha = 1L << 0,
+      _S_dec = 1L << 1,
+      _S_fixed = 1L << 2,
+      _S_hex = 1L << 3,
+      _S_internal = 1L << 4,
+      _S_left = 1L << 5,
+      _S_oct = 1L << 6,
+      _S_right = 1L << 7,
+      _S_scientific = 1L << 8,
+      _S_showbase = 1L << 9,
+      _S_showpoint = 1L << 10,
+      _S_showpos = 1L << 11,
+      _S_skipws = 1L << 12,
+      _S_unitbuf = 1L << 13,
+      _S_uppercase = 1L << 14,
+      _S_adjustfield = _S_left | _S_right | _S_internal,
+      _S_basefield = _S_dec | _S_oct | _S_hex,
+      _S_floatfield = _S_scientific | _S_fixed,
+      _S_ios_fmtflags_end = 1L << 16,
+      _S_ios_fmtflags_max = 0x7fffffff,
+      _S_ios_fmtflags_min = ~0x7fffffff
+    };
+
+  inline 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,
+      _S_ios_openmode_max = 0x7fffffff,
+      _S_ios_openmode_min = ~0x7fffffff
+    };
+
+  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,
+      _S_ios_iostate_max = 0x7fffffff,
+      _S_ios_iostate_min = ~0x7fffffff
+    };
+
+  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
+    };
+
+
+
+  enum class io_errc { stream = 1 };
+
+  template <> struct is_error_code_enum<io_errc> : public true_type { };
+
+  const error_category& iostream_category() noexcept;
+
+  inline error_code
+  make_error_code(io_errc e) noexcept
+  { return error_code(static_cast<int>(e), iostream_category()); }
+
+  inline error_condition
+  make_error_condition(io_errc e) noexcept
+  { return error_condition(static_cast<int>(e), iostream_category()); }
+# 228 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+  class ios_base
+  {
+# 246 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+  public:
+# 255 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
+    {
+    public:
+      explicit
+      failure(const string& __str);
+
+
+      explicit
+      failure(const string&, const error_code&);
+
+      explicit
+      failure(const char*, const error_code& = io_errc::stream);
+
+
+      virtual
+      ~failure() throw();
+
+      virtual const char*
+      what() const throw();
+    };
+# 323 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    typedef _Ios_Fmtflags fmtflags;
+
+
+    static const fmtflags boolalpha = _S_boolalpha;
+
+
+    static const fmtflags dec = _S_dec;
+
+
+    static const fmtflags fixed = _S_fixed;
+
+
+    static const fmtflags hex = _S_hex;
+
+
+
+
+    static const fmtflags internal = _S_internal;
+
+
+
+    static const fmtflags left = _S_left;
+
+
+    static const fmtflags oct = _S_oct;
+
+
+
+    static const fmtflags right = _S_right;
+
+
+    static const fmtflags scientific = _S_scientific;
+
+
+
+    static const fmtflags showbase = _S_showbase;
+
+
+
+    static const fmtflags showpoint = _S_showpoint;
+
+
+    static const fmtflags showpos = _S_showpos;
+
+
+    static const fmtflags skipws = _S_skipws;
+
+
+    static const fmtflags unitbuf = _S_unitbuf;
+
+
+
+    static const fmtflags uppercase = _S_uppercase;
+
+
+    static const fmtflags adjustfield = _S_adjustfield;
+
+
+    static const fmtflags basefield = _S_basefield;
+
+
+    static const fmtflags floatfield = _S_floatfield;
+# 398 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    typedef _Ios_Iostate iostate;
+
+
+
+    static const iostate badbit = _S_badbit;
+
+
+    static const iostate eofbit = _S_eofbit;
+
+
+
+
+    static const iostate failbit = _S_failbit;
+
+
+    static const iostate goodbit = _S_goodbit;
+# 429 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    typedef _Ios_Openmode openmode;
+
+
+    static const openmode app = _S_app;
+
+
+    static const openmode ate = _S_ate;
+
+
+
+
+    static const openmode binary = _S_bin;
+
+
+    static const openmode in = _S_in;
+
+
+    static const openmode out = _S_out;
+
+
+    static const openmode trunc = _S_trunc;
+# 461 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    typedef _Ios_Seekdir seekdir;
+
+
+    static const seekdir beg = _S_beg;
+
+
+    static const seekdir cur = _S_cur;
+
+
+    static const seekdir end = _S_end;
+
+
+    typedef int io_state;
+    typedef int open_mode;
+    typedef int seek_dir;
+
+    typedef std::streampos streampos;
+    typedef std::streamoff streamoff;
+# 487 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    enum event
+    {
+      erase_event,
+      imbue_event,
+      copyfmt_event
+    };
+# 504 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
+# 516 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    void
+    register_callback(event_callback __fn, int __index);
+
+  protected:
+    streamsize _M_precision;
+    streamsize _M_width;
+    fmtflags _M_flags;
+    iostate _M_exception;
+    iostate _M_streambuf_state;
+
+
+
+    struct _Callback_list
+    {
+
+      _Callback_list* _M_next;
+      ios_base::event_callback _M_fn;
+      int _M_index;
+      _Atomic_word _M_refcount;
+
+      _Callback_list(ios_base::event_callback __fn, int __index,
+       _Callback_list* __cb)
+      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
+
+      void
+      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+
+      int
+      _M_remove_reference()
+      {
+
+        ;
+        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
+        if (__res == 0)
+          {
+            ;
+          }
+        return __res;
+      }
+    };
+
+     _Callback_list* _M_callbacks;
+
+    void
+    _M_call_callbacks(event __ev) throw();
+
+    void
+    _M_dispose_callbacks(void) throw();
+
+
+    struct _Words
+    {
+      void* _M_pword;
+      long _M_iword;
+      _Words() : _M_pword(0), _M_iword(0) { }
+    };
+
+
+    _Words _M_word_zero;
+
+
+
+    enum { _S_local_word_size = 8 };
+    _Words _M_local_word[_S_local_word_size];
+
+
+    int _M_word_size;
+    _Words* _M_word;
+
+    _Words&
+    _M_grow_words(int __index, bool __iword);
+
+
+    locale _M_ios_locale;
+
+    void
+    _M_init() throw();
+
+  public:
+
+
+
+
+
+    class Init
+    {
+      friend class ios_base;
+    public:
+      Init();
+      ~Init();
+
+    private:
+      static _Atomic_word _S_refcount;
+      static bool _S_synced_with_stdio;
+    };
+
+
+
+
+
+
+    fmtflags
+    flags() const
+    { return _M_flags; }
+# 629 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    fmtflags
+    flags(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags = __fmtfl;
+      return __old;
+    }
+# 645 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags |= __fmtfl;
+      return __old;
+    }
+# 662 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl, fmtflags __mask)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags &= ~__mask;
+      _M_flags |= (__fmtfl & __mask);
+      return __old;
+    }
+
+
+
+
+
+
+
+    void
+    unsetf(fmtflags __mask)
+    { _M_flags &= ~__mask; }
+# 688 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    streamsize
+    precision() const
+    { return _M_precision; }
+
+
+
+
+
+
+    streamsize
+    precision(streamsize __prec)
+    {
+      streamsize __old = _M_precision;
+      _M_precision = __prec;
+      return __old;
+    }
+
+
+
+
+
+
+
+    streamsize
+    width() const
+    { return _M_width; }
+
+
+
+
+
+
+    streamsize
+    width(streamsize __wide)
+    {
+      streamsize __old = _M_width;
+      _M_width = __wide;
+      return __old;
+    }
+# 739 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    static bool
+    sync_with_stdio(bool __sync = true);
+# 751 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    locale
+    imbue(const locale& __loc) throw();
+# 762 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    locale
+    getloc() const
+    { return _M_ios_locale; }
+# 773 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    const locale&
+    _M_getloc() const
+    { return _M_ios_locale; }
+# 792 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    static int
+    xalloc() throw();
+# 808 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    long&
+    iword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, true);
+      return __word._M_iword;
+    }
+# 829 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    void*&
+    pword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, false);
+      return __word._M_pword;
+    }
+# 846 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+    virtual ~ios_base();
+
+  protected:
+    ios_base() throw ();
+# 860 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ios_base.h" 3
+  public:
+    ios_base(const ios_base&) = delete;
+
+    ios_base&
+    operator=(const ios_base&) = delete;
+
+  protected:
+    void
+    _M_move(ios_base&) noexcept;
+
+    void
+    _M_swap(ios_base& __rhs) noexcept;
+
+  };
+
+
+
+  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;
+  }
+
+
+
+
+
+
+  inline ios_base&
+  hexfloat(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  defaultfloat(ios_base& __base)
+  {
+    __base.unsetf(ios_base::floatfield);
+    return __base;
+  }
+
+
+
+}
+# 43 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ios" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 1 3
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+       
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
+     basic_streambuf<_CharT, _Traits>*, bool&);
+# 119 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+  template<typename _CharT, typename _Traits>
+    class basic_streambuf
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+
+
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+
+
+      friend class basic_ios<char_type, traits_type>;
+      friend class basic_istream<char_type, traits_type>;
+      friend class basic_ostream<char_type, traits_type>;
+      friend class istreambuf_iterator<char_type, traits_type>;
+      friend class ostreambuf_iterator<char_type, traits_type>;
+
+      friend streamsize
+      __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);
+
+      template<bool _IsMove, typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+        __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+
+      template<typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+      istreambuf_iterator<_CharT2> >::__type
+        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+
+      template<typename _CharT2, typename _Traits2>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&,
+     basic_string<_CharT2, _Traits2, _Alloc>&);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        getline(basic_istream<_CharT2, _Traits2>&,
+  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
+
+    protected:
+
+
+
+
+
+
+
+      char_type* _M_in_beg;
+      char_type* _M_in_cur;
+      char_type* _M_in_end;
+      char_type* _M_out_beg;
+      char_type* _M_out_cur;
+      char_type* _M_out_end;
+
+
+      locale _M_buf_locale;
+
+  public:
+
+      virtual
+      ~basic_streambuf()
+      { }
+# 208 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      locale
+      pubimbue(const locale& __loc)
+      {
+ locale __tmp(this->getloc());
+ this->imbue(__loc);
+ _M_buf_locale = __loc;
+ return __tmp;
+      }
+# 225 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      locale
+      getloc() const
+      { return _M_buf_locale; }
+# 238 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      basic_streambuf*
+      pubsetbuf(char_type* __s, streamsize __n)
+      { return this->setbuf(__s, __n); }
+# 250 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      pos_type
+      pubseekoff(off_type __off, ios_base::seekdir __way,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekoff(__off, __way, __mode); }
+# 262 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      pos_type
+      pubseekpos(pos_type __sp,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekpos(__sp, __mode); }
+
+
+
+
+      int
+      pubsync() { return this->sync(); }
+# 283 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      streamsize
+      in_avail()
+      {
+ const streamsize __ret = this->egptr() - this->gptr();
+ return __ret ? __ret : this->showmanyc();
+      }
+# 297 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      int_type
+      snextc()
+      {
+ int_type __ret = traits_type::eof();
+ if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
+             __ret), true))
+   __ret = this->sgetc();
+ return __ret;
+      }
+# 315 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      int_type
+      sbumpc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ else
+   __ret = this->uflow();
+ return __ret;
+      }
+# 337 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      int_type
+      sgetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   __ret = traits_type::to_int_type(*this->gptr());
+ else
+   __ret = this->underflow();
+ return __ret;
+      }
+# 356 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      streamsize
+      sgetn(char_type* __s, streamsize __n)
+      { return this->xsgetn(__s, __n); }
+# 371 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      int_type
+      sputbackc(char_type __c)
+      {
+ int_type __ret;
+ const bool __testpos = this->eback() < this->gptr();
+ if (__builtin_expect(!__testpos ||
+        !traits_type::eq(__c, this->gptr()[-1]), false))
+   __ret = this->pbackfail(traits_type::to_int_type(__c));
+ else
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ return __ret;
+      }
+# 396 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      int_type
+      sungetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->eback() < this->gptr(), true))
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ else
+   __ret = this->pbackfail();
+ return __ret;
+      }
+# 423 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      int_type
+      sputc(char_type __c)
+      {
+ int_type __ret;
+ if (__builtin_expect(this->pptr() < this->epptr(), true))
+   {
+     *this->pptr() = __c;
+     this->pbump(1);
+     __ret = traits_type::to_int_type(__c);
+   }
+ else
+   __ret = this->overflow(traits_type::to_int_type(__c));
+ return __ret;
+      }
+# 449 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      streamsize
+      sputn(const char_type* __s, streamsize __n)
+      { return this->xsputn(__s, __n); }
+
+    protected:
+# 463 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      basic_streambuf()
+      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
+      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
+      _M_buf_locale(locale())
+      { }
+# 481 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      char_type*
+      eback() const { return _M_in_beg; }
+
+      char_type*
+      gptr() const { return _M_in_cur; }
+
+      char_type*
+      egptr() const { return _M_in_end; }
+# 497 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      void
+      gbump(int __n) { _M_in_cur += __n; }
+# 508 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      void
+      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
+      {
+ _M_in_beg = __gbeg;
+ _M_in_cur = __gnext;
+ _M_in_end = __gend;
+      }
+# 528 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      char_type*
+      pbase() const { return _M_out_beg; }
+
+      char_type*
+      pptr() const { return _M_out_cur; }
+
+      char_type*
+      epptr() const { return _M_out_end; }
+# 544 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      void
+      pbump(int __n) { _M_out_cur += __n; }
+# 554 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      void
+      setp(char_type* __pbeg, char_type* __pend)
+      {
+ _M_out_beg = _M_out_cur = __pbeg;
+ _M_out_end = __pend;
+      }
+# 575 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual void
+      imbue(const locale& __loc)
+      { }
+# 590 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual basic_streambuf<char_type,_Traits>*
+      setbuf(char_type*, streamsize)
+      { return this; }
+# 601 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual pos_type
+      seekoff(off_type, ios_base::seekdir,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 613 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual pos_type
+      seekpos(pos_type,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 626 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual int
+      sync() { return 0; }
+# 648 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual streamsize
+      showmanyc() { return 0; }
+# 664 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+# 686 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual int_type
+      underflow()
+      { return traits_type::eof(); }
+# 699 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual int_type
+      uflow()
+      {
+ int_type __ret = traits_type::eof();
+ const bool __testeof = traits_type::eq_int_type(this->underflow(),
+       __ret);
+ if (!__testeof)
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ return __ret;
+      }
+# 723 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof())
+      { return traits_type::eof(); }
+# 741 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+# 767 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 3
+      virtual int_type
+      overflow(int_type __c = traits_type::eof())
+      { return traits_type::eof(); }
+
+
+
+    public:
+# 782 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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; }
+
+
+
+
+    protected:
+
+      basic_streambuf(const basic_streambuf&);
+
+      basic_streambuf&
+      operator=(const basic_streambuf&);
+
+
+      void
+      swap(basic_streambuf& __sb)
+      {
+ std::swap(_M_in_beg, __sb._M_in_beg);
+ std::swap(_M_in_cur, __sb._M_in_cur);
+ std::swap(_M_in_end, __sb._M_in_end);
+ std::swap(_M_out_beg, __sb._M_out_beg);
+ std::swap(_M_out_cur, __sb._M_out_cur);
+ std::swap(_M_out_end, __sb._M_out_end);
+ std::swap(_M_buf_locale, __sb._M_buf_locale);
+      }
+
+    };
+
+
+  template<typename _CharT, typename _Traits>
+    std::basic_streambuf<_CharT, _Traits>::
+    basic_streambuf(const basic_streambuf&) = default;
+
+  template<typename _CharT, typename _Traits>
+    std::basic_streambuf<_CharT, _Traits>&
+    std::basic_streambuf<_CharT, _Traits>::
+    operator=(const basic_streambuf&) = default;
+
+
+
+  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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/streambuf.tcc" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/streambuf.tcc" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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&);
+
+
+
+
+}
+# 851 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/streambuf" 2 3
+# 44 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ios" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwctype" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwctype" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwctype" 3
+# 50 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwctype" 3
+# 1 "/mnt/odroid-c2/usr/include/wctype.h" 1 3 4
+# 33 "/mnt/odroid-c2/usr/include/wctype.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/wchar.h" 1 3 4
+# 34 "/mnt/odroid-c2/usr/include/wctype.h" 2 3 4
+# 49 "/mnt/odroid-c2/usr/include/wctype.h" 3 4
+
+
+
+typedef unsigned long int wctype_t;
+
+# 71 "/mnt/odroid-c2/usr/include/wctype.h" 3 4
+enum
+{
+  __ISwupper = 0,
+  __ISwlower = 1,
+  __ISwalpha = 2,
+  __ISwdigit = 3,
+  __ISwxdigit = 4,
+  __ISwspace = 5,
+  __ISwprint = 6,
+  __ISwgraph = 7,
+  __ISwblank = 8,
+  __ISwcntrl = 9,
+  __ISwpunct = 10,
+  __ISwalnum = 11,
+
+  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
+  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
+  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
+  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
+  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
+  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
+  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
+  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
+  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
+  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
+  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
+  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
+};
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+extern int iswalnum (wint_t __wc) throw ();
+
+
+
+
+
+extern int iswalpha (wint_t __wc) throw ();
+
+
+extern int iswcntrl (wint_t __wc) throw ();
+
+
+
+extern int iswdigit (wint_t __wc) throw ();
+
+
+
+extern int iswgraph (wint_t __wc) throw ();
+
+
+
+
+extern int iswlower (wint_t __wc) throw ();
+
+
+extern int iswprint (wint_t __wc) throw ();
+
+
+
+
+extern int iswpunct (wint_t __wc) throw ();
+
+
+
+
+extern int iswspace (wint_t __wc) throw ();
+
+
+
+
+extern int iswupper (wint_t __wc) throw ();
+
+
+
+
+extern int iswxdigit (wint_t __wc) throw ();
+
+
+
+
+
+extern int iswblank (wint_t __wc) throw ();
+# 171 "/mnt/odroid-c2/usr/include/wctype.h" 3 4
+extern wctype_t wctype (const char *__property) throw ();
+
+
+
+extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
+
+
+
+
+
+
+
+
+
+
+typedef const __int32_t *wctrans_t;
+
+
+
+
+
+
+
+extern wint_t towlower (wint_t __wc) throw ();
+
+
+extern wint_t towupper (wint_t __wc) throw ();
+
+
+}
+# 213 "/mnt/odroid-c2/usr/include/wctype.h" 3 4
+extern "C" {
+
+
+
+
+extern wctrans_t wctrans (const char *__property) throw ();
+
+
+extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
+
+
+
+
+
+
+
+
+extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+
+extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern wctype_t wctype_l (const char *__property, __locale_t __locale)
+     throw ();
+
+
+
+extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
+     throw ();
+
+
+
+
+
+
+
+extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern wctrans_t wctrans_l (const char *__property, __locale_t __locale)
+     throw ();
+
+
+extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
+      __locale_t __locale) throw ();
+
+
+
+}
+# 51 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwctype" 2 3
+# 80 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cwctype" 3
+namespace std
+{
+  using ::wctrans_t;
+  using ::wctype_t;
+  using ::wint_t;
+
+  using ::iswalnum;
+  using ::iswalpha;
+
+  using ::iswblank;
+
+  using ::iswcntrl;
+  using ::iswctype;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::towctrans;
+  using ::towlower;
+  using ::towupper;
+  using ::wctrans;
+  using ::wctype;
+}
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cctype" 1 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cctype" 3
+       
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/cctype" 3
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/ctype_base.h" 1 3
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/ctype_base.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  struct ctype_base
+  {
+
+    typedef const int* __to_type;
+
+
+
+    typedef unsigned short mask;
+    static const mask upper = _ISupper;
+    static const mask lower = _ISlower;
+    static const mask alpha = _ISalpha;
+    static const mask digit = _ISdigit;
+    static const mask xdigit = _ISxdigit;
+    static const mask space = _ISspace;
+    static const mask print = _ISprint;
+    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
+    static const mask cntrl = _IScntrl;
+    static const mask punct = _ISpunct;
+    static const mask alnum = _ISalpha | _ISdigit;
+
+    static const mask blank = _ISblank;
+
+  };
+
+
+}
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 2 3
+
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/streambuf_iterator.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/streambuf_iterator.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/streambuf_iterator.h" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 49 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+
+
+
+
+}
+# 49 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 71 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 149 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class __ctype_abstract_base : public locale::facet, public ctype_base
+    {
+    public:
+
+
+      typedef _CharT char_type;
+# 168 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      bool
+      is(mask __m, char_type __c) const
+      { return this->do_is(__m, __c); }
+# 185 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char_type*
+      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
+      { return this->do_is(__lo, __hi, __vec); }
+# 201 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char_type*
+      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_is(__m, __lo, __hi); }
+# 217 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char_type*
+      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_not(__m, __lo, __hi); }
+# 231 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 246 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 260 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 275 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 292 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      char_type
+      widen(char __c) const
+      { return this->do_widen(__c); }
+# 311 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      { return this->do_widen(__lo, __hi, __to); }
+# 330 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return this->do_narrow(__c, __dfault); }
+# 352 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+       char __dfault, char* __to) const
+      { return this->do_narrow(__lo, __hi, __dfault, __to); }
+
+    protected:
+      explicit
+      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
+
+      virtual
+      ~__ctype_abstract_base() { }
+# 377 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const = 0;
+# 396 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi,
+     mask* __vec) const = 0;
+# 415 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo,
+   const char_type* __hi) const = 0;
+# 434 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const = 0;
+# 452 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const = 0;
+# 469 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
+# 485 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const = 0;
+# 502 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
+# 521 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const = 0;
+# 542 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
+# 563 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const = 0;
+# 588 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const = 0;
+    };
+# 611 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+# 680 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+# 717 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      explicit
+      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
+# 730 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
+     size_t __refs = 0);
+# 743 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      inline bool
+      is(mask __m, char __c) const;
+# 758 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      inline const char*
+      is(const char* __lo, const char* __hi, mask* __vec) const;
+# 772 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      inline const char*
+      scan_is(mask __m, const char* __lo, const char* __hi) const;
+# 786 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      inline const char*
+      scan_not(mask __m, const char* __lo, const char* __hi) const;
+# 801 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 818 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 834 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 851 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 871 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+      }
+# 898 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (_M_widen_ok == 1)
+   {
+     __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_widen_ok)
+   _M_widen_init();
+ return this->do_widen(__lo, __hi, __to);
+      }
+# 929 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+      }
+# 962 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+      char __dfault, char* __to) const
+      {
+ if (__builtin_expect(_M_narrow_ok == 1, true))
+   {
+     __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_narrow_ok)
+   _M_narrow_init();
+ return this->do_narrow(__lo, __hi, __dfault, __to);
+      }
+
+
+
+
+
+      const mask*
+      table() const throw()
+      { return _M_table; }
+
+
+      static const mask*
+      classic_table() throw();
+    protected:
+
+
+
+
+
+
+
+      virtual
+      ~ctype();
+# 1011 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const;
+# 1028 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1044 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const;
+# 1061 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1081 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const
+      { return __c; }
+# 1104 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+# 1130 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const
+      { return __c; }
+# 1156 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const
+      {
+ __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+
+    private:
+      void _M_narrow_init() const;
+      void _M_widen_init() const;
+    };
+# 1181 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+  template<>
+    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
+    {
+    public:
+
+
+      typedef wchar_t char_type;
+      typedef wctype_t __wmask_type;
+
+    protected:
+      __c_locale _M_c_locale_ctype;
+
+
+      bool _M_narrow_ok;
+      char _M_narrow[128];
+      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
+
+
+      mask _M_bit[16];
+      __wmask_type _M_wmask[16];
+
+    public:
+
+
+      static locale::id id;
+# 1214 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      explicit
+      ctype(size_t __refs = 0);
+# 1225 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      __wmask_type
+      _M_convert_to_wmask(const mask __m) const throw();
+
+
+      virtual
+      ~ctype();
+# 1249 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+# 1268 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+# 1286 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+# 1304 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+# 1321 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const;
+# 1338 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1354 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const;
+# 1371 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1391 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const;
+# 1413 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
+# 1436 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const;
+# 1462 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+
+
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0)
+      : ctype_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~ctype_byname() { };
+    };
+
+
+  template<>
+    class ctype_byname<char> : public ctype<char>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+
+      explicit
+      ctype_byname(const string& __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);
+
+
+      explicit
+      ctype_byname(const string& __s, size_t __refs = 0);
+
+
+    protected:
+      virtual
+      ~ctype_byname();
+    };
+
+
+
+}
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/bits/ctype_inline.h" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/aarch64-linux-gnu/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;
+  }
+
+
+}
+# 1535 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+ }
+    }
+
+namespace __cxx11 {
+# 1665 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(); }
+# 1703 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      explicit
+      numpunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_numpunct(); }
+# 1717 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      explicit
+      numpunct(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(__cloc); }
+# 1731 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+# 1744 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+# 1775 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      string
+      grouping() const
+      { return this->do_grouping(); }
+# 1788 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      string_type
+      truename() const
+      { return this->do_truename(); }
+# 1801 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      string_type
+      falsename() const
+      { return this->do_falsename(); }
+
+    protected:
+
+      virtual
+      ~numpunct();
+# 1818 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+# 1830 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+# 1843 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+# 1856 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual string_type
+      do_truename() const
+      { return _M_data->_M_truename; }
+# 1869 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+   }
+      }
+
+
+      explicit
+      numpunct_byname(const string& __s, size_t __refs = 0)
+      : numpunct_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~numpunct_byname() { }
+    };
+
+}
+
+
+# 1947 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+  template<typename _CharT, typename _InIter>
+    class num_get : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+
+
+      static locale::id id;
+# 1968 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      explicit
+      num_get(size_t __refs = 0) : facet(__refs) { }
+# 1994 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, bool& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2031 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned short& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned int& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2091 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, float& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2134 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, void*& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+    protected:
+
+      virtual ~num_get() { }
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iter_type
+      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         string&) const;
+
+      template<typename _ValueT>
+ __attribute ((__abi_tag__ ("cxx11")))
+ iter_type
+ _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         _ValueT&) const;
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
+ _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
+ {
+   int __ret = -1;
+   if (__len <= 10)
+     {
+       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
+  __ret = __c - _CharT2('0');
+     }
+   else
+     {
+       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
+  __ret = __c - _CharT2('0');
+       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
+  __ret = 10 + (__c - _CharT2('a'));
+       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
+  __ret = 10 + (__c - _CharT2('A'));
+     }
+   return __ret;
+ }
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
+          int>::__type
+ _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
+ {
+   int __ret = -1;
+   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
+   if (__q)
+     {
+       __ret = __q - __zero;
+       if (__ret > 15)
+  __ret -= 6;
+     }
+   return __ret;
+ }
+# 2207 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned short& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned int& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      double&) const;
+
+
+
+
+
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      long double&) const;
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
+# 2270 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id num_get<_CharT, _InIter>::id;
+# 2288 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+  template<typename _CharT, typename _OutIter>
+    class num_put : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+
+
+      static locale::id id;
+# 2309 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      explicit
+      num_put(size_t __refs = 0) : facet(__refs) { }
+# 2327 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2369 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2432 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   long double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2457 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   const void* __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+    protected:
+      template<typename _ValueT>
+ iter_type
+ _M_insert_float(iter_type, ios_base& __io, char_type __fill,
+   char __mod, _ValueT __v) const;
+
+      void
+      _M_group_float(const char* __grouping, size_t __grouping_size,
+       char_type __sep, const char_type* __p, char_type* __new,
+       char_type* __cs, int& __len) const;
+
+      template<typename _ValueT>
+ iter_type
+ _M_insert_int(iter_type, ios_base& __io, char_type __fill,
+        _ValueT __v) const;
+
+      void
+      _M_group_int(const char* __grouping, size_t __grouping_size,
+     char_type __sep, ios_base& __io, char_type* __new,
+     char_type* __cs, int& __len) const;
+
+      void
+      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
+      char_type* __new, const char_type* __cs, int& __len) const;
+
+
+      virtual
+      ~num_put() { };
+# 2505 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 bool
+    isblank(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.tcc" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.tcc" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+    {
+      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+
+      char* __grouping = 0;
+      _CharT* __truename = 0;
+      _CharT* __falsename = 0;
+      try
+ {
+   const string& __g = __np.grouping();
+   _M_grouping_size = __g.size();
+   __grouping = new char[_M_grouping_size];
+   __g.copy(__grouping, _M_grouping_size);
+   _M_use_grouping = (_M_grouping_size
+        && static_cast<signed char>(__grouping[0]) > 0
+        && (__grouping[0]
+     != __gnu_cxx::__numeric_traits<char>::__max));
+
+   const basic_string<_CharT>& __tn = __np.truename();
+   _M_truename_size = __tn.size();
+   __truename = new _CharT[_M_truename_size];
+   __tn.copy(__truename, _M_truename_size);
+
+   const basic_string<_CharT>& __fn = __np.falsename();
+   _M_falsename_size = __fn.size();
+   __falsename = new _CharT[_M_falsename_size];
+   __fn.copy(__falsename, _M_falsename_size);
+
+   _M_decimal_point = __np.decimal_point();
+   _M_thousands_sep = __np.thousands_sep();
+
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(__num_base::_S_atoms_out,
+       __num_base::_S_atoms_out
+       + __num_base::_S_oend, _M_atoms_out);
+   __ct.widen(__num_base::_S_atoms_in,
+       __num_base::_S_atoms_in
+       + __num_base::_S_iend, _M_atoms_in);
+
+   _M_grouping = __grouping;
+   _M_truename = __truename;
+   _M_falsename = __falsename;
+   _M_allocated = true;
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __truename;
+   delete [] __falsename;
+   throw;
+ }
+    }
+# 139 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.tcc" 3
+  __attribute__ ((__pure__)) bool
+  __verify_grouping(const char* __grouping, size_t __grouping_size,
+      const string& __grouping_tmp) throw ();
+
+
+
+  template<typename _CharT, typename _InIter>
+    __attribute ((__abi_tag__ ("cxx11")))
+    _InIter
+    num_get<_CharT, _InIter>::
+    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, string& __xtrc) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      typedef __numpunct_cache<_CharT> __cache_type;
+      __use_cache<__cache_type> __uc;
+      const locale& __loc = __io._M_getloc();
+      const __cache_type* __lc = __uc(__loc);
+      const _CharT* __lit = __lc->_M_atoms_in;
+      char_type __c = char_type();
+
+
+      bool __testeof = __beg == __end;
+
+
+      if (!__testeof)
+ {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+     {
+       __xtrc += __plus ? '+' : '-';
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ }
+
+
+      bool __found_mantissa = false;
+      int __sep_pos = 0;
+      while (!__testeof)
+ {
+   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       || __c == __lc->_M_decimal_point)
+     break;
+   else if (__c == __lit[__num_base::_S_izero])
+     {
+       if (!__found_mantissa)
+  {
+    __xtrc += '0';
+    __found_mantissa = true;
+  }
+       ++__sep_pos;
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+   else
+     break;
+ }
+
+
+      bool __found_dec = false;
+      bool __found_sci = false;
+      string __found_grouping;
+      if (__lc->_M_use_grouping)
+ __found_grouping.reserve(32);
+      const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+      if (!__lc->_M_allocated)
+
+ while (!__testeof)
+   {
+     const int __digit = _M_find(__lit_zero, 10, __c);
+     if (__digit != -1)
+       {
+  __xtrc += '0' + __digit;
+  __found_mantissa = true;
+       }
+     else if (__c == __lc->_M_decimal_point
+       && !__found_dec && !__found_sci)
+       {
+  __xtrc += '.';
+  __found_dec = true;
+       }
+     else if ((__c == __lit[__num_base::_S_ie]
+        || __c == __lit[__num_base::_S_iE])
+       && !__found_sci && __found_mantissa)
+       {
+
+  __xtrc += 'e';
+  __found_sci = true;
+
+
+  if (++__beg != __end)
+    {
+      __c = *__beg;
+      const bool __plus = __c == __lit[__num_base::_S_iplus];
+      if (__plus || __c == __lit[__num_base::_S_iminus])
+        __xtrc += __plus ? '+' : '-';
+      else
+        continue;
+    }
+  else
+    {
+      __testeof = true;
+      break;
+    }
+       }
+     else
+       break;
+
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+      else
+ while (!__testeof)
+   {
+
+
+     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+
+
+      if (__sep_pos)
+        {
+   __found_grouping += static_cast<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>
+      __attribute ((__abi_tag__ ("cxx11")))
+      _InIter
+      num_get<_CharT, _InIter>::
+      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, _ValueT& __v) const
+      {
+        typedef char_traits<_CharT> __traits_type;
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_in;
+ char_type __c = char_type();
+
+
+ const ios_base::fmtflags __basefield = __io.flags()
+                                        & ios_base::basefield;
+ const bool __oct = __basefield == ios_base::oct;
+ int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
+
+
+ bool __testeof = __beg == __end;
+
+
+ bool __negative = false;
+ if (!__testeof)
+   {
+     __c = *__beg;
+     __negative = __c == __lit[__num_base::_S_iminus];
+     if ((__negative || __c == __lit[__num_base::_S_iplus])
+  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  && !(__c == __lc->_M_decimal_point))
+       {
+  if (++__beg != __end)
+    __c = *__beg;
+  else
+    __testeof = true;
+       }
+   }
+
+
+
+ bool __found_zero = false;
+ int __sep_pos = 0;
+ while (!__testeof)
+   {
+     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  || __c == __lc->_M_decimal_point)
+       break;
+     else if (__c == __lit[__num_base::_S_izero]
+       && (!__found_zero || __base == 10))
+       {
+  __found_zero = true;
+  ++__sep_pos;
+  if (__basefield == 0)
+    __base = 8;
+  if (__base == 8)
+    __sep_pos = 0;
+       }
+     else if (__found_zero
+       && (__c == __lit[__num_base::_S_ix]
+    || __c == __lit[__num_base::_S_iX]))
+       {
+  if (__basefield == 0)
+    __base = 16;
+  if (__base == 16)
+    {
+      __found_zero = false;
+      __sep_pos = 0;
+    }
+  else
+    break;
+       }
+     else
+       break;
+
+     if (++__beg != __end)
+       {
+  __c = *__beg;
+  if (!__found_zero)
+    break;
+       }
+     else
+       __testeof = true;
+   }
+
+
+
+ const size_t __len = (__base == 16 ? __num_base::_S_iend
+         - __num_base::_S_izero : __base);
+
+
+ string __found_grouping;
+ if (__lc->_M_use_grouping)
+   __found_grouping.reserve(32);
+ bool __testfail = false;
+ bool __testoverflow = false;
+ const __unsigned_type __max =
+   (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+   ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
+   : __gnu_cxx::__numeric_traits<_ValueT>::__max;
+ const __unsigned_type __smax = __max / __base;
+ __unsigned_type __result = 0;
+ int __digit = 0;
+ const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+ if (!__lc->_M_allocated)
+
+   while (!__testeof)
+     {
+       __digit = _M_find(__lit_zero, __len, __c);
+       if (__digit == -1)
+  break;
+
+       if (__result > __smax)
+  __testoverflow = true;
+       else
+  {
+    __result *= __base;
+    __testoverflow |= __result > __max - __digit;
+    __result += __digit;
+    ++__sep_pos;
+  }
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ else
+   while (!__testeof)
+     {
+
+
+       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  {
+
+
+    if (__sep_pos)
+      {
+        __found_grouping += static_cast<char>(__sep_pos);
+        __sep_pos = 0;
+      }
+    else
+      {
+        __testfail = true;
+        break;
+      }
+  }
+       else if (__c == __lc->_M_decimal_point)
+  break;
+       else
+  {
+    const char_type* __q =
+      __traits_type::find(__lit_zero, __len, __c);
+    if (!__q)
+      break;
+
+    __digit = __q - __lit_zero;
+    if (__digit > 15)
+      __digit -= 6;
+    if (__result > __smax)
+      __testoverflow = true;
+    else
+      {
+        __result *= __base;
+        __testoverflow |= __result > __max - __digit;
+        __result += __digit;
+        ++__sep_pos;
+      }
+  }
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+
+
+
+ if (__found_grouping.size())
+   {
+
+     __found_grouping += static_cast<char>(__sep_pos);
+
+     if (!std::__verify_grouping(__lc->_M_grouping,
+     __lc->_M_grouping_size,
+     __found_grouping))
+       __err = ios_base::failbit;
+   }
+
+
+
+ if ((!__sep_pos && !__found_zero && !__found_grouping.size())
+     || __testfail)
+   {
+     __v = 0;
+     __err = ios_base::failbit;
+   }
+ else if (__testoverflow)
+   {
+     if (__negative
+  && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+       __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
+     else
+       __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
+     __err = ios_base::failbit;
+   }
+ else
+   __v = __negative ? -__result : __result;
+
+ if (__testeof)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, bool& __v) const
+    {
+      if (!(__io.flags() & ios_base::boolalpha))
+        {
+
+
+
+   long __l = -1;
+          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
+   if (__l == 0 || __l == 1)
+     __v = bool(__l);
+   else
+     {
+
+
+       __v = true;
+       __err = ios_base::failbit;
+       if (__beg == __end)
+  __err |= ios_base::eofbit;
+     }
+        }
+      else
+        {
+
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+
+   bool __testf = true;
+   bool __testt = true;
+   bool __donef = __lc->_M_falsename_size == 0;
+   bool __donet = __lc->_M_truename_size == 0;
+   bool __testeof = false;
+   size_t __n = 0;
+   while (!__donef || !__donet)
+     {
+       if (__beg == __end)
+  {
+    __testeof = true;
+    break;
+  }
+
+       const char_type __c = *__beg;
+
+       if (!__donef)
+  __testf = __c == __lc->_M_falsename[__n];
+
+       if (!__testf && __donet)
+  break;
+
+       if (!__donet)
+  __testt = __c == __lc->_M_truename[__n];
+
+       if (!__testt && __donef)
+  break;
+
+       if (!__testt && !__testf)
+  break;
+
+       ++__n;
+       ++__beg;
+
+       __donef = !__testf || __n >= __lc->_M_falsename_size;
+       __donet = !__testt || __n >= __lc->_M_truename_size;
+     }
+   if (__testf && __n == __lc->_M_falsename_size && __n)
+     {
+       __v = false;
+       if (__testt && __n == __lc->_M_truename_size)
+  __err = ios_base::failbit;
+       else
+  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else if (__testt && __n == __lc->_M_truename_size && __n)
+     {
+       __v = true;
+       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else
+     {
+
+
+       __v = false;
+       __err = ios_base::failbit;
+       if (__testeof)
+  __err |= ios_base::eofbit;
+     }
+ }
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, float& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+# 735 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 971 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+
+
+
+ const bool __use_prec =
+   (__io.flags() & ios_base::floatfield) != ios_base::floatfield;
+
+
+
+ int __cs_size = __max_digits * 3;
+ char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+ if (__use_prec)
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __prec, __v);
+ else
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __v);
+
+
+ if (__len >= __cs_size)
+   {
+     __cs_size = __len + 1;
+     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+     if (__use_prec)
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __prec, __v);
+     else
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __v);
+   }
+# 1044 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 1169 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+    long double __v) const
+    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+           const void* __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      const ios_base::fmtflags __fmt = ~(ios_base::basefield
+      | ios_base::uppercase);
+      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+
+      __s = _M_insert_int(__s, __io, __fill,
+     reinterpret_cast<_UIntPtrType>(__v));
+      __io.flags(__flags);
+      return __s;
+    }
+
+
+# 1206 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 __cxx11:: numpunct<char>;
+  extern template class __cxx11:: 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 __cxx11:: numpunct<wchar_t>;
+  extern template class __cxx11:: numpunct_byname<wchar_t>;
+  extern template class num_get<wchar_t>;
+  extern template class num_put<wchar_t>;
+  extern template class ctype_byname<wchar_t>;
+
+  extern template
+    const ctype<wchar_t>&
+    use_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    const numpunct<wchar_t>&
+    use_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    const num_put<wchar_t>&
+    use_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    const num_get<wchar_t>&
+    use_facet<num_get<wchar_t> >(const locale&);
+
+ extern template
+    bool
+    has_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_get<wchar_t> >(const locale&);
+
+
+
+
+}
+# 2652 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/locale_facets.h" 2 3
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+    }
+# 66 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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:
+# 117 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      explicit operator bool() const
+      { return !this->fail(); }
+
+
+
+
+
+      bool
+      operator!() const
+      { return this->fail(); }
+# 136 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      iostate
+      rdstate() const
+      { return _M_streambuf_state; }
+# 147 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      void
+      clear(iostate __state = goodbit);
+
+
+
+
+
+
+
+      void
+      setstate(iostate __state)
+      { this->clear(this->rdstate() | __state); }
+
+
+
+
+      void
+      _M_setstate(iostate __state)
+      {
+
+
+ _M_streambuf_state |= __state;
+ if (this->exceptions() & __state)
+   throw;
+      }
+
+
+
+
+
+
+
+      bool
+      good() const
+      { return this->rdstate() == 0; }
+
+
+
+
+
+
+
+      bool
+      eof() const
+      { return (this->rdstate() & eofbit) != 0; }
+# 200 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      bool
+      fail() const
+      { return (this->rdstate() & (badbit | failbit)) != 0; }
+
+
+
+
+
+
+
+      bool
+      bad() const
+      { return (this->rdstate() & badbit) != 0; }
+# 221 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      iostate
+      exceptions() const
+      { return _M_exception; }
+# 256 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      void
+      exceptions(iostate __except)
+      {
+        _M_exception = __except;
+        this->clear(_M_streambuf_state);
+      }
+
+
+
+
+
+
+
+      explicit
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
+      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
+ _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { this->init(__sb); }
+
+
+
+
+
+
+
+      virtual
+      ~basic_ios() { }
+# 294 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie() const
+      { return _M_tie; }
+# 306 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie(basic_ostream<_CharT, _Traits>* __tiestr)
+      {
+        basic_ostream<_CharT, _Traits>* __old = _M_tie;
+        _M_tie = __tiestr;
+        return __old;
+      }
+
+
+
+
+
+
+
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf() const
+      { return _M_streambuf; }
+# 346 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+# 360 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      basic_ios&
+      copyfmt(const basic_ios& __rhs);
+
+
+
+
+
+
+
+      char_type
+      fill() const
+      {
+ if (!_M_fill_init)
+   {
+     _M_fill = this->widen(' ');
+     _M_fill_init = true;
+   }
+ return _M_fill;
+      }
+# 389 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      char_type
+      fill(char_type __ch)
+      {
+ char_type __old = this->fill();
+ _M_fill = __ch;
+ return __old;
+      }
+# 409 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      locale
+      imbue(const locale& __loc);
+# 429 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
+# 448 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+
+
+      basic_ios(const basic_ios&) = delete;
+      basic_ios& operator=(const basic_ios&) = delete;
+
+      void
+      move(basic_ios& __rhs)
+      {
+ ios_base::_M_move(__rhs);
+ _M_cache_locale(_M_ios_locale);
+ this->tie(__rhs.tie(nullptr));
+ _M_fill = __rhs._M_fill;
+ _M_fill_init = __rhs._M_fill_init;
+ _M_streambuf = nullptr;
+      }
+
+      void
+      move(basic_ios&& __rhs)
+      { this->move(__rhs); }
+
+      void
+      swap(basic_ios& __rhs) noexcept
+      {
+ ios_base::_M_swap(__rhs);
+ _M_cache_locale(_M_ios_locale);
+ __rhs._M_cache_locale(__rhs._M_ios_locale);
+ std::swap(_M_tie, __rhs._M_tie);
+ std::swap(_M_fill, __rhs._M_fill);
+ std::swap(_M_fill_init, __rhs._M_fill_init);
+      }
+
+      void
+      set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+      { _M_streambuf = __sb; }
+
+
+      void
+      _M_cache_locale(const locale& __loc);
+    };
+
+
+}
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.tcc" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.tcc" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::clear(iostate __state)
+    {
+      if (this->rdbuf())
+ _M_streambuf_state = __state;
+      else
+   _M_streambuf_state = __state | badbit;
+      if (this->exceptions() & this->rdstate())
+ __throw_ios_failure(("basic_ios::clear"));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_streambuf<_CharT, _Traits>*
+    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
+      _M_streambuf = __sb;
+      this->clear();
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ios<_CharT, _Traits>&
+    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
+    {
+
+
+      if (this != &__rhs)
+ {
+
+
+
+
+   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
+                      _M_local_word : new _Words[__rhs._M_word_size];
+
+
+   _Callback_list* __cb = __rhs._M_callbacks;
+   if (__cb)
+     __cb->_M_add_reference();
+   _M_call_callbacks(erase_event);
+   if (_M_word != _M_local_word)
+     {
+       delete [] _M_word;
+       _M_word = 0;
+     }
+   _M_dispose_callbacks();
+
+
+   _M_callbacks = __cb;
+   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
+     __words[__i] = __rhs._M_word[__i];
+   _M_word = __words;
+   _M_word_size = __rhs._M_word_size;
+
+   this->flags(__rhs.flags());
+   this->width(__rhs.width());
+   this->precision(__rhs.precision());
+   this->tie(__rhs.tie());
+   this->fill(__rhs.fill());
+   _M_ios_locale = __rhs.getloc();
+   _M_cache_locale(_M_ios_locale);
+
+   _M_call_callbacks(copyfmt_event);
+
+
+   this->exceptions(__rhs.exceptions());
+ }
+      return *this;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    locale
+    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
+    {
+      locale __old(this->getloc());
+      ios_base::imbue(__loc);
+      _M_cache_locale(__loc);
+      if (this->rdbuf() != 0)
+ this->rdbuf()->pubimbue(__loc);
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+
+      ios_base::_M_init();
+
+
+      _M_cache_locale(_M_ios_locale);
+# 146 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>;
+
+
+
+
+}
+# 517 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/basic_ios.h" 2 3
+# 45 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ios" 2 3
+# 39 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 57 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+             __num_put_type;
+      typedef ctype<_CharT> __ctype_type;
+# 83 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      explicit
+      basic_ostream(__streambuf_type* __sb)
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_ostream() { }
+
+
+      class sentry;
+      friend class sentry;
+# 107 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      __ostream_type&
+      operator<<(__ostream_type& (*__pf)(__ostream_type&))
+      {
+
+
+
+ return __pf(*this);
+      }
+
+      __ostream_type&
+      operator<<(__ios_type& (*__pf)(__ios_type&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+
+      __ostream_type&
+      operator<<(ios_base& (*__pf) (ios_base&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+# 165 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 219 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 244 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      __ostream_type&
+      operator<<(const void* __p)
+      { return _M_insert(__p); }
+# 269 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      __ostream_type&
+      operator<<(__streambuf_type* __sb);
+# 302 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      __ostream_type&
+      put(char_type __c);
+
+
+
+
+
+
+      void
+      _M_write(const char_type* __s, streamsize __n)
+      {
+ const streamsize __put = this->rdbuf()->sputn(__s, __n);
+ if (__put != __n)
+   this->setstate(ios_base::badbit);
+      }
+# 334 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      __ostream_type&
+      write(const char_type* __s, streamsize __n);
+# 347 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      __ostream_type&
+      flush();
+# 357 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      pos_type
+      tellp();
+# 368 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      __ostream_type&
+      seekp(pos_type);
+# 380 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+       __ostream_type&
+      seekp(off_type, ios_base::seekdir);
+
+    protected:
+      basic_ostream()
+      { this->init(0); }
+
+
+
+      basic_ostream(basic_iostream<_CharT, _Traits>&) { }
+
+      basic_ostream(const basic_ostream&) = delete;
+
+      basic_ostream(basic_ostream&& __rhs)
+      : __ios_type()
+      { __ios_type::move(__rhs); }
+
+
+
+      basic_ostream& operator=(const basic_ostream&) = delete;
+
+      basic_ostream&
+      operator=(basic_ostream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+
+      void
+      swap(basic_ostream& __rhs)
+      { __ios_type::swap(__rhs); }
+
+
+      template<typename _ValueT>
+ __ostream_type&
+ _M_insert(_ValueT __v);
+    };
+# 425 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+  template <typename _CharT, typename _Traits>
+    class basic_ostream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+      basic_ostream<_CharT, _Traits>& _M_os;
+
+    public:
+# 444 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      explicit
+      sentry(basic_ostream<_CharT, _Traits>& __os);
+# 454 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+   }
+      }
+# 473 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+      explicit
+
+      operator bool() const
+      { return _M_ok; }
+    };
+# 495 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)); }
+# 537 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)); }
+# 588 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    endl(basic_ostream<_CharT, _Traits>& __os)
+    { return flush(__os.put(__os.widen('\n'))); }
+# 600 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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(); }
+# 626 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 3
+  template<typename _CharT, typename _Traits, typename _Tp>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
+    {
+      __os << __x;
+      return __os;
+    }
+
+
+
+}
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ostream.tcc" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/ostream.tcc" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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*);
+
+
+
+
+}
+# 639 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ostream" 2 3
+# 65 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iterator" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 1 3
+# 36 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+       
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 57 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+        __num_get_type;
+      typedef ctype<_CharT> __ctype_type;
+
+    protected:
+
+
+
+
+
+      streamsize _M_gcount;
+
+    public:
+
+
+
+
+
+
+
+      explicit
+      basic_istream(__streambuf_type* __sb)
+      : _M_gcount(streamsize(0))
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_istream()
+      { _M_gcount = streamsize(0); }
+
+
+      class sentry;
+      friend class sentry;
+# 119 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      operator>>(__istream_type& (*__pf)(__istream_type&))
+      { return __pf(*this); }
+
+      __istream_type&
+      operator>>(__ios_type& (*__pf)(__ios_type&))
+      {
+ __pf(*this);
+ return *this;
+      }
+
+      __istream_type&
+      operator>>(ios_base& (*__pf)(ios_base&))
+      {
+ __pf(*this);
+ return *this;
+      }
+# 167 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      operator>>(bool& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(short& __n);
+
+      __istream_type&
+      operator>>(unsigned short& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(int& __n);
+
+      __istream_type&
+      operator>>(unsigned int& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long& __n)
+      { return _M_extract(__n); }
+
+
+      __istream_type&
+      operator>>(long long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long long& __n)
+      { return _M_extract(__n); }
+# 213 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      operator>>(float& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(double& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(long double& __f)
+      { return _M_extract(__f); }
+# 234 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      operator>>(void*& __p)
+      { return _M_extract(__p); }
+# 258 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      operator>>(__streambuf_type* __sb);
+# 268 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      streamsize
+      gcount() const
+      { return _M_gcount; }
+# 301 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      int_type
+      get();
+# 315 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      get(char_type& __c);
+# 342 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n, char_type __delim);
+# 353 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n)
+      { return this->get(__s, __n, this->widen('\n')); }
+# 376 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb, char_type __delim);
+# 386 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb)
+      { return this->get(__sb, this->widen('\n')); }
+# 415 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n, char_type __delim);
+# 426 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n)
+      { return this->getline(__s, __n, this->widen('\n')); }
+# 450 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      ignore(streamsize __n, int_type __delim);
+
+      __istream_type&
+      ignore(streamsize __n);
+
+      __istream_type&
+      ignore();
+# 467 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      int_type
+      peek();
+# 485 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      read(char_type* __s, streamsize __n);
+# 504 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      streamsize
+      readsome(char_type* __s, streamsize __n);
+# 521 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      putback(char_type __c);
+# 537 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      unget();
+# 555 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      int
+      sync();
+# 570 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      pos_type
+      tellg();
+# 585 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      seekg(pos_type);
+# 601 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      __istream_type&
+      seekg(off_type, ios_base::seekdir);
+
+
+    protected:
+      basic_istream()
+      : _M_gcount(streamsize(0))
+      { this->init(0); }
+
+
+      basic_istream(const basic_istream&) = delete;
+
+      basic_istream(basic_istream&& __rhs)
+      : __ios_type(), _M_gcount(__rhs._M_gcount)
+      {
+ __ios_type::move(__rhs);
+ __rhs._M_gcount = 0;
+      }
+
+
+
+      basic_istream& operator=(const basic_istream&) = delete;
+
+      basic_istream&
+      operator=(basic_istream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+
+      void
+      swap(basic_istream& __rhs)
+      {
+ __ios_type::swap(__rhs);
+ std::swap(_M_gcount, __rhs._M_gcount);
+      }
+
+
+      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);
+# 685 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+
+    public:
+
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::__ctype_type __ctype_type;
+      typedef typename _Traits::int_type __int_type;
+# 721 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      explicit
+      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
+# 732 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+      explicit
+
+      operator bool() const
+      { return _M_ok; }
+    };
+# 750 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)); }
+# 792 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)); }
+# 823 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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() { }
+
+
+      basic_iostream(const basic_iostream&) = delete;
+
+      basic_iostream(basic_iostream&& __rhs)
+      : __istream_type(std::move(__rhs)), __ostream_type(*this)
+      { }
+
+
+
+      basic_iostream& operator=(const basic_iostream&) = delete;
+
+      basic_iostream&
+      operator=(basic_iostream&& __rhs)
+      {
+ swap(__rhs);
+ return *this;
+      }
+
+      void
+      swap(basic_iostream& __rhs)
+      { __istream_type::swap(__rhs); }
+
+    };
+# 906 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __is);
+# 922 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 3
+  template<typename _CharT, typename _Traits, typename _Tp>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
+    {
+      __is >> __x;
+      return __is;
+    }
+
+
+
+}
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/istream.tcc" 1 3
+# 37 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/istream.tcc" 3
+       
+# 38 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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();
+# 513 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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>;
+
+
+
+
+}
+# 935 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/istream" 2 3
+# 66 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iterator" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stream_iterator.h" 1 3
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stream_iterator.h" 3
+       
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/iterator" 2 3
+# 54 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h" 2
+# 66 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h"
+
+
+
+
+
+
+
+
+# 73 "../../include/QtCore/../../../../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
+    {
+        do { } while ((false) && (ba.ref.isStatic()));
+        return const_cast<QByteArrayData *>(&ba);
+    }
+};
+
+struct QByteArrayDataPtr
+{
+    QByteArrayData *ptr;
+};
+# 167 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h"
+class __attribute__((visibility("default"))) QByteArray
+{
+private:
+    typedef QTypedArrayData<char> Data;
+
+public:
+    enum Base64Option {
+        Base64Encoding = 0,
+        Base64UrlEncoding = 1,
+
+        KeepTrailingEquals = 0,
+        OmitTrailingEquals = 2
+    };
+    typedef QFlags<Base64Option> Base64Options;
+
+    inline QByteArray() noexcept;
+    QByteArray(const char *, int size = -1);
+    QByteArray(int size, char c);
+    QByteArray(int size, Qt::Initialization);
+    inline QByteArray(const QByteArray &) noexcept;
+    inline ~QByteArray();
+
+    QByteArray &operator=(const QByteArray &) noexcept;
+    QByteArray &operator=(const char *str);
+
+    inline QByteArray(QByteArray && other) noexcept : d(other.d) { other.d = Data::sharedNull(); }
+    inline QByteArray &operator=(QByteArray &&other) noexcept
+    { qSwap(d, other.d); return *this; }
+
+
+    inline void swap(QByteArray &other) noexcept
+    { 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 __attribute__ ((__warn_unused_result__));
+    QByteArray right(int len) const __attribute__ ((__warn_unused_result__));
+    QByteArray mid(int index, int len = -1) const __attribute__ ((__warn_unused_result__));
+
+    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);
+
+
+
+
+           
+
+
+
+
+    inline __attribute__((always_inline)) QByteArray toLower() const &
+    { return toLower_helper(*this); }
+    inline __attribute__((always_inline)) QByteArray toLower() &&
+    { return toLower_helper(*this); }
+    inline __attribute__((always_inline)) QByteArray toUpper() const &
+    { return toUpper_helper(*this); }
+    inline __attribute__((always_inline)) QByteArray toUpper() &&
+    { return toUpper_helper(*this); }
+    inline __attribute__((always_inline)) QByteArray trimmed() const &
+    { return trimmed_helper(*this); }
+    inline __attribute__((always_inline)) QByteArray trimmed() &&
+    { return trimmed_helper(*this); }
+    inline __attribute__((always_inline)) QByteArray simplified() const &
+    { return simplified_helper(*this); }
+    inline __attribute__((always_inline)) QByteArray simplified() &&
+    { return simplified_helper(*this); }
+
+           
+# 291 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h"
+    QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const __attribute__ ((__warn_unused_result__));
+    QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const __attribute__ ((__warn_unused_result__));
+
+    QByteArray &prepend(char c);
+    QByteArray &prepend(int count, 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(int count, 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, int count, 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 __attribute__ ((__warn_unused_result__));
+# 341 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h"
+    inline __attribute__ ((__deprecated__)) bool operator==(const QString &s2) const;
+    inline __attribute__ ((__deprecated__)) bool operator!=(const QString &s2) const;
+    inline __attribute__ ((__deprecated__)) bool operator<(const QString &s2) const;
+    inline __attribute__ ((__deprecated__)) bool operator>(const QString &s2) const;
+    inline __attribute__ ((__deprecated__)) bool operator<=(const QString &s2) const;
+    inline __attribute__ ((__deprecated__)) bool operator>=(const QString &s2) const;
+
+
+    short toShort(bool *ok = nullptr, int base = 10) const;
+    ushort toUShort(bool *ok = nullptr, int base = 10) const;
+    int toInt(bool *ok = nullptr, int base = 10) const;
+    uint toUInt(bool *ok = nullptr, int base = 10) const;
+    long toLong(bool *ok = nullptr, int base = 10) const;
+    ulong toULong(bool *ok = nullptr, int base = 10) const;
+    qlonglong toLongLong(bool *ok = nullptr, int base = 10) const;
+    qulonglong toULongLong(bool *ok = nullptr, int base = 10) const;
+    float toFloat(bool *ok = nullptr) const;
+    double toDouble(bool *ok = nullptr) const;
+    QByteArray toBase64(Base64Options options) 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) __attribute__ ((__warn_unused_result__));
+    static QByteArray number(uint, int base = 10) __attribute__ ((__warn_unused_result__));
+    static QByteArray number(qlonglong, int base = 10) __attribute__ ((__warn_unused_result__));
+    static QByteArray number(qulonglong, int base = 10) __attribute__ ((__warn_unused_result__));
+    static QByteArray number(double, char f = 'g', int prec = 6) __attribute__ ((__warn_unused_result__));
+    static QByteArray fromRawData(const char *, int size) __attribute__ ((__warn_unused_result__));
+    static QByteArray fromBase64(const QByteArray &base64, Base64Options options) __attribute__ ((__warn_unused_result__));
+    static QByteArray fromBase64(const QByteArray &base64) __attribute__ ((__warn_unused_result__));
+    static QByteArray fromHex(const QByteArray &hexEncoded) __attribute__ ((__warn_unused_result__));
+    static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%') __attribute__ ((__warn_unused_result__));
+# 400 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h"
+    typedef char *iterator;
+    typedef const char *const_iterator;
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    inline iterator begin();
+    inline const_iterator begin() const;
+    inline const_iterator cbegin() const;
+    inline const_iterator constBegin() const;
+    inline iterator end();
+    inline const_iterator end() const;
+    inline const_iterator cend() const;
+    inline const_iterator constEnd() const;
+    reverse_iterator rbegin() { return reverse_iterator(end()); }
+    reverse_iterator rend() { return reverse_iterator(begin()); }
+    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }
+    const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }
+
+
+    typedef int size_type;
+    typedef qptrdiff difference_type;
+    typedef const char & const_reference;
+    typedef char & reference;
+    typedef char *pointer;
+    typedef const char *const_pointer;
+    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);
+
+    static inline QByteArray fromStdString(const std::string &s);
+    inline std::string toStdString() const;
+
+    inline int count() const { return d->size; }
+    int length() const { return d->size; }
+    bool isNull() const;
+
+    inline QByteArray(QByteArrayDataPtr dd)
+        : d(static_cast<Data *>(dd.ptr))
+    {
+    }
+
+private:
+    operator QNoImplicitBoolCast() const;
+    Data *d;
+    void reallocData(uint alloc, Data::AllocationOptions options);
+    void expand(int i);
+    QByteArray nulTerminated() const;
+
+    static QByteArray toLower_helper(const QByteArray &a);
+    static QByteArray toLower_helper(QByteArray &a);
+    static QByteArray toUpper_helper(const QByteArray &a);
+    static QByteArray toUpper_helper(QByteArray &a);
+    static QByteArray trimmed_helper(const QByteArray &a);
+    static QByteArray trimmed_helper(QByteArray &a);
+    static QByteArray simplified_helper(const QByteArray &a);
+    static QByteArray simplified_helper(QByteArray &a);
+
+    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; }
+};
+
+constexpr inline QFlags<QByteArray::Base64Options::enum_type> operator|(QByteArray::Base64Options::enum_type f1, QByteArray::Base64Options::enum_type f2) noexcept { return QFlags<QByteArray::Base64Options::enum_type>(f1) | f2; } constexpr inline QFlags<QByteArray::Base64Options::enum_type> operator|(QByteArray::Base64Options::enum_type f1, QFlags<QByteArray::Base64Options::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QByteArray::Base64Options::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+
+inline QByteArray::QByteArray() noexcept : 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
+{ do { } while ((false) && (uint(i) < uint(size()))); return d->data()[i]; }
+inline char QByteArray::operator[](int i) const
+{ do { } while ((false) && (uint(i) < uint(size()))); return d->data()[i]; }
+inline char QByteArray::operator[](uint i) const
+{ do { } while ((false) && (i < uint(size()))); 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->offset != sizeof(QByteArrayData))) reallocData(uint(d->size) + 1u, d->detachFlags()); }
+inline bool QByteArray::isDetached() const
+{ return !d->ref.isShared(); }
+inline QByteArray::QByteArray(const QByteArray &a) noexcept : d(a.d)
+{ d->ref.ref(); }
+
+inline int QByteArray::capacity() const
+{ return d->alloc ? d->alloc - 1 : 0; }
+
+inline void QByteArray::reserve(int asize)
+{
+    if (d->ref.isShared() || uint(asize) + 1u > d->alloc) {
+        reallocData(qMax(uint(size()), uint(asize)) + 1u, d->detachFlags() | Data::CapacityReserved);
+    } else {
+
+
+        d->capacityReserved = true;
+    }
+}
+
+inline void QByteArray::squeeze()
+{
+    if (d->ref.isShared() || uint(d->size) + 1u < d->alloc) {
+        reallocData(uint(d->size) + 1u, d->detachFlags() & ~Data::CapacityReserved);
+    } else {
+
+
+        d->capacityReserved = false;
+    }
+}
+
+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)
+{ do { } while ((false) && (i >= 0)); 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::append(int n, char ch)
+{ return insert(d->size, n, ch); }
+inline QByteArray &QByteArray::prepend(int n, char ch)
+{ return insert(0, n, ch); }
+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; }
+# 655 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h"
+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 base == 10 ? setNum(qlonglong(n), base) : setNum(qulonglong(ushort(n)), base); }
+inline QByteArray &QByteArray::setNum(ushort n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QByteArray &QByteArray::setNum(int n, int base)
+{ return base == 10 ? setNum(qlonglong(n), base) : setNum(qulonglong(uint(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); }
+
+inline std::string QByteArray::toStdString() const
+{ return std::string(constData(), length()); }
+
+inline QByteArray QByteArray::fromStdString(const std::string &s)
+{ return QByteArray(s.data(), int(s.size())); }
+
+
+__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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QByteArray)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QByteArray >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QByteArray) }; static inline const char *name() { return "QByteArray"; } }; inline void swap(QByteArray &value1, QByteArray &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }
+
+
+
+
+# 1 "../../include/QtCore/qstring.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h" 1
+# 1 "../../include/QtCore/qstring.h" 2
+# 701 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearray.h" 2
+# 1 "../../include/QtCore/qbytearray.h" 2
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h" 2
+# 1 "../../include/QtCore/qrefcount.h" 1
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h" 2
+# 1 "../../include/QtCore/qnamespace.h" 1
+# 52 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h" 2
+# 78 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+
+
+class QCharRef;
+class QRegExp;
+class QRegularExpression;
+class QRegularExpressionMatch;
+class QString;
+class QStringList;
+class QTextCodec;
+class QStringRef;
+template <typename T> class QVector;
+
+class QLatin1String
+{
+public:
+    constexpr inline QLatin1String() noexcept : m_size(0), m_data(nullptr) {}
+    constexpr inline explicit QLatin1String(const char *s) noexcept : m_size(s ? int(strlen(s)) : 0), m_data(s) {}
+    constexpr inline explicit QLatin1String(const char *s, int sz) noexcept : m_size(sz), m_data(s) {}
+    inline explicit QLatin1String(const QByteArray &s) noexcept : m_size(int(qstrnlen(s.constData(), s.size()))), m_data(s.constData()) {}
+
+    constexpr const char *latin1() const noexcept { return m_data; }
+    constexpr int size() const noexcept { return m_size; }
+    constexpr const char *data() const noexcept { return m_data; }
+
+    inline bool operator==(const QString &s) const noexcept;
+    inline bool operator!=(const QString &s) const noexcept;
+    inline bool operator>(const QString &s) const noexcept;
+    inline bool operator<(const QString &s) const noexcept;
+    inline bool operator>=(const QString &s) const noexcept;
+    inline bool operator<=(const QString &s) const noexcept;
+
+
+    inline __attribute__ ((__deprecated__)) bool operator==(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator!=(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator>(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<=(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator>=(const char *s) const;
+
+    inline __attribute__ ((__deprecated__)) bool operator==(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) bool operator!=(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) bool operator>(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<=(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) 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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QLatin1String)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QLatin1String >::value, 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;
+# 161 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+static_assert(bool(sizeof(qunicodechar) == 2), "qunicodechar must typedef an integral type of size 2")
+                                                               ;
+# 199 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+template <int N>
+struct QStaticStringData
+{
+    QArrayData str;
+    qunicodechar data[N + 1];
+
+    QStringData *data_ptr() const
+    {
+        do { } while ((false) && (str.ref.isStatic()));
+        return const_cast<QStringData *>(static_cast<const QStringData*>(&str));
+    }
+};
+
+struct QStringDataPtr
+{
+    QStringData *ptr;
+};
+
+class __attribute__((visibility("default"))) QString
+{
+public:
+    typedef QStringData Data;
+
+    inline QString() noexcept;
+    explicit QString(const QChar *unicode, int size = -1);
+    QString(QChar c);
+    QString(int size, QChar c);
+    inline QString(QLatin1String latin1);
+    inline QString(const QString &) noexcept;
+    inline ~QString();
+    QString &operator=(QChar c);
+    QString &operator=(const QString &) noexcept;
+    QString &operator=(QLatin1String latin1);
+
+    inline QString(QString && other) noexcept : d(other.d) { other.d = Data::sharedNull(); }
+    inline QString &operator=(QString &&other) noexcept
+    { qSwap(d, other.d); return *this; }
+
+    inline void swap(QString &other) noexcept { 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);
+    void resize(int size, QChar fillChar);
+
+    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))));
+    static QString vasprintf(const char *format, va_list ap) __attribute__((format(printf, (1), (0))));
+    static QString asprintf(const char *format, ...) __attribute__((format(printf, (1), (2))));
+
+    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(QLatin1String 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 indexOf(const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch) const;
+    int lastIndexOf(const QRegularExpression &re, int from = -1) const;
+    int lastIndexOf(const QRegularExpression &re, int from, QRegularExpressionMatch *rmatch) const;
+    bool contains(const QRegularExpression &re) const;
+    bool contains(const QRegularExpression &re, QRegularExpressionMatch *match) 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__));
+
+
+
+
+           
+
+
+
+
+    inline __attribute__((always_inline)) QString toLower() const &
+    { return toLower_helper(*this); }
+    inline __attribute__((always_inline)) QString toLower() &&
+    { return toLower_helper(*this); }
+    inline __attribute__((always_inline)) QString toUpper() const &
+    { return toUpper_helper(*this); }
+    inline __attribute__((always_inline)) QString toUpper() &&
+    { return toUpper_helper(*this); }
+    inline __attribute__((always_inline)) QString toCaseFolded() const &
+    { return toCaseFolded_helper(*this); }
+    inline __attribute__((always_inline)) QString toCaseFolded() &&
+    { return toCaseFolded_helper(*this); }
+    inline __attribute__((always_inline)) QString trimmed() const &
+    { return trimmed_helper(*this); }
+    inline __attribute__((always_inline)) QString trimmed() &&
+    { return trimmed_helper(*this); }
+    inline __attribute__((always_inline)) QString simplified() const &
+    { return simplified_helper(*this); }
+    inline __attribute__((always_inline)) QString simplified() &&
+    { return simplified_helper(*this); }
+
+           
+# 428 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+    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()); }
+    inline QString &insert(int i, const QStringRef &s);
+    QString &insert(int i, QLatin1String s);
+    QString &append(QChar c);
+    QString &append(const QChar *uc, int len);
+    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 QChar *uc, int len) { return insert(0, uc, len); }
+    inline QString &prepend(const QString &s) { return insert(0, s); }
+    inline QString &prepend(const QStringRef &s) { return insert(0, s); }
+    inline QString &prepend(QLatin1String s) { return insert(0, s); }
+
+    inline QString &operator+=(QChar c) {
+        if (d->ref.isShared() || uint(d->size) + 2u > d->alloc)
+            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__));
+    QVector<QStringRef> splitRef(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__));
+    QVector<QStringRef> splitRef(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__));
+    QVector<QStringRef> splitRef(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const __attribute__ ((__warn_unused_result__));
+
+
+    QStringList split(const QRegularExpression &sep, SplitBehavior behavior = KeepEmptyParts) const __attribute__ ((__warn_unused_result__));
+    QVector<QStringRef> splitRef(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 __attribute__ ((__warn_unused_result__));
+
+    const ushort *utf16() const;
+
+
+    QByteArray toLatin1() const & __attribute__ ((__warn_unused_result__))
+    { return toLatin1_helper(*this); }
+    QByteArray toLatin1() && __attribute__ ((__warn_unused_result__))
+    { return toLatin1_helper_inplace(*this); }
+    QByteArray toUtf8() const & __attribute__ ((__warn_unused_result__))
+    { return toUtf8_helper(*this); }
+    QByteArray toUtf8() && __attribute__ ((__warn_unused_result__))
+    { return toUtf8_helper(*this); }
+    QByteArray toLocal8Bit() const & __attribute__ ((__warn_unused_result__))
+    { return toLocal8Bit_helper(constData(), size()); }
+    QByteArray toLocal8Bit() && __attribute__ ((__warn_unused_result__))
+    { return toLocal8Bit_helper(constData(), size()); }
+
+
+
+
+
+    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 str.isNull() ? QString() : fromLatin1(str.data(), qstrnlen(str.constData(), str.size())); }
+    static inline QString fromUtf8(const QByteArray &str)
+    { return str.isNull() ? QString() : fromUtf8(str.data(), qstrnlen(str.constData(), str.size())); }
+    static inline QString fromLocal8Bit(const QByteArray &str)
+    { return str.isNull() ? QString() : 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 QString fromUtf16(const char16_t *str, int size = -1)
+    { return fromUtf16(reinterpret_cast<const ushort *>(str), size); }
+    static QString fromUcs4(const char32_t *str, int size = -1)
+    { return fromUcs4(reinterpret_cast<const uint *>(str), size); }
+# 575 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+    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 noexcept;
+    int compare(QLatin1String other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
+
+    static inline int compare(const QString &s1, const QString &s2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept
+    { return s1.compare(s2, cs); }
+
+    static inline int compare(const QString &s1, QLatin1String s2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept
+    { return s1.compare(s2, cs); }
+    static inline int compare(QLatin1String s1, const QString &s2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept
+    { return -s2.compare(s1, cs); }
+
+    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
+    static int compare(const QString &s1, const QStringRef &s2,
+                       Qt::CaseSensitivity = Qt::CaseSensitive) noexcept;
+
+    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=nullptr, int base=10) const;
+    ushort toUShort(bool *ok=nullptr, int base=10) const;
+    int toInt(bool *ok=nullptr, int base=10) const;
+    uint toUInt(bool *ok=nullptr, int base=10) const;
+    long toLong(bool *ok=nullptr, int base=10) const;
+    ulong toULong(bool *ok=nullptr, int base=10) const;
+    qlonglong toLongLong(bool *ok=nullptr, int base=10) const;
+    qulonglong toULongLong(bool *ok=nullptr, int base=10) const;
+    float toFloat(bool *ok=nullptr) const;
+    double toDouble(bool *ok=nullptr) 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) noexcept;
+    friend __attribute__((visibility("default"))) bool operator<(const QString &s1, const QString &s2) noexcept;
+    friend inline bool operator>(const QString &s1, const QString &s2) noexcept { return s2 < s1; }
+    friend inline bool operator!=(const QString &s1, const QString &s2) noexcept { return !(s1 == s2); }
+    friend inline bool operator<=(const QString &s1, const QString &s2) noexcept { return !(s1 > s2); }
+    friend inline bool operator>=(const QString &s1, const QString &s2) noexcept { return !(s1 < s2); }
+
+    bool operator==(QLatin1String s) const noexcept;
+    bool operator<(QLatin1String s) const noexcept;
+    bool operator>(QLatin1String s) const noexcept;
+    inline bool operator!=(QLatin1String s) const noexcept { return !operator==(s); }
+    inline bool operator<=(QLatin1String s) const noexcept { return !operator>(s); }
+    inline bool operator>=(QLatin1String s) const noexcept { return !operator<(s); }
+# 663 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+    inline __attribute__ ((__deprecated__)) QString(const char *ch)
+        : d(fromAscii_helper(ch, ch ? int(strlen(ch)) : -1))
+    {}
+    inline __attribute__ ((__deprecated__)) QString(const QByteArray &a)
+        : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size())))
+    {}
+    inline __attribute__ ((__deprecated__)) QString &operator=(const char *ch)
+    { return (*this = fromUtf8(ch)); }
+    inline __attribute__ ((__deprecated__)) QString &operator=(const QByteArray &a)
+    { return (*this = fromUtf8(a)); }
+    inline __attribute__ ((__deprecated__)) QString &operator=(char c)
+    { return (*this = QChar::fromLatin1(c)); }
+
+
+    inline __attribute__ ((__deprecated__)) QString &prepend(const char *s)
+    { return prepend(QString::fromUtf8(s)); }
+    inline __attribute__ ((__deprecated__)) QString &prepend(const QByteArray &s)
+    { return prepend(QString::fromUtf8(s)); }
+    inline __attribute__ ((__deprecated__)) QString &append(const char *s)
+    { return append(QString::fromUtf8(s)); }
+    inline __attribute__ ((__deprecated__)) QString &append(const QByteArray &s)
+    { return append(QString::fromUtf8(s)); }
+    inline __attribute__ ((__deprecated__)) QString &insert(int i, const char *s)
+    { return insert(i, QString::fromUtf8(s)); }
+    inline __attribute__ ((__deprecated__)) QString &insert(int i, const QByteArray &s)
+    { return insert(i, QString::fromUtf8(s)); }
+    inline __attribute__ ((__deprecated__)) QString &operator+=(const char *s)
+    { return append(QString::fromUtf8(s)); }
+    inline __attribute__ ((__deprecated__)) QString &operator+=(const QByteArray &s)
+    { return append(QString::fromUtf8(s)); }
+    inline __attribute__ ((__deprecated__)) QString &operator+=(char c)
+    { return append(QChar::fromLatin1(c)); }
+
+    inline __attribute__ ((__deprecated__)) bool operator==(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator!=(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<=(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator>(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator>=(const char *s) const;
+
+    inline __attribute__ ((__deprecated__)) bool operator==(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) bool operator!=(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) bool operator>(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<=(const QByteArray &s) const;
+    inline __attribute__ ((__deprecated__)) bool operator>=(const QByteArray &s) const;
+
+    friend inline __attribute__ ((__deprecated__)) bool operator==(const char *s1, const QString &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator!=(const char *s1, const QString &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator<(const char *s1, const QString &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator>(const char *s1, const QString &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator<=(const char *s1, const QString &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator>=(const char *s1, const QString &s2);
+
+    friend inline __attribute__ ((__deprecated__)) bool operator==(const char *s1, const QStringRef &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator!=(const char *s1, const QStringRef &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator<(const char *s1, const QStringRef &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator>(const char *s1, const QStringRef &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator<=(const char *s1, const QStringRef &s2);
+    friend inline __attribute__ ((__deprecated__)) bool operator>=(const char *s1, const QStringRef &s2);
+
+
+    typedef QChar *iterator;
+    typedef const QChar *const_iterator;
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    inline iterator begin();
+    inline const_iterator begin() const;
+    inline const_iterator cbegin() const;
+    inline const_iterator constBegin() const;
+    inline iterator end();
+    inline const_iterator end() const;
+    inline const_iterator cend() const;
+    inline const_iterator constEnd() const;
+    reverse_iterator rbegin() { return reverse_iterator(end()); }
+    reverse_iterator rend() { return reverse_iterator(begin()); }
+    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }
+    const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }
+
+
+    typedef int size_type;
+    typedef qptrdiff difference_type;
+    typedef const QChar & const_reference;
+    typedef QChar & reference;
+    typedef QChar *pointer;
+    typedef const QChar *const_pointer;
+    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;
+
+
+    static inline QString fromStdU16String(const std::u16string &s);
+    inline std::u16string toStdU16String() const;
+    static inline QString fromStdU32String(const std::u32string &s);
+    inline std::u32string toStdU32String() const;
+# 780 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+    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:
+# 803 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+    Data *d;
+
+    void reallocData(uint alloc, bool grow = false);
+    void expand(int i);
+    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) noexcept;
+    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) noexcept;
+    static int localeAwareCompare_helper(const QChar *data1, int length1,
+                                         const QChar *data2, int length2);
+    static QString toLower_helper(const QString &str);
+    static QString toLower_helper(QString &str);
+    static QString toUpper_helper(const QString &str);
+    static QString toUpper_helper(QString &str);
+    static QString toCaseFolded_helper(const QString &str);
+    static QString toCaseFolded_helper(QString &str);
+    static QString trimmed_helper(const QString &str);
+    static QString trimmed_helper(QString &str);
+    static QString simplified_helper(const QString &str);
+    static QString simplified_helper(QString &str);
+    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 QByteArray toLatin1_helper(const QString &);
+    static QByteArray toLatin1_helper(const QChar *data, int size);
+    static QByteArray toLatin1_helper_inplace(QString &);
+    static QByteArray toUtf8_helper(const QString &);
+    static QByteArray toLocal8Bit_helper(const QChar *data, int size);
+    static int toUcs4_helper(const ushort *uc, int length, uint *out);
+    static qlonglong toIntegral_helper(const QChar *data, int len, bool *ok, int base);
+    static qulonglong toIntegral_helper(const QChar *data, uint len, bool *ok, int base);
+    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 class QCollator;
+    friend struct QAbstractConcatenable;
+
+    template <typename T> static
+    T toIntegral_helper(const QChar *data, int len, bool *ok, int base)
+    {
+
+        const bool isUnsigned = T(0) < T(-1);
+        typedef typename QtPrivate::QConditional<isUnsigned, qulonglong, qlonglong>::Type Int64;
+        typedef typename QtPrivate::QConditional<isUnsigned, uint, int>::Type Int32;
+
+
+        Int64 val = toIntegral_helper(data, Int32(len), ok, base);
+        if (T(val) != val) {
+            if (ok)
+                *ok = false;
+            val = 0;
+        }
+        return T(val);
+    }
+
+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
+{ do { } while ((false) && (uint(i) < uint(size()))); return d->data()[i]; }
+inline const QChar QString::operator[](int i) const
+{ do { } while ((false) && (uint(i) < uint(size()))); return d->data()[i]; }
+inline const QChar QString::operator[](uint i) const
+{ do { } while ((false) && (i < uint(size()))); 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->offset != sizeof(QStringData))) reallocData(uint(d->size) + 1u); }
+inline bool QString::isDetached() const
+{ return !d->ref.isShared(); }
+inline void QString::clear()
+{ if (!isNull()) *this = QString(); }
+inline QString::QString(const QString &other) noexcept : d(other.d)
+{ do { } while ((false) && (&other != this)); d->ref.ref(); }
+inline int QString::capacity() const
+{ return d->alloc ? d->alloc - 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); }
+
+
+# 957 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+#pragma GCC diagnostic push
+# 957 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+
+
+
+inline int QString::toWCharArray(wchar_t *array) const
+{
+    if (sizeof(wchar_t) == sizeof(QChar)) {
+        memcpy(array, d->data(), sizeof(QChar) * size());
+        return size();
+    } else {
+        return toUcs4_helper(d->data(), size(), reinterpret_cast<uint *>(array));
+    }
+}
+
+
+# 970 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+#pragma GCC diagnostic pop
+# 970 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+
+
+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 __attribute__ ((__deprecated__)) QCharRef &operator=(char c)
+    { return operator=(QChar::fromLatin1(c)); }
+    inline __attribute__ ((__deprecated__)) 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::JoiningType joiningType() const { return QChar(*this).joiningType(); }
+
+    __attribute__ ((__deprecated__)) QChar::Joining joining() const
+    {
+        switch (QChar(*this).joiningType()) {
+        case QChar::Joining_Causing: return QChar::Center;
+        case QChar::Joining_Dual: return QChar::Dual;
+        case QChar::Joining_Right: return QChar::Right;
+        case QChar::Joining_None:
+        case QChar::Joining_Left:
+        case QChar::Joining_Transparent:
+        default: return QChar::OtherJoining;
+        }
+    }
+
+    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(); }
+
+    inline QChar::Script script() const { return QChar(*this).script(); }
+
+    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 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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QCharRef)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QCharRef >::value, 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() noexcept : d(Data::sharedNull()) {}
+inline QString::~QString() { if (!d->ref.deref()) Data::deallocate(d); }
+
+inline void QString::reserve(int asize)
+{
+    if (d->ref.isShared() || uint(asize) >= d->alloc)
+        reallocData(qMax(asize, d->size) + 1u);
+
+    if (!d->capacityReserved) {
+
+        d->capacityReserved = true;
+    }
+}
+
+inline void QString::squeeze()
+{
+    if (d->ref.isShared() || uint(d->size) + 1u < d->alloc)
+        reallocData(uint(d->size) + 1u);
+
+    if (d->capacityReserved) {
+
+
+        d->capacityReserved = false;
+    }
+}
+
+inline QString &QString::setUtf16(const ushort *autf16, int asize)
+{ return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); }
+inline QCharRef QString::operator[](int i)
+{ do { } while ((false) && (i >= 0)); 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(QLatin1String 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) noexcept
+{ return (s1.size() == s2.size() && !memcmp(s1.latin1(), s2.latin1(), s1.size())); }
+inline bool operator!=(QLatin1String s1, QLatin1String s2) noexcept
+{ return (s1.size() != s2.size() || memcmp(s1.latin1(), s2.latin1(), s1.size())); }
+inline bool operator<(QLatin1String s1, QLatin1String s2) noexcept
+{ 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) noexcept
+{ 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) noexcept
+{ 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) noexcept
+{ 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 noexcept
+{ return s == *this; }
+inline bool QLatin1String::operator!=(const QString &s) const noexcept
+{ return s != *this; }
+inline bool QLatin1String::operator>(const QString &s) const noexcept
+{ return s < *this; }
+inline bool QLatin1String::operator<(const QString &s) const noexcept
+{ return s > *this; }
+inline bool QLatin1String::operator>=(const QString &s) const noexcept
+{ return s <= *this; }
+inline bool QLatin1String::operator<=(const QString &s) const noexcept
+{ 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 __attribute__ ((__deprecated__)) bool operator==(const char *s1, const QString &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) == 0; }
+inline __attribute__ ((__deprecated__)) bool operator!=(const char *s1, const QString &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) != 0; }
+inline __attribute__ ((__deprecated__)) bool operator<(const char *s1, const QString &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) > 0; }
+inline __attribute__ ((__deprecated__)) bool operator>(const char *s1, const QString &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) < 0; }
+inline __attribute__ ((__deprecated__)) bool operator<=(const char *s1, const QString &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) >= 0; }
+inline __attribute__ ((__deprecated__)) bool operator>=(const char *s1, const QString &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) <= 0; }
+
+inline __attribute__ ((__deprecated__)) bool operator==(const char *s1, QLatin1String s2)
+{ return QString::fromUtf8(s1) == s2; }
+inline __attribute__ ((__deprecated__)) bool operator!=(const char *s1, QLatin1String s2)
+{ return QString::fromUtf8(s1) != s2; }
+inline __attribute__ ((__deprecated__)) bool operator<(const char *s1, QLatin1String s2)
+{ return (QString::fromUtf8(s1) < s2); }
+inline __attribute__ ((__deprecated__)) bool operator>(const char *s1, QLatin1String s2)
+{ return (QString::fromUtf8(s1) > s2); }
+inline __attribute__ ((__deprecated__)) bool operator<=(const char *s1, QLatin1String s2)
+{ return (QString::fromUtf8(s1) <= s2); }
+inline __attribute__ ((__deprecated__)) bool operator>=(const char *s1, QLatin1String s2)
+{ return (QString::fromUtf8(s1) >= s2); }
+
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator==(const char *s) const
+{ return QString::fromUtf8(s) == *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator!=(const char *s) const
+{ return QString::fromUtf8(s) != *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator<(const char *s) const
+{ return QString::fromUtf8(s) > *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator>(const char *s) const
+{ return QString::fromUtf8(s) < *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator<=(const char *s) const
+{ return QString::fromUtf8(s) >= *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator>=(const char *s) const
+{ return QString::fromUtf8(s) <= *this; }
+
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator==(const QByteArray &s) const
+{ return QString::fromUtf8(s) == *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator!=(const QByteArray &s) const
+{ return QString::fromUtf8(s) != *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator<(const QByteArray &s) const
+{ return QString::fromUtf8(s) > *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator>(const QByteArray &s) const
+{ return QString::fromUtf8(s) < *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator<=(const QByteArray &s) const
+{ return QString::fromUtf8(s) >= *this; }
+inline __attribute__ ((__deprecated__)) bool QLatin1String::operator>=(const QByteArray &s) const
+{ return QString::fromUtf8(s) <= *this; }
+
+inline __attribute__ ((__deprecated__)) bool QString::operator==(const QByteArray &s) const
+{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) == 0; }
+inline __attribute__ ((__deprecated__)) bool QString::operator!=(const QByteArray &s) const
+{ return QString::compare_helper(constData(), size(), s.constData(), qstrnlen(s.constData(), s.size())) != 0; }
+inline __attribute__ ((__deprecated__)) bool QString::operator<(const QByteArray &s) const
+{ return QString::compare_helper(constData(), size(), s.constData(), s.size()) < 0; }
+inline __attribute__ ((__deprecated__)) bool QString::operator>(const QByteArray &s) const
+{ return QString::compare_helper(constData(), size(), s.constData(), s.size()) > 0; }
+inline __attribute__ ((__deprecated__)) bool QString::operator<=(const QByteArray &s) const
+{ return QString::compare_helper(constData(), size(), s.constData(), s.size()) <= 0; }
+inline __attribute__ ((__deprecated__)) bool QString::operator>=(const QByteArray &s) const
+{ return QString::compare_helper(constData(), size(), 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(), size()) > 0; }
+inline bool QByteArray::operator>(const QString &s) const
+{ return QString::compare_helper(s.constData(), s.size(), constData(), size()) < 0; }
+inline bool QByteArray::operator<=(const QString &s) const
+{ return QString::compare_helper(s.constData(), s.size(), constData(), size()) >= 0; }
+inline bool QByteArray::operator>=(const QString &s) const
+{ return QString::compare_helper(s.constData(), s.size(), constData(), size()) <= 0; }
+# 1304 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h"
+inline std::string QString::toStdString() const
+{ return toUtf8().toStdString(); }
+
+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())); }
+
+
+inline QString QString::fromStdU16String(const std::u16string &s)
+{ return fromUtf16(s.data(), int(s.size())); }
+
+inline std::u16string QString::toStdU16String() const
+{ return std::u16string(reinterpret_cast<const char16_t*>(utf16()), length()); }
+
+inline QString QString::fromStdU32String(const std::u32string &s)
+{ return fromUcs4(s.data(), int(s.size())); }
+
+inline std::u32string QString::toStdU32String() const
+{
+    std::u32string u32str(length(), char32_t(0));
+    int len = toUcs4_helper(d->data(), length(), reinterpret_cast<uint*>(&u32str[0]));
+    u32str.resize(len);
+    return u32str;
+}
+
+
+
+__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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QString)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QString >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QString) }; static inline const char *name() { return "QString"; } }; inline void swap(QString &value1, QString &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }
+constexpr inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QString::SectionFlags::enum_type f2) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QString::SectionFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+
+
+class __attribute__((visibility("default"))) QStringRef {
+    const QString *m_string;
+    int m_position;
+    int m_size;
+public:
+    typedef QString::size_type size_type;
+    typedef QString::value_type value_type;
+    typedef const QChar *const_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef QString::const_pointer const_pointer;
+    typedef QString::const_reference const_reference;
+
+
+    inline QStringRef() : m_string(nullptr), m_position(0), m_size(0) {}
+    inline QStringRef(const QString *string, int position, int size);
+    inline QStringRef(const QString *string);
+
+
+
+    QStringRef(const QStringRef &other) noexcept
+        :m_string(other.m_string), m_position(other.m_position), m_size(other.m_size)
+        {}
+
+    QStringRef(QStringRef &&other) noexcept : m_string(other.m_string), m_position(other.m_position), m_size(other.m_size) {}
+    QStringRef &operator=(QStringRef &&other) noexcept { return *this = other; }
+
+    QStringRef &operator=(const QStringRef &other) noexcept {
+        m_string = other.m_string; m_position = other.m_position;
+        m_size = other.m_size; return *this;
+    }
+    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; }
+
+    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;
+
+    QVector<QStringRef> split(const QString &sep, QString::SplitBehavior behavior = QString::KeepEmptyParts,
+                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((__warn_unused_result__));
+    QVector<QStringRef> split(QChar sep, QString::SplitBehavior behavior = QString::KeepEmptyParts,
+                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((__warn_unused_result__));
+
+    QStringRef left(int n) const __attribute__ ((__warn_unused_result__));
+    QStringRef right(int n) const __attribute__ ((__warn_unused_result__));
+    QStringRef mid(int pos, int n = -1) const __attribute__ ((__warn_unused_result__));
+
+    void truncate(int pos) noexcept { m_size = qBound(0, pos, m_size); }
+
+    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(); }
+
+    inline const_iterator begin() const { return unicode(); }
+    inline const_iterator cbegin() const { return unicode(); }
+    inline const_iterator end() const { return unicode() + size(); }
+    inline const_iterator cend() const { return unicode() + size(); }
+    inline const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+    inline const_reverse_iterator crbegin() const { return rbegin(); }
+    inline const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+    inline const_reverse_iterator crend() const { return rend(); }
+
+
+
+
+
+    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 = nullptr; m_position = m_size = 0; }
+    QString toString() const;
+    inline bool isEmpty() const { return m_size == 0; }
+    inline bool isNull() const { return m_string == nullptr || m_string->isNull(); }
+
+    QStringRef appendTo(QString *string) const;
+
+    inline const QChar at(int i) const
+        { do { } while ((false) && (uint(i) < uint(size()))); return m_string->at(i + m_position); }
+    QChar operator[](int i) const { return at(i); }
+
+
+
+    inline __attribute__ ((__deprecated__)) bool operator==(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator!=(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator<=(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator>(const char *s) const;
+    inline __attribute__ ((__deprecated__)) bool operator>=(const char *s) const;
+
+
+    int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
+    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
+    int compare(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const noexcept;
+    static int compare(const QStringRef &s1, const QString &s2,
+                       Qt::CaseSensitivity = Qt::CaseSensitive) noexcept;
+    static int compare(const QStringRef &s1, const QStringRef &s2,
+                       Qt::CaseSensitivity = Qt::CaseSensitive) noexcept;
+    static int compare(const QStringRef &s1, QLatin1String s2,
+                       Qt::CaseSensitivity cs = Qt::CaseSensitive) noexcept;
+
+    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);
+
+    QStringRef trimmed() const __attribute__ ((__warn_unused_result__));
+    short toShort(bool *ok = nullptr, int base = 10) const;
+    ushort toUShort(bool *ok = nullptr, int base = 10) const;
+    int toInt(bool *ok = nullptr, int base = 10) const;
+    uint toUInt(bool *ok = nullptr, int base = 10) const;
+    long toLong(bool *ok = nullptr, int base = 10) const;
+    ulong toULong(bool *ok = nullptr, int base = 10) const;
+    qlonglong toLongLong(bool *ok = nullptr, int base = 10) const;
+    qulonglong toULongLong(bool *ok = nullptr, int base = 10) const;
+    float toFloat(bool *ok = nullptr) const;
+    double toDouble(bool *ok = nullptr) const;
+};
+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), isRelocatable = !isStatic || ((Q_PRIMITIVE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QStringRef)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QStringRef >::value, 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) noexcept;
+inline bool operator!=(const QStringRef &s1, const QStringRef &s2) noexcept
+{ return !(s1 == s2); }
+__attribute__((visibility("default"))) bool operator==(const QString &s1, const QStringRef &s2) noexcept;
+inline bool operator!=(const QString &s1, const QStringRef &s2) noexcept
+{ return !(s1 == s2); }
+inline bool operator==(const QStringRef &s1, const QString &s2) noexcept
+{ return s2 == s1; }
+inline bool operator!=(const QStringRef &s1, const QString &s2) noexcept
+{ return s2 != s1; }
+__attribute__((visibility("default"))) bool operator==(QLatin1String s1, const QStringRef &s2) noexcept;
+inline bool operator!=(QLatin1String s1, const QStringRef &s2) noexcept
+{ return !(s1 == s2); }
+inline bool operator==(const QStringRef &s1, QLatin1String s2) noexcept
+{ return s2 == s1; }
+inline bool operator!=(const QStringRef &s1, QLatin1String s2) noexcept
+{ return s2 != s1; }
+
+__attribute__((visibility("default"))) bool operator<(const QStringRef &s1, const QStringRef &s2) noexcept;
+inline bool operator>(const QStringRef &s1, const QStringRef &s2) noexcept
+{ return s2 < s1; }
+inline bool operator<=(const QStringRef &s1, const QStringRef &s2) noexcept
+{ return !(s1 > s2); }
+inline bool operator>=(const QStringRef &s1, const QStringRef &s2) noexcept
+{ return !(s1 < s2); }
+
+
+inline __attribute__ ((__deprecated__)) bool QStringRef::operator==(const char *s) const
+{ return QString::compare_helper(constData(), size(), s, -1) == 0; }
+inline __attribute__ ((__deprecated__)) bool QStringRef::operator!=(const char *s) const
+{ return QString::compare_helper(constData(), size(), s, -1) != 0; }
+inline __attribute__ ((__deprecated__)) bool QStringRef::operator<(const char *s) const
+{ return QString::compare_helper(constData(), size(), s, -1) < 0; }
+inline __attribute__ ((__deprecated__)) bool QStringRef::operator<=(const char *s) const
+{ return QString::compare_helper(constData(), size(), s, -1) <= 0; }
+inline __attribute__ ((__deprecated__)) bool QStringRef::operator>(const char *s) const
+{ return QString::compare_helper(constData(), size(), s, -1) > 0; }
+inline __attribute__ ((__deprecated__)) bool QStringRef::operator>=(const char *s) const
+{ return QString::compare_helper(constData(), size(), s, -1) >= 0; }
+
+inline __attribute__ ((__deprecated__)) bool operator==(const char *s1, const QStringRef &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) == 0; }
+inline __attribute__ ((__deprecated__)) bool operator!=(const char *s1, const QStringRef &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) != 0; }
+inline __attribute__ ((__deprecated__)) bool operator<(const char *s1, const QStringRef &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) > 0; }
+inline __attribute__ ((__deprecated__)) bool operator<=(const char *s1, const QStringRef &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) >= 0; }
+inline __attribute__ ((__deprecated__)) bool operator>(const char *s1, const QStringRef &s2)
+{ return QString::compare_helper(s2.constData(), s2.size(), s1, -1) < 0; }
+inline __attribute__ ((__deprecated__)) 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 noexcept
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs) noexcept
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const noexcept
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const noexcept
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const noexcept
+{ return QString::compare_helper(constData(), length(), s, cs); }
+inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs) noexcept
+{ 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) noexcept
+{ 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) noexcept
+{ 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; }
+
+inline QString &QString::insert(int i, const QStringRef &s)
+{ return insert(i, s.constData(), s.length()); }
+
+namespace Qt {
+
+
+
+
+
+}
+
+
+
+
+# 1 "../../include/QtCore/qstringbuilder.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringbuilder.h" 1
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringbuilder.h"
+# 1 "../../include/QtCore/qstring.h" 1
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringbuilder.h" 2
+# 1 "../../include/QtCore/qbytearray.h" 1
+# 52 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringbuilder.h" 2
+
+
+
+
+
+
+struct __attribute__((visibility("default"))) QAbstractConcatenable
+{
+protected:
+    static void convertFromAscii(const char *a, int len, QChar *&out) noexcept;
+    static inline void convertFromAscii(char a, QChar *&out) noexcept
+    {
+        *out++ = QLatin1Char(a);
+    }
+    static void appendLatin1To(const char *a, int len, QChar *out) noexcept;
+};
+
+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<B>::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 = const_cast<typename T::iterator>(s.constData());
+        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_) {}
+        QStringBuilder(const QStringBuilder &other) : a(other.a), b(other.b) {}
+
+        operator QString() const
+        { QString r(a); r += b; return r; }
+
+        const QString &a;
+        const QString &b;
+
+    private:
+        QStringBuilder &operator=(const QStringBuilder &) = delete;
+};
+
+template <>
+class QStringBuilder <QByteArray, QByteArray> : public QStringBuilderBase<QStringBuilder<QByteArray, QByteArray>, QByteArray>
+{
+    public:
+        QStringBuilder(const QByteArray &a_, const QByteArray &b_) : a(a_), b(b_) {}
+        QStringBuilder(const QStringBuilder &other) : a(other.a), b(other.b) {}
+
+        operator QByteArray() const
+        { QByteArray r(a); r += b; return r; }
+
+        const QByteArray &a;
+        const QByteArray &b;
+
+    private:
+        QStringBuilder &operator=(const QStringBuilder &) = delete;
+};
+
+
+template <> struct QConcatenable<char> : private QAbstractConcatenable
+{
+    typedef char type;
+    typedef QByteArray ConvertTo;
+    enum { ExactSize = true };
+    static int size(const char) { return 1; }
+
+    static inline __attribute__ ((__deprecated__)) 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> : private QAbstractConcatenable
+{
+    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)
+    {
+        appendLatin1To(a.latin1(), a.size(), out);
+        out += a.size();
+    }
+    static inline void appendTo(const QLatin1String a, char *&out)
+    {
+        if (const char *data = a.data()) {
+            memcpy(out, data, a.size());
+            out += a.size();
+        }
+    }
+};
+
+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 __attribute__ ((__deprecated__)) 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 __attribute__ ((__deprecated__)) 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 __attribute__ ((__deprecated__)) 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 __attribute__ ((__deprecated__)) 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<B>::ConvertTo>::ConvertTo ConvertTo;
+    enum { ExactSize = QConcatenable<A>::ExactSize && QConcatenable<B>::ExactSize };
+    static int size(const type &p)
+    {
+        return QConcatenable<A>::size(p.a) + QConcatenable<B>::size(p.b);
+    }
+    template<typename T> static inline void appendTo(const type &p, T *&out)
+    {
+        QConcatenable<A>::appendTo(p.a, out);
+        QConcatenable<B>::appendTo(p.b, out);
+    }
+};
+
+template <typename A, typename B>
+QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>
+operator%(const A &a, const B &b)
+{
+   return QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>(a, b);
+}
+
+
+
+
+template <typename A, typename B>
+QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::type>
+operator+(const A &a, const B &b)
+{
+   return QStringBuilder<typename QConcatenable<A>::type, typename QConcatenable<B>::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;
+}
+# 414 "../../include/QtCore/../../../../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(int(it - a.constData()));
+    return a;
+}
+
+
+
+# 1 "../../include/QtCore/qstringbuilder.h" 2
+# 1629 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstring.h" 2
+# 1 "../../include/QtCore/qstring.h" 2
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonvalue.h" 2
+
+
+
+class QDebug;
+class QVariant;
+class QJsonArray;
+class QJsonObject;
+
+namespace QJsonPrivate {
+    class Data;
+    class Base;
+    class Object;
+    class Header;
+    class Array;
+    class Value;
+    class Entry;
+}
+
+class __attribute__((visibility("default"))) QJsonValue
+{
+public:
+    enum Type {
+        Null = 0x0,
+        Bool = 0x1,
+        Double = 0x2,
+        String = 0x3,
+        Array = 0x4,
+        Object = 0x5,
+        Undefined = 0x80
+    };
+
+    QJsonValue(Type = Null);
+    QJsonValue(bool b);
+    QJsonValue(double n);
+    QJsonValue(int n);
+    QJsonValue(qint64 n);
+    QJsonValue(const QString &s);
+    QJsonValue(QLatin1String s);
+
+    inline __attribute__ ((__deprecated__)) QJsonValue(const char *s)
+        : d(0), t(String) { stringDataFromQStringHelper(QString::fromUtf8(s)); }
+
+    QJsonValue(const QJsonArray &a);
+    QJsonValue(const QJsonObject &o);
+
+    ~QJsonValue();
+
+    QJsonValue(const QJsonValue &other);
+    QJsonValue &operator =(const QJsonValue &other);
+
+    static QJsonValue fromVariant(const QVariant &variant);
+    QVariant toVariant() const;
+
+    Type type() const;
+    inline bool isNull() const { return type() == Null; }
+    inline bool isBool() const { return type() == Bool; }
+    inline bool isDouble() const { return type() == Double; }
+    inline bool isString() const { return type() == String; }
+    inline bool isArray() const { return type() == Array; }
+    inline bool isObject() const { return type() == Object; }
+    inline bool isUndefined() const { return type() == Undefined; }
+
+    bool toBool(bool defaultValue = false) const;
+    int toInt(int defaultValue = 0) const;
+    double toDouble(double defaultValue = 0) const;
+    QString toString(const QString &defaultValue = QString()) const;
+    QJsonArray toArray() const;
+    QJsonArray toArray(const QJsonArray &defaultValue) const;
+    QJsonObject toObject() const;
+    QJsonObject toObject(const QJsonObject &defaultValue) const;
+
+    bool operator==(const QJsonValue &other) const;
+    bool operator!=(const QJsonValue &other) const;
+
+private:
+
+    inline QJsonValue(const void *) {}
+    friend class QJsonPrivate::Value;
+    friend class QJsonArray;
+    friend class QJsonObject;
+    friend __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QJsonValue &);
+
+    QJsonValue(QJsonPrivate::Data *d, QJsonPrivate::Base *b, const QJsonPrivate::Value& v);
+    void stringDataFromQStringHelper(const QString &string);
+
+    void detach();
+
+    union {
+        quint64 ui;
+        bool b;
+        double dbl;
+        QStringData *stringData;
+        QJsonPrivate::Base *base;
+    };
+    QJsonPrivate::Data *d;
+    Type t;
+};
+
+class __attribute__((visibility("default"))) QJsonValueRef
+{
+public:
+    QJsonValueRef(QJsonArray *array, int idx)
+        : a(array), is_object(false), index(idx) {}
+    QJsonValueRef(QJsonObject *object, int idx)
+        : o(object), is_object(true), index(idx) {}
+
+    inline operator QJsonValue() const { return toValue(); }
+    QJsonValueRef &operator = (const QJsonValue &val);
+    QJsonValueRef &operator = (const QJsonValueRef &val);
+
+    QVariant toVariant() const;
+    inline QJsonValue::Type type() const { return toValue().type(); }
+    inline bool isNull() const { return type() == QJsonValue::Null; }
+    inline bool isBool() const { return type() == QJsonValue::Bool; }
+    inline bool isDouble() const { return type() == QJsonValue::Double; }
+    inline bool isString() const { return type() == QJsonValue::String; }
+    inline bool isArray() const { return type() == QJsonValue::Array; }
+    inline bool isObject() const { return type() == QJsonValue::Object; }
+    inline bool isUndefined() const { return type() == QJsonValue::Undefined; }
+
+    inline bool toBool() const { return toValue().toBool(); }
+    inline int toInt() const { return toValue().toInt(); }
+    inline double toDouble() const { return toValue().toDouble(); }
+    inline QString toString() const { return toValue().toString(); }
+    QJsonArray toArray() const;
+    QJsonObject toObject() const;
+
+
+    inline bool toBool(bool defaultValue) const { return toValue().toBool(defaultValue); }
+    inline int toInt(int defaultValue) const { return toValue().toInt(defaultValue); }
+    inline double toDouble(double defaultValue) const { return toValue().toDouble(defaultValue); }
+    inline QString toString(const QString &defaultValue) const { return toValue().toString(defaultValue); }
+
+    inline bool operator==(const QJsonValue &other) const { return toValue() == other; }
+    inline bool operator!=(const QJsonValue &other) const { return toValue() != other; }
+
+private:
+    QJsonValue toValue() const;
+
+    union {
+        QJsonArray *a;
+        QJsonObject *o;
+    };
+    uint is_object : 1;
+    uint index : 31;
+};
+
+
+
+class QJsonValuePtr
+{
+    QJsonValue value;
+public:
+    explicit QJsonValuePtr(const QJsonValue& val)
+        : value(val) {}
+
+    QJsonValue& operator*() { return value; }
+    QJsonValue* operator->() { return &value; }
+};
+
+class QJsonValueRefPtr
+{
+    QJsonValueRef valueRef;
+public:
+    QJsonValueRefPtr(QJsonArray *array, int idx)
+        : valueRef(array, idx) {}
+    QJsonValueRefPtr(QJsonObject *object, int idx)
+        : valueRef(object, idx) {}
+
+    QJsonValueRef& operator*() { return valueRef; }
+    QJsonValueRef* operator->() { return &valueRef; }
+};
+
+
+
+__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QJsonValue &);
+
+
+
+# 1 "../../include/QtCore/qjsonvalue.h" 2
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonobject.h" 2
+# 1 "../../include/QtCore/qiterator.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qiterator.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qiterator.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qiterator.h" 2
+
+
+# 182 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qiterator.h"
+
+# 1 "../../include/QtCore/qiterator.h" 2
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonobject.h" 2
+
+# 1 "../../include/QtCore/qpair.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qpair.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qpair.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qpair.h" 2
+
+
+
+
+template <class T1, class T2>
+struct QPair
+{
+    typedef T1 first_type;
+    typedef T2 second_type;
+
+    constexpr QPair()
+        noexcept((std::is_nothrow_default_constructible<T1>::value && std::is_nothrow_default_constructible<T2>::value))
+
+        : first(), second() {}
+    constexpr QPair(const T1 &t1, const T2 &t2)
+        noexcept((std::is_nothrow_copy_constructible<T1>::value && std::is_nothrow_copy_constructible<T2>::value))
+
+        : first(t1), second(t2) {}
+
+
+    template <typename TT1, typename TT2>
+    constexpr QPair(const QPair<TT1, TT2> &p)
+        noexcept((std::is_nothrow_constructible<T1, TT1&>::value && std::is_nothrow_constructible<T2, TT2&>::value))
+
+        : first(p.first), second(p.second) {}
+    template <typename TT1, typename TT2>
+    constexpr QPair &operator=(const QPair<TT1, TT2> &p)
+        noexcept((std::is_nothrow_assignable<T1, TT1&>::value && std::is_nothrow_assignable<T2, TT2&>::value))
+
+    { first = p.first; second = p.second; return *this; }
+
+    template <typename TT1, typename TT2>
+    constexpr QPair(QPair<TT1, TT2> &&p)
+        noexcept((std::is_nothrow_constructible<T1, TT1>::value && std::is_nothrow_constructible<T2, TT2>::value))
+
+
+        : first(static_cast<TT1 &&>(p.first)), second(static_cast<TT2 &&>(p.second)) {}
+    template <typename TT1, typename TT2>
+    constexpr QPair &operator=(QPair<TT1, TT2> &&p)
+        noexcept((std::is_nothrow_assignable<T1, TT1>::value && std::is_nothrow_assignable<T2, TT2>::value))
+
+    { first = std::move(p.first); second = std::move(p.second); return *this; }
+
+
+    constexpr void swap(QPair &other)
+        noexcept(noexcept(qSwap(other.first, other.first)) && noexcept(qSwap(other.second, other.second)))
+    {
+
+        qSwap(first, other.first);
+        qSwap(second, other.second);
+    }
+
+    T1 first;
+    T2 second;
+};
+
+template <typename T1, typename T2>
+void swap(QPair<T1, T2> &lhs, QPair<T1, T2> &rhs) noexcept(noexcept(lhs.swap(rhs)))
+{ lhs.swap(rhs); }
+
+
+
+template<class T1, class T2>
+class QTypeInfo<QPair<T1, T2> > : public QTypeInfoMerger<QPair<T1, T2>, T1, T2> {};
+
+template <class T1, class T2>
+constexpr inline bool operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+    noexcept(noexcept(p1.first == p2.first && p1.second == p2.second))
+{ return p1.first == p2.first && p1.second == p2.second; }
+
+template <class T1, class T2>
+constexpr inline bool operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+    noexcept(noexcept(!(p1 == p2)))
+{ return !(p1 == p2); }
+
+template <class T1, class T2>
+constexpr inline bool operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+    noexcept(noexcept(p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second)))
+{
+    return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second);
+}
+
+template <class T1, class T2>
+constexpr inline bool operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+    noexcept(noexcept(p2 < p1))
+{
+    return p2 < p1;
+}
+
+template <class T1, class T2>
+constexpr inline bool operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+    noexcept(noexcept(!(p2 < p1)))
+{
+    return !(p2 < p1);
+}
+
+template <class T1, class T2>
+constexpr inline bool operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+    noexcept(noexcept(!(p1 < p2)))
+{
+    return !(p1 < p2);
+}
+
+template <class T1, class T2>
+constexpr QPair<T1, T2> qMakePair(const T1 &x, const T2 &y)
+    noexcept(noexcept(QPair<T1, T2>(x, y)))
+{
+    return QPair<T1, T2>(x, y);
+}
+
+
+# 1 "../../include/QtCore/qpair.h" 2
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonobject.h" 2
+
+
+
+
+
+class QDebug;
+template <class Key, class T> class QMap;
+typedef QMap<QString, QVariant> QVariantMap;
+template <class Key, class T> class QHash;
+typedef QHash<QString, QVariant> QVariantHash;
+
+class __attribute__((visibility("default"))) QJsonObject
+{
+public:
+    QJsonObject();
+
+
+    QJsonObject(std::initializer_list<QPair<QString, QJsonValue> > args)
+    {
+        initialize();
+        for (std::initializer_list<QPair<QString, QJsonValue> >::const_iterator i = args.begin(); i != args.end(); ++i)
+            insert(i->first, i->second);
+    }
+
+
+    ~QJsonObject();
+
+    QJsonObject(const QJsonObject &other);
+    QJsonObject &operator =(const QJsonObject &other);
+
+    static QJsonObject fromVariantMap(const QVariantMap &map);
+    QVariantMap toVariantMap() const;
+    static QJsonObject fromVariantHash(const QVariantHash &map);
+    QVariantHash toVariantHash() const;
+
+    QStringList keys() const;
+    int size() const;
+    inline int count() const { return size(); }
+    inline int length() const { return size(); }
+    bool isEmpty() const;
+
+    QJsonValue value(const QString &key) const;
+    QJsonValue operator[] (const QString &key) const;
+    QJsonValueRef operator[] (const QString &key);
+
+    void remove(const QString &key);
+    QJsonValue take(const QString &key);
+    bool contains(const QString &key) const;
+
+    bool operator==(const QJsonObject &other) const;
+    bool operator!=(const QJsonObject &other) const;
+
+    class const_iterator;
+
+    class iterator
+    {
+        friend class const_iterator;
+        friend class QJsonObject;
+        QJsonObject *o;
+        int i;
+
+    public:
+        typedef std::random_access_iterator_tag iterator_category;
+        typedef int difference_type;
+        typedef QJsonValue value_type;
+        typedef QJsonValueRef reference;
+        typedef QJsonValuePtr pointer;
+
+        constexpr inline iterator() : o(nullptr), i(0) {}
+        constexpr inline iterator(QJsonObject *obj, int index) : o(obj), i(index) {}
+
+        inline QString key() const { return o->keyAt(i); }
+        inline QJsonValueRef value() const { return QJsonValueRef(o, i); }
+        inline QJsonValueRef operator*() const { return QJsonValueRef(o, i); }
+
+
+
+        inline QJsonValueRefPtr operator->() const { return QJsonValueRefPtr(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 iterator &operator++() { ++i; return *this; }
+        inline iterator operator++(int) { iterator r = *this; ++i; return r; }
+        inline iterator &operator--() { --i; return *this; }
+        inline iterator operator--(int) { iterator r = *this; --i; return r; }
+        inline iterator operator+(int j) const
+        { iterator r = *this; r.i += j; return r; }
+        inline iterator operator-(int j) const { return operator+(-j); }
+        inline iterator &operator+=(int j) { i += j; return *this; }
+        inline iterator &operator-=(int j) { i -= j; return *this; }
+
+    public:
+        inline bool operator==(const const_iterator &other) const { return i == other.i; }
+        inline bool operator!=(const const_iterator &other) const { return i != other.i; }
+    };
+    friend class iterator;
+
+    class const_iterator
+    {
+        friend class iterator;
+        const QJsonObject *o;
+        int i;
+
+    public:
+        typedef std::random_access_iterator_tag iterator_category;
+        typedef int difference_type;
+        typedef QJsonValue value_type;
+        typedef QJsonValue reference;
+        typedef QJsonValuePtr pointer;
+
+        constexpr inline const_iterator() : o(nullptr), i(0) {}
+        constexpr inline const_iterator(const QJsonObject *obj, int index)
+            : o(obj), i(index) {}
+        inline const_iterator(const iterator &other)
+            : o(other.o), i(other.i) {}
+
+        inline QString key() const { return o->keyAt(i); }
+        inline QJsonValue value() const { return o->valueAt(i); }
+        inline QJsonValue operator*() const { return o->valueAt(i); }
+
+
+
+        inline QJsonValuePtr operator->() const { return QJsonValuePtr(o->valueAt(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) { const_iterator r = *this; ++i; return r; }
+        inline const_iterator &operator--() { --i; return *this; }
+        inline const_iterator operator--(int) { const_iterator r = *this; --i; return r; }
+        inline const_iterator operator+(int j) const
+        { const_iterator r = *this; r.i += j; return r; }
+        inline const_iterator operator-(int j) const { return operator+(-j); }
+        inline const_iterator &operator+=(int j) { i += j; return *this; }
+        inline const_iterator &operator-=(int j) { i -= j; return *this; }
+
+        inline bool operator==(const iterator &other) const { return i == other.i; }
+        inline bool operator!=(const iterator &other) const { return i != other.i; }
+    };
+    friend class const_iterator;
+
+
+    inline iterator begin() { detach2(); return iterator(this, 0); }
+    inline const_iterator begin() const { return const_iterator(this, 0); }
+    inline const_iterator constBegin() const { return const_iterator(this, 0); }
+    inline iterator end() { detach2(); return iterator(this, size()); }
+    inline const_iterator end() const { return const_iterator(this, size()); }
+    inline const_iterator constEnd() const { return const_iterator(this, size()); }
+    iterator erase(iterator it);
+
+
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    iterator find(const QString &key);
+    const_iterator find(const QString &key) const { return constFind(key); }
+    const_iterator constFind(const QString &key) const;
+    iterator insert(const QString &key, const QJsonValue &value);
+
+
+    typedef QJsonValue mapped_type;
+    typedef QString key_type;
+    typedef int size_type;
+
+    inline bool empty() const { return isEmpty(); }
+
+private:
+    friend class QJsonPrivate::Data;
+    friend class QJsonValue;
+    friend class QJsonDocument;
+    friend class QJsonValueRef;
+
+    friend __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QJsonObject &);
+
+    QJsonObject(QJsonPrivate::Data *data, QJsonPrivate::Object *object);
+    void initialize();
+
+    void detach(uint reserve = 0);
+    bool detach2(uint reserve = 0);
+    void compact();
+
+    QString keyAt(int i) const;
+    QJsonValue valueAt(int i) const;
+    void setValueAt(int i, const QJsonValue &val);
+
+    QJsonPrivate::Data *d;
+    QJsonPrivate::Object *o;
+};
+
+
+__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QJsonObject &);
+
+
+
+# 1 "../../include/QtCore/qjsonobject.h" 2
+# 41 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp" 2
+# 1 "../../include/QtCore/qjsonvalue.h" 1
+# 42 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp" 2
+# 1 "../../include/QtCore/qjsonarray.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonarray.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonarray.h"
+# 1 "../../include/QtCore/qjsonvalue.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonarray.h" 2
+# 1 "../../include/QtCore/qiterator.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsonarray.h" 2
+
+
+
+
+
+
+class QDebug;
+class QStringList;
+template <typename T> class QList;
+typedef QList<QVariant> QVariantList;
+
+class __attribute__((visibility("default"))) QJsonArray
+{
+public:
+    QJsonArray();
+
+
+    QJsonArray(std::initializer_list<QJsonValue> args)
+    {
+        initialize();
+        for (std::initializer_list<QJsonValue>::const_iterator i = args.begin(); i != args.end(); ++i)
+            append(*i);
+    }
+
+
+    ~QJsonArray();
+
+    QJsonArray(const QJsonArray &other);
+    QJsonArray &operator =(const QJsonArray &other);
+
+    static QJsonArray fromStringList(const QStringList &list);
+    static QJsonArray fromVariantList(const QVariantList &list);
+    QVariantList toVariantList() const;
+
+    int size() const;
+    inline int count() const { return size(); }
+
+    bool isEmpty() const;
+    QJsonValue at(int i) const;
+    QJsonValue first() const;
+    QJsonValue last() const;
+
+    void prepend(const QJsonValue &value);
+    void append(const QJsonValue &value);
+    void removeAt(int i);
+    QJsonValue takeAt(int i);
+    inline void removeFirst() { removeAt(0); }
+    inline void removeLast() { removeAt(size() - 1); }
+
+    void insert(int i, const QJsonValue &value);
+    void replace(int i, const QJsonValue &value);
+
+    bool contains(const QJsonValue &element) const;
+    QJsonValueRef operator[](int i);
+    QJsonValue operator[](int i) const;
+
+    bool operator==(const QJsonArray &other) const;
+    bool operator!=(const QJsonArray &other) const;
+
+    class const_iterator;
+
+    class iterator {
+    public:
+        QJsonArray *a;
+        int i;
+        typedef std::random_access_iterator_tag iterator_category;
+        typedef int difference_type;
+        typedef QJsonValue value_type;
+        typedef QJsonValueRef reference;
+        typedef QJsonValueRefPtr pointer;
+
+        inline iterator() : a(nullptr), i(0) { }
+        explicit inline iterator(QJsonArray *array, int index) : a(array), i(index) { }
+
+        inline QJsonValueRef operator*() const { return QJsonValueRef(a, i); }
+
+
+
+        inline QJsonValueRefPtr operator->() const { return QJsonValueRefPtr(a, i); }
+
+        inline QJsonValueRef operator[](int j) const { return QJsonValueRef(a, i + j); }
+
+        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) { iterator n = *this; ++i; return n; }
+        inline iterator &operator--() { i--; return *this; }
+        inline iterator operator--(int) { iterator n = *this; 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(a, i+j); }
+        inline iterator operator-(int j) const { return iterator(a, i-j); }
+        inline int operator-(iterator j) const { return i - j.i; }
+    };
+    friend class iterator;
+
+    class const_iterator {
+    public:
+        const QJsonArray *a;
+        int i;
+        typedef std::random_access_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef QJsonValue value_type;
+        typedef QJsonValue reference;
+        typedef QJsonValuePtr pointer;
+
+        inline const_iterator() : a(nullptr), i(0) { }
+        explicit inline const_iterator(const QJsonArray *array, int index) : a(array), i(index) { }
+
+        inline const_iterator(const const_iterator &o) : a(o.a), i(o.i) {}
+
+        inline const_iterator(const iterator &o) : a(o.a), i(o.i) {}
+
+        inline QJsonValue operator*() const { return a->at(i); }
+
+
+
+        inline QJsonValuePtr operator->() const { return QJsonValuePtr(a->at(i)); }
+
+        inline QJsonValue operator[](int j) const { return a->at(i+j); }
+        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) { const_iterator n = *this; ++i; return n; }
+        inline const_iterator &operator--() { i--; return *this; }
+        inline const_iterator operator--(int) { const_iterator n = *this; 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(a, i+j); }
+        inline const_iterator operator-(int j) const { return const_iterator(a, i-j); }
+        inline int operator-(const_iterator j) const { return i - j.i; }
+    };
+    friend class const_iterator;
+
+
+    inline iterator begin() { detach2(); return iterator(this, 0); }
+    inline const_iterator begin() const { return const_iterator(this, 0); }
+    inline const_iterator constBegin() const { return const_iterator(this, 0); }
+    inline iterator end() { detach2(); return iterator(this, size()); }
+    inline const_iterator end() const { return const_iterator(this, size()); }
+    inline const_iterator constEnd() const { return const_iterator(this, size()); }
+    iterator insert(iterator before, const QJsonValue &value) { insert(before.i, value); return before; }
+    iterator erase(iterator it) { removeAt(it.i); return it; }
+
+
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+
+
+    inline QJsonArray operator+(const QJsonValue &v) const
+    { QJsonArray n = *this; n += v; return n; }
+    inline QJsonArray &operator+=(const QJsonValue &v)
+    { append(v); return *this; }
+    inline QJsonArray &operator<< (const QJsonValue &v)
+    { append(v); return *this; }
+
+
+    inline void push_back(const QJsonValue &t) { append(t); }
+    inline void push_front(const QJsonValue &t) { prepend(t); }
+    inline void pop_front() { removeFirst(); }
+    inline void pop_back() { removeLast(); }
+    inline bool empty() const { return isEmpty(); }
+    typedef int size_type;
+    typedef QJsonValue value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef QJsonValueRef reference;
+    typedef QJsonValue const_reference;
+    typedef int difference_type;
+
+private:
+    friend class QJsonPrivate::Data;
+    friend class QJsonValue;
+    friend class QJsonDocument;
+    friend __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QJsonArray &);
+
+    QJsonArray(QJsonPrivate::Data *data, QJsonPrivate::Array *array);
+    void initialize();
+    void compact();
+
+    void detach(uint reserve = 0);
+    bool detach2(uint reserve = 0);
+
+    QJsonPrivate::Data *d;
+    QJsonPrivate::Array *a;
+};
+
+
+__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QJsonArray &);
+
+
+
+# 1 "../../include/QtCore/qjsonarray.h" 2
+# 43 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp" 2
+# 1 "../../include/QtCore/qvariant.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h"
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+# 1 "../../include/QtCore/qatomic.h" 2
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+# 1 "../../include/QtCore/qbytearray.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+# 1 "../../include/QtCore/qlist.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h"
+# 1 "../../include/QtCore/qalgorithms.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h" 2
+
+
+
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+#pragma GCC diagnostic push
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+
+
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+
+
+
+
+
+
+
+namespace QAlgorithmsPrivate {
+
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+__attribute__ ((__deprecated__("Use std::sort"))) void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
+template <typename RandomAccessIterator, typename T>
+__attribute__ ((__deprecated__("Use std::sort"))) inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy);
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+__attribute__ ((__deprecated__("Use std::stable_sort"))) void qStableSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
+template <typename RandomAccessIterator, typename T>
+__attribute__ ((__deprecated__("Use std::stable_sort"))) inline void qStableSortHelper(RandomAccessIterator, RandomAccessIterator, const T &);
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+__attribute__ ((__deprecated__("Use std::lower_bound"))) RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
+template <typename RandomAccessIterator, typename T, typename LessThan>
+__attribute__ ((__deprecated__("Use std::upper_bound"))) RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
+template <typename RandomAccessIterator, typename T, typename LessThan>
+__attribute__ ((__deprecated__("Use std::binary_search"))) RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
+
+
+}
+
+
+template <typename InputIterator, typename OutputIterator>
+__attribute__ ((__deprecated__("Use std::copy"))) inline OutputIterator qCopy(InputIterator begin, InputIterator end, OutputIterator dest)
+{
+    while (begin != end)
+        *dest++ = *begin++;
+    return dest;
+}
+
+template <typename BiIterator1, typename BiIterator2>
+__attribute__ ((__deprecated__("Use std::copy_backward"))) inline BiIterator2 qCopyBackward(BiIterator1 begin, BiIterator1 end, BiIterator2 dest)
+{
+    while (begin != end)
+        *--dest = *--end;
+    return dest;
+}
+
+template <typename InputIterator1, typename InputIterator2>
+__attribute__ ((__deprecated__("Use std::equal"))) 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>
+__attribute__ ((__deprecated__("Use std::fill"))) inline void qFill(ForwardIterator first, ForwardIterator last, const T &val)
+{
+    for (; first != last; ++first)
+        *first = val;
+}
+
+template <typename Container, typename T>
+__attribute__ ((__deprecated__("Use std::fill"))) inline void qFill(Container &container, const T &val)
+{
+    qFill(container.begin(), container.end(), val);
+}
+
+template <typename InputIterator, typename T>
+__attribute__ ((__deprecated__("Use std::find"))) inline InputIterator qFind(InputIterator first, InputIterator last, const T &val)
+{
+    while (first != last && !(*first == val))
+        ++first;
+    return first;
+}
+
+template <typename Container, typename T>
+__attribute__ ((__deprecated__("Use std::find"))) 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>
+__attribute__ ((__deprecated__("Use std::count"))) 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>
+__attribute__ ((__deprecated__("Use std::count"))) inline void qCount(const Container &container, const T &value, Size &n)
+{
+    qCount(container.constBegin(), container.constEnd(), value, n);
+}
+# 155 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+template <typename T>
+class __attribute__ ((__deprecated__("Use std::less"))) qLess
+{
+public:
+    inline bool operator()(const T &t1, const T &t2) const
+    {
+        return (t1 < t2);
+    }
+};
+
+template <typename T>
+class __attribute__ ((__deprecated__("Use std::greater"))) qGreater
+{
+public:
+    inline bool operator()(const T &t1, const T &t2) const
+    {
+        return (t2 < t1);
+    }
+};
+
+
+template <typename RandomAccessIterator>
+__attribute__ ((__deprecated__("Use std::sort"))) inline void qSort(RandomAccessIterator start, RandomAccessIterator end)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qSortHelper(start, end, *start);
+}
+
+template <typename RandomAccessIterator, typename LessThan>
+__attribute__ ((__deprecated__("Use std::sort"))) inline void qSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qSortHelper(start, end, *start, lessThan);
+}
+
+template<typename Container>
+__attribute__ ((__deprecated__("Use std::sort"))) inline void qSort(Container &c)
+{
+
+
+
+
+    if (!c.empty())
+        QAlgorithmsPrivate::qSortHelper(c.begin(), c.end(), *c.begin());
+}
+
+template <typename RandomAccessIterator>
+__attribute__ ((__deprecated__("Use std::stable_sort"))) inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qStableSortHelper(start, end, *start);
+}
+
+template <typename RandomAccessIterator, typename LessThan>
+__attribute__ ((__deprecated__("Use std::stable_sort"))) inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qStableSortHelper(start, end, *start, lessThan);
+}
+
+template<typename Container>
+__attribute__ ((__deprecated__("Use std::stable_sort"))) inline void qStableSort(Container &c)
+{
+
+
+
+
+    if (!c.empty())
+        QAlgorithmsPrivate::qStableSortHelper(c.begin(), c.end(), *c.begin());
+}
+
+template <typename RandomAccessIterator, typename T>
+__attribute__ ((__deprecated__("Use std::lower_bound"))) 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>
+__attribute__ ((__deprecated__("Use std::lower_bound"))) RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    return QAlgorithmsPrivate::qLowerBoundHelper(begin, end, value, lessThan);
+}
+
+template <typename Container, typename T>
+__attribute__ ((__deprecated__("Use std::lower_bound"))) 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>
+__attribute__ ((__deprecated__("Use std::upper_bound"))) 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>
+__attribute__ ((__deprecated__("Use std::upper_bound"))) RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    return QAlgorithmsPrivate::qUpperBoundHelper(begin, end, value, lessThan);
+}
+
+template <typename Container, typename T>
+__attribute__ ((__deprecated__("Use std::upper_bound"))) 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>
+__attribute__ ((__deprecated__("Use std::binary_search"))) 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>
+__attribute__ ((__deprecated__("Use std::binary_search"))) RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    return QAlgorithmsPrivate::qBinaryFindHelper(begin, end, value, lessThan);
+}
+
+template <typename Container, typename T>
+__attribute__ ((__deprecated__("Use std::binary_search"))) 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>
+__attribute__ ((__deprecated__("Use std::sort"))) 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>
+__attribute__ ((__deprecated__("Use std::sort"))) inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
+{
+    qSortHelper(begin, end, dummy, qLess<T>());
+}
+
+template <typename RandomAccessIterator>
+__attribute__ ((__deprecated__("Use std::reverse"))) void qReverse(RandomAccessIterator begin, RandomAccessIterator end)
+{
+    --end;
+    while (begin < end)
+        qSwap(*begin++, *end--);
+}
+
+template <typename RandomAccessIterator>
+__attribute__ ((__deprecated__("Use std::rotate"))) void qRotate(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end)
+{
+    qReverse(begin, middle);
+    qReverse(middle, end);
+    qReverse(begin, end);
+}
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+__attribute__ ((__deprecated__("Use std::merge"))) 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>
+__attribute__ ((__deprecated__("Use std::stable_sort"))) 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>
+__attribute__ ((__deprecated__("Use std::stable_sort"))) inline void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
+{
+    qStableSortHelper(begin, end, dummy, qLess<T>());
+}
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+__attribute__ ((__deprecated__("Use std::lower_bound"))) 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>
+__attribute__ ((__deprecated__("Use std::upper_bound"))) 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>
+__attribute__ ((__deprecated__("Use std::binary_search"))) 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;
+}
+
+
+
+}
+# 535 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+__attribute__((const)) constexpr inline uint qPopulationCount(quint32 v) noexcept
+{
+
+    return __builtin_popcount(v);
+
+
+
+
+
+
+
+}
+
+__attribute__((const)) constexpr inline uint qPopulationCount(quint8 v) noexcept
+{
+
+    return __builtin_popcount(v);
+
+
+
+
+}
+
+__attribute__((const)) constexpr inline uint qPopulationCount(quint16 v) noexcept
+{
+
+    return __builtin_popcount(v);
+
+
+
+
+
+}
+
+__attribute__((const)) constexpr inline uint qPopulationCount(quint64 v) noexcept
+{
+
+    return __builtin_popcountll(v);
+# 582 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+}
+
+__attribute__((const)) constexpr inline uint qPopulationCount(long unsigned int v) noexcept
+{
+    return qPopulationCount(static_cast<quint64>(v));
+}
+
+
+
+
+
+constexpr inline uint qCountTrailingZeroBits(quint32 v) noexcept
+{
+
+    return v ? __builtin_ctz(v) : 32U;
+# 609 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+}
+
+constexpr inline uint qCountTrailingZeroBits(quint8 v) noexcept
+{
+
+    return v ? __builtin_ctz(v) : 8U;
+# 624 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+}
+
+constexpr inline uint qCountTrailingZeroBits(quint16 v) noexcept
+{
+
+
+
+
+    return v ? __builtin_ctz(v) : 16U;
+# 644 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+}
+
+constexpr inline uint qCountTrailingZeroBits(quint64 v) noexcept
+{
+
+    return v ? __builtin_ctzll(v) : 64;
+
+
+
+
+
+}
+
+constexpr inline uint qCountTrailingZeroBits(unsigned long v) noexcept
+{
+    return qCountTrailingZeroBits(QIntegerForSizeof<long>::Unsigned(v));
+}
+
+constexpr inline uint qCountLeadingZeroBits(quint32 v) noexcept
+{
+
+    return v ? __builtin_clz(v) : 32U;
+# 675 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+}
+
+constexpr inline uint qCountLeadingZeroBits(quint8 v) noexcept
+{
+
+    return v ? __builtin_clz(v)-24U : 8U;
+
+
+
+
+
+
+}
+
+constexpr inline uint qCountLeadingZeroBits(quint16 v) noexcept
+{
+
+
+
+
+    return v ? __builtin_clz(v)-16U : 16U;
+# 704 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+}
+
+constexpr inline uint qCountLeadingZeroBits(quint64 v) noexcept
+{
+
+    return v ? __builtin_clzll(v) : 64U;
+# 719 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+}
+
+constexpr inline uint qCountLeadingZeroBits(unsigned long v) noexcept
+{
+    return qCountLeadingZeroBits(QIntegerForSizeof<long>::Unsigned(v));
+}
+
+
+# 726 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+#pragma GCC diagnostic pop
+# 726 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qalgorithms.h"
+
+
+# 1 "../../include/QtCore/qalgorithms.h" 2
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 2
+# 1 "../../include/QtCore/qiterator.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 2
+# 1 "../../include/QtCore/qrefcount.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 2
+# 1 "../../include/QtCore/qarraydata.h" 1
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 2
+# 1 "../../include/QtCore/qhashfunctions.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhashfunctions.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhashfunctions.h"
+# 1 "../../include/QtCore/qchar.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhashfunctions.h" 2
+# 1 "../../include/QtCore/qpair.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhashfunctions.h" 2
+# 59 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhashfunctions.h"
+
+
+class QBitArray;
+class QByteArray;
+class QString;
+class QStringRef;
+class QLatin1String;
+
+__attribute__((visibility("default"))) __attribute__((pure)) uint qHashBits(const void *p, size_t size, uint seed = 0) noexcept;
+
+__attribute__((const)) constexpr inline uint qHash(char key, uint seed = 0) noexcept { return uint(key) ^ seed; }
+__attribute__((const)) constexpr inline uint qHash(uchar key, uint seed = 0) noexcept { return uint(key) ^ seed; }
+__attribute__((const)) constexpr inline uint qHash(signed char key, uint seed = 0) noexcept { return uint(key) ^ seed; }
+__attribute__((const)) constexpr inline uint qHash(ushort key, uint seed = 0) noexcept { return uint(key) ^ seed; }
+__attribute__((const)) constexpr inline uint qHash(short key, uint seed = 0) noexcept { return uint(key) ^ seed; }
+__attribute__((const)) constexpr inline uint qHash(uint key, uint seed = 0) noexcept { return key ^ seed; }
+__attribute__((const)) constexpr inline uint qHash(int key, uint seed = 0) noexcept { return uint(key) ^ seed; }
+__attribute__((const)) constexpr inline uint qHash(ulong key, uint seed = 0) noexcept
+{
+    return (sizeof(ulong) > sizeof(uint))
+        ? (uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)) ^ seed)
+        : (uint(key & (~0U)) ^ seed);
+}
+__attribute__((const)) constexpr inline uint qHash(long key, uint seed = 0) noexcept { return qHash(ulong(key), seed); }
+__attribute__((const)) constexpr inline uint qHash(quint64 key, uint seed = 0) noexcept
+{
+    return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U)) ^ seed;
+}
+__attribute__((const)) constexpr inline uint qHash(qint64 key, uint seed = 0) noexcept { return qHash(quint64(key), seed); }
+__attribute__((visibility("default"))) __attribute__((const)) uint qHash(float key, uint seed = 0) noexcept;
+__attribute__((visibility("default"))) __attribute__((const)) uint qHash(double key, uint seed = 0) noexcept;
+
+__attribute__((visibility("default"))) __attribute__((const)) uint qHash(long double key, uint seed = 0) noexcept;
+
+__attribute__((const)) constexpr inline uint qHash(const QChar key, uint seed = 0) noexcept { return qHash(key.unicode(), seed); }
+__attribute__((visibility("default"))) __attribute__((pure)) uint qHash(const QByteArray &key, uint seed = 0) noexcept;
+__attribute__((visibility("default"))) __attribute__((pure)) uint qHash(const QString &key, uint seed = 0) noexcept;
+__attribute__((visibility("default"))) __attribute__((pure)) uint qHash(const QStringRef &key, uint seed = 0) noexcept;
+__attribute__((visibility("default"))) __attribute__((pure)) uint qHash(const QBitArray &key, uint seed = 0) noexcept;
+__attribute__((visibility("default"))) __attribute__((pure)) uint qHash(QLatin1String key, uint seed = 0) noexcept;
+__attribute__((visibility("default"))) __attribute__((pure)) uint qt_hash(const QString &key) noexcept;
+__attribute__((visibility("default"))) __attribute__((pure)) uint qt_hash(const QStringRef &key) noexcept;
+
+template <class T> inline uint qHash(const T *key, uint seed = 0) noexcept
+{
+    return qHash(reinterpret_cast<quintptr>(key), seed);
+}
+template<typename T> inline uint qHash(const T &t, uint seed)
+    noexcept(noexcept(qHash(t)))
+{ return qHash(t) ^ seed; }
+
+namespace QtPrivate {
+
+struct QHashCombine {
+    typedef uint result_type;
+    template <typename T>
+    constexpr result_type operator()(uint seed, const T &t) const noexcept(noexcept(qHash(t)))
+
+    { return seed ^ (qHash(t) + 0x9e3779b9 + (seed << 6) + (seed >> 2)) ; }
+};
+
+struct QHashCombineCommutative {
+
+
+
+
+
+    typedef uint result_type;
+    template <typename T>
+    constexpr result_type operator()(uint seed, const T &t) const noexcept(noexcept(qHash(t)))
+    { return seed + qHash(t); }
+};
+
+}
+
+template <typename InputIterator>
+inline uint qHashRange(InputIterator first, InputIterator last, uint seed = 0)
+    noexcept(noexcept(qHash(*first)))
+{
+    return std::accumulate(first, last, seed, QtPrivate::QHashCombine());
+}
+
+template <typename InputIterator>
+inline uint qHashRangeCommutative(InputIterator first, InputIterator last, uint seed = 0)
+    noexcept(noexcept(qHash(*first)))
+{
+    return std::accumulate(first, last, seed, QtPrivate::QHashCombineCommutative());
+}
+
+template <typename T1, typename T2> inline uint qHash(const QPair<T1, T2> &key, uint seed = 0)
+    noexcept(noexcept(qHash(key.first, seed)) && noexcept(qHash(key.second, seed)))
+{
+    uint h1 = qHash(key.first, seed);
+    uint h2 = qHash(key.second, seed);
+    return ((h1 << 16) | (h1 >> 16)) ^ h2 ^ seed;
+}
+
+template <typename T1, typename T2> inline uint qHash(const std::pair<T1, T2> &key, uint seed = 0)
+    noexcept(noexcept(qHash(key.first, seed)) && noexcept(qHash(key.second, seed)))
+{
+    QtPrivate::QHashCombine hash;
+    seed = hash(seed, key.first);
+    seed = hash(seed, key.second);
+    return seed;
+}
+
+
+# 1 "../../include/QtCore/qhashfunctions.h" 2
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 2
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/list" 1 3
+# 58 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/list" 3
+       
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/list" 3
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 1 3
+# 64 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+
+# 64 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+  namespace __detail
+  {
+ 
+# 77 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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() noexcept
+      : _M_node() { }
+
+      explicit
+      _List_iterator(__detail::_List_node_base* __x) noexcept
+      : _M_node(__x) { }
+
+      _Self
+      _M_const_cast() const noexcept
+      { return *this; }
+
+
+      reference
+      operator*() const noexcept
+      { return static_cast<_Node*>(_M_node)->_M_data; }
+
+      pointer
+      operator->() const noexcept
+      { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
+
+      _Self&
+      operator++() noexcept
+      {
+ _M_node = _M_node->_M_next;
+ return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_next;
+ return __tmp;
+      }
+
+      _Self&
+      operator--() noexcept
+      {
+ _M_node = _M_node->_M_prev;
+ return *this;
+      }
+
+      _Self
+      operator--(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_prev;
+ return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const noexcept
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const noexcept
+      { 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() noexcept
+      : _M_node() { }
+
+      explicit
+      _List_const_iterator(const __detail::_List_node_base* __x)
+      noexcept
+      : _M_node(__x) { }
+
+      _List_const_iterator(const iterator& __x) noexcept
+      : _M_node(__x._M_node) { }
+
+      iterator
+      _M_const_cast() const noexcept
+      { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); }
+
+
+
+      reference
+      operator*() const noexcept
+      { return static_cast<_Node*>(_M_node)->_M_data; }
+
+      pointer
+      operator->() const noexcept
+      { return std::__addressof(static_cast<_Node*>(_M_node)->_M_data); }
+
+      _Self&
+      operator++() noexcept
+      {
+ _M_node = _M_node->_M_next;
+ return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_next;
+ return __tmp;
+      }
+
+      _Self&
+      operator--() noexcept
+      {
+ _M_node = _M_node->_M_prev;
+ return *this;
+      }
+
+      _Self
+      operator--(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_prev;
+ return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const noexcept
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const noexcept
+      { 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) noexcept
+    { return __x._M_node == __y._M_node; }
+
+  template<typename _Val>
+    inline bool
+    operator!=(const _List_iterator<_Val>& __x,
+               const _List_const_iterator<_Val>& __y) noexcept
+    { return __x._M_node != __y._M_node; }
+
+namespace __cxx11 {
+
+  template<typename _Tp, typename _Alloc>
+    class _List_base
+    {
+    protected:
+# 314 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
+        _Node_alloc_type;
+
+      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+
+      static size_t
+      _S_distance(const __detail::_List_node_base* __first,
+    const __detail::_List_node_base* __last)
+      {
+ size_t __n = 0;
+ while (__first != __last)
+   {
+     __first = __first->_M_next;
+     ++__n;
+   }
+ return __n;
+      }
+
+      struct _List_impl
+      : public _Node_alloc_type
+      {
+
+ _List_node<size_t> _M_node;
+
+
+
+
+ _List_impl()
+ : _Node_alloc_type(), _M_node()
+ { }
+
+ _List_impl(const _Node_alloc_type& __a) noexcept
+ : _Node_alloc_type(__a), _M_node()
+ { }
+
+
+ _List_impl(_Node_alloc_type&& __a) noexcept
+ : _Node_alloc_type(std::move(__a)), _M_node()
+ { }
+
+      };
+
+      _List_impl _M_impl;
+
+
+      size_t _M_get_size() const { return _M_impl._M_node._M_data; }
+
+      void _M_set_size(size_t __n) { _M_impl._M_node._M_data = __n; }
+
+      void _M_inc_size(size_t __n) { _M_impl._M_node._M_data += __n; }
+
+      void _M_dec_size(size_t __n) { _M_impl._M_node._M_data -= __n; }
+
+      size_t
+      _M_distance(const __detail::_List_node_base* __first,
+    const __detail::_List_node_base* __last) const
+      { return _S_distance(__first, __last); }
+
+
+      size_t _M_node_count() const { return _M_impl._M_node._M_data; }
+# 390 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      _List_node<_Tp>*
+      _M_get_node()
+      { return _M_impl._Node_alloc_type::allocate(1); }
+
+      void
+      _M_put_node(_List_node<_Tp>* __p) noexcept
+      { _M_impl._Node_alloc_type::deallocate(__p, 1); }
+
+  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) noexcept
+      : _M_impl(__a)
+      { _M_init(); }
+
+
+      _List_base(_List_base&& __x) noexcept
+      : _M_impl(std::move(__x._M_get_Node_allocator()))
+      {
+ auto* const __xnode = std::__addressof(__x._M_impl._M_node);
+ if (__xnode->_M_next == __xnode)
+   _M_init();
+ else
+   {
+     auto* const __node = std::__addressof(_M_impl._M_node);
+     __node->_M_next = __xnode->_M_next;
+     __node->_M_prev = __xnode->_M_prev;
+     __node->_M_next->_M_prev = __node->_M_prev->_M_next = __node;
+     _M_set_size(__x._M_get_size());
+     __x._M_init();
+   }
+      }
+
+
+
+      ~_List_base() noexcept
+      { _M_clear(); }
+
+      void
+      _M_clear() noexcept;
+
+      void
+      _M_init() noexcept
+      {
+        this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
+        this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
+ _M_set_size(0);
+      }
+    };
+# 506 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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;
+# 567 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()
+
+      noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value)
+
+      : _Base() { }
+
+
+
+
+
+      explicit
+      list(const allocator_type& __a) noexcept
+      : _Base(_Node_alloc_type(__a)) { }
+# 615 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      explicit
+      list(size_type __n)
+      : _Base()
+      { _M_default_initialize(__n); }
+# 628 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 655 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      list(const list& __x)
+      : _Base(__x._M_get_Node_allocator())
+      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
+# 667 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      list(list&& __x) noexcept
+      : _Base(std::move(__x)) { }
+# 678 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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()); }
+# 695 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        list(_InputIterator __first, _InputIterator __last,
+      const allocator_type& __a = allocator_type())
+ : _Base(_Node_alloc_type(__a))
+        { _M_initialize_dispatch(__first, __last, __false_type()); }
+# 728 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      list&
+      operator=(const list& __x);
+# 739 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      list&
+      operator=(list&& __x)
+      {
+
+
+ this->clear();
+ this->swap(__x);
+ return *this;
+      }
+# 756 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      list&
+      operator=(initializer_list<value_type> __l)
+      {
+ this->assign(__l.begin(), __l.end());
+ return *this;
+      }
+# 774 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 791 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        { _M_assign_dispatch(__first, __last, __false_type()); }
+# 815 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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_node_count(); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _M_get_Node_allocator().max_size(); }
+# 964 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      resize(size_type __new_size);
+# 977 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      resize(size_type __new_size, const value_type& __x);
+# 999 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      reference
+      front() noexcept
+      { return *begin(); }
+
+
+
+
+
+      const_reference
+      front() const noexcept
+      { return *begin(); }
+
+
+
+
+
+      reference
+      back() noexcept
+      {
+ iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      {
+ const_iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+# 1046 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)...); }
+# 1073 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      pop_front() noexcept
+      { this->_M_erase(begin()); }
+# 1087 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)...); }
+# 1113 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      pop_back() noexcept
+      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
+# 1130 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      template<typename... _Args>
+        iterator
+        emplace(const_iterator __position, _Args&&... __args);
+# 1145 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+# 1175 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+# 1194 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __p, initializer_list<value_type> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+# 1214 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x);
+# 1253 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+ insert(const_iterator __position, _InputIterator __first,
+        _InputIterator __last);
+# 1297 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      iterator
+
+      erase(const_iterator __position) noexcept;
+# 1322 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      iterator
+
+      erase(const_iterator __first, const_iterator __last) noexcept
+
+
+
+      {
+ while (__first != __last)
+   __first = erase(__first);
+ return __last._M_const_cast();
+      }
+# 1343 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      swap(list& __x)
+      {
+ __detail::_List_node_base::swap(this->_M_impl._M_node,
+     __x._M_impl._M_node);
+
+ size_t __xsize = __x._M_get_size();
+ __x._M_set_size(this->_M_get_size());
+ this->_M_set_size(__xsize);
+
+
+
+ std::__alloc_swap<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();
+      }
+# 1384 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+
+      splice(const_iterator __position, list&& __x) noexcept
+
+
+
+      {
+ if (!__x.empty())
+   {
+     _M_check_equal_allocators(__x);
+
+     this->_M_transfer(__position._M_const_cast(),
+         __x.begin(), __x.end());
+
+     this->_M_inc_size(__x._M_get_size());
+     __x._M_set_size(0);
+   }
+      }
+
+
+      void
+      splice(const_iterator __position, list& __x) noexcept
+      { splice(__position, std::move(__x)); }
+# 1420 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list&& __x, const_iterator __i) noexcept
+# 1435 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      {
+ iterator __j = __i._M_const_cast();
+ ++__j;
+ if (__position == __i || __position == __j)
+   return;
+
+ if (this != &__x)
+   _M_check_equal_allocators(__x);
+
+ this->_M_transfer(__position._M_const_cast(),
+     __i._M_const_cast(), __j);
+
+ this->_M_inc_size(1);
+ __x._M_dec_size(1);
+      }
+# 1462 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list& __x, const_iterator __i) noexcept
+      { splice(__position, std::move(__x), __i); }
+# 1481 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list&& __x, const_iterator __first,
+      const_iterator __last) noexcept
+# 1501 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      {
+ if (__first != __last)
+   {
+     if (this != &__x)
+       _M_check_equal_allocators(__x);
+
+     size_t __n = this->_M_distance(__first._M_node, __last._M_node);
+     this->_M_inc_size(__n);
+     __x._M_dec_size(__n);
+
+     this->_M_transfer(__position._M_const_cast(),
+         __first._M_const_cast(),
+         __last._M_const_cast());
+   }
+      }
+# 1531 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list& __x, const_iterator __first,
+      const_iterator __last) noexcept
+      { splice(__position, std::move(__x), __first, __last); }
+# 1548 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      remove(const _Tp& __value);
+# 1562 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      template<typename _Predicate>
+        void
+        remove_if(_Predicate);
+# 1576 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      unique();
+# 1591 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      template<typename _BinaryPredicate>
+        void
+        unique(_BinaryPredicate);
+# 1605 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+      void
+      merge(list&& __x);
+
+      void
+      merge(list& __x)
+      { merge(std::move(__x)); }
+# 1630 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 1649 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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)
+
+     emplace_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);
+# 1727 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+# 1759 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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);
+  this->_M_inc_size(1);
+       }
+
+
+
+      void
+      _M_erase(iterator __position) noexcept
+      {
+ this->_M_dec_size(1);
+        __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) noexcept
+      {
+ if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
+     _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
+   __builtin_abort();
+      }
+    };
+}
+# 1805 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    {
+      typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
+      const_iterator __end1 = __x.end();
+      const_iterator __end2 = __y.end();
+
+      const_iterator __i1 = __x.begin();
+      const_iterator __i2 = __y.begin();
+      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
+ {
+   ++__i1;
+   ++__i2;
+ }
+      return __i1 == __end1 && __i2 == __end2;
+    }
+# 1834 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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); }
+
+
+}
+# 64 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/list" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/list.tcc" 1 3
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/list.tcc" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _List_base<_Tp, _Alloc>::
+    _M_clear() noexcept
+    {
+      typedef _List_node<_Tp> _Node;
+      __detail::_List_node_base* __cur = _M_impl._M_node._M_next;
+      while (__cur != &_M_impl._M_node)
+ {
+   _Node* __tmp = static_cast<_Node*>(__cur);
+   __cur = __tmp->_M_next;
+
+   _M_get_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(const_iterator __position, _Args&&... __args)
+      {
+ _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
+ __tmp->_M_hook(__position._M_const_cast()._M_node);
+ this->_M_inc_size(1);
+ return iterator(__tmp);
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+
+    insert(const_iterator __position, const value_type& __x)
+
+
+
+    {
+      _Node* __tmp = _M_create_node(__x);
+      __tmp->_M_hook(__position._M_const_cast()._M_node);
+      this->_M_inc_size(1);
+      return iterator(__tmp);
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+    insert(const_iterator __position, size_type __n, const value_type& __x)
+    {
+      if (__n)
+ {
+   list __tmp(__n, __x, get_allocator());
+   iterator __it = __tmp.begin();
+   splice(__position, __tmp);
+   return __it;
+ }
+      return __position._M_const_cast();
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator, typename>
+      typename list<_Tp, _Alloc>::iterator
+      list<_Tp, _Alloc>::
+      insert(const_iterator __position, _InputIterator __first,
+      _InputIterator __last)
+      {
+ list __tmp(__first, __last, get_allocator());
+ if (!__tmp.empty())
+   {
+     iterator __it = __tmp.begin();
+     splice(__position, __tmp);
+     return __it;
+   }
+ return __position._M_const_cast();
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+
+    erase(const_iterator __position) noexcept
+
+
+
+    {
+      iterator __ret = iterator(__position._M_node->_M_next);
+      _M_erase(__position._M_const_cast());
+      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)
+    {
+      iterator __i = begin();
+      size_type __len = 0;
+      for (; __i != end() && __len < __new_size; ++__i, ++__len)
+        ;
+      if (__len == __new_size)
+        erase(__i, end());
+      else
+ _M_default_append(__new_size - __len);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    resize(size_type __new_size, const value_type& __x)
+    {
+      iterator __i = begin();
+      size_type __len = 0;
+      for (; __i != end() && __len < __new_size; ++__i, ++__len)
+        ;
+      if (__len == __new_size)
+        erase(__i, end());
+      else
+        insert(end(), __new_size - __len, __x);
+    }
+# 226 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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_inc_size(__x._M_get_size());
+   __x._M_set_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_inc_size(__x._M_get_size());
+     __x._M_set_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));
+   }
+      }
+
+
+}
+# 65 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/list" 2 3
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 2
+
+
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/limits.h" 1 3 4
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/limits.h" 3 4
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/syslimits.h" 1 3 4
+
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/limits.h" 1 3 4
+# 168 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/limits.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/limits.h" 1 3 4
+# 143 "/mnt/odroid-c2/usr/include/limits.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/posix1_lim.h" 1 3 4
+# 160 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/posix1_lim.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/local_lim.h" 1 3 4
+# 39 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/local_lim.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/linux/limits.h" 1 3 4
+# 40 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/local_lim.h" 2 3 4
+# 161 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/posix1_lim.h" 2 3 4
+# 144 "/mnt/odroid-c2/usr/include/limits.h" 2 3 4
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/posix2_lim.h" 1 3 4
+# 148 "/mnt/odroid-c2/usr/include/limits.h" 2 3 4
+
+
+
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/xopen_lim.h" 1 3 4
+# 33 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/xopen_lim.h" 3 4
+# 1 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/stdio_lim.h" 1 3 4
+# 34 "/mnt/odroid-c2/usr/include/aarch64-linux-gnu/bits/xopen_lim.h" 2 3 4
+# 152 "/mnt/odroid-c2/usr/include/limits.h" 2 3 4
+# 169 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/limits.h" 2 3 4
+# 8 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/syslimits.h" 2 3 4
+# 35 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/limits.h" 2 3 4
+# 59 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 2
+
+
+
+
+
+
+
+
+
+
+
+# 69 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h"
+template <typename T> class QVector;
+template <typename T> class QSet;
+
+template <typename T> struct QListSpecialMethods
+{
+protected:
+    ~QListSpecialMethods() {}
+};
+template <> struct QListSpecialMethods<QByteArray>;
+template <> struct QListSpecialMethods<QString>;
+
+struct __attribute__((visibility("default"))) QListData {
+
+
+    struct NotArrayCompatibleLayout {};
+    struct NotIndirectLayout {};
+    struct ArrayCompatibleLayout : NotIndirectLayout {};
+    struct InlineWithPaddingLayout : NotArrayCompatibleLayout, NotIndirectLayout {};
+    struct IndirectLayout : NotArrayCompatibleLayout {};
+
+    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);
+    void realloc_grow(int growth);
+    inline void dispose() { dispose(d); }
+    static void dispose(Data *d);
+    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 noexcept { return d->end - d->begin; }
+    inline bool isEmpty() const noexcept { return d->end == d->begin; }
+    inline void **at(int i) const noexcept { return d->array + d->begin + i; }
+    inline void **begin() const noexcept { return d->array + d->begin; }
+    inline void **end() const noexcept { return d->array + d->end; }
+};
+
+template <typename T>
+class QList : public QListSpecialMethods<T>
+{
+public:
+    struct MemoryLayout
+        : QtPrivate::if_<
+            QTypeInfo<T>::isStatic || QTypeInfo<T>::isLarge,
+            QListData::IndirectLayout,
+            typename QtPrivate::if_<
+                sizeof(T) == sizeof(void*),
+                QListData::ArrayCompatibleLayout,
+                QListData::InlineWithPaddingLayout
+             >::type>::type {};
+private:
+    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() noexcept : 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) noexcept
+        : d(other.d) { other.d = const_cast<QListData::Data *>(&QListData::shared_null); }
+    inline QList &operator=(QList<T> &&other) noexcept
+    { QList moved(std::move(other)); swap(moved); return *this; }
+
+    inline void swap(QList<T> &other) noexcept { qSwap(d, other.d); }
+
+    inline QList(std::initializer_list<T> args)
+        : d(const_cast<QListData::Data *>(&QListData::shared_null))
+    { reserve(int(args.size())); std::copy(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 noexcept { 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 noexcept { return d == other.d; }
+
+    inline bool isEmpty() const noexcept { 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() noexcept : i(nullptr) {}
+        inline iterator(Node *n) noexcept : i(n) {}
+
+
+
+        inline iterator(const iterator &o) noexcept : i(o.i){}
+
+        inline T &operator*() const { return i->t(); }
+        inline T *operator->() const { return &i->t(); }
+        inline T &operator[](difference_type j) const { return i[j].t(); }
+        inline bool operator==(const iterator &o) const noexcept { return i == o.i; }
+        inline bool operator!=(const iterator &o) const noexcept { return i != o.i; }
+        inline bool operator<(const iterator& other) const noexcept { return i < other.i; }
+        inline bool operator<=(const iterator& other) const noexcept { return i <= other.i; }
+        inline bool operator>(const iterator& other) const noexcept { return i > other.i; }
+        inline bool operator>=(const iterator& other) const noexcept { return i >= other.i; }
+
+        inline bool operator==(const const_iterator &o) const noexcept
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const noexcept
+            { return i != o.i; }
+        inline bool operator<(const const_iterator& other) const noexcept
+            { return i < other.i; }
+        inline bool operator<=(const const_iterator& other) const noexcept
+            { return i <= other.i; }
+        inline bool operator>(const const_iterator& other) const noexcept
+            { return i > other.i; }
+        inline bool operator>=(const const_iterator& other) const noexcept
+            { 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+=(difference_type j) { i+=j; return *this; }
+        inline iterator &operator-=(difference_type j) { i-=j; return *this; }
+        inline iterator operator+(difference_type j) const { return iterator(i+j); }
+        inline iterator operator-(difference_type 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() noexcept : i(nullptr) {}
+        inline const_iterator(Node *n) noexcept : i(n) {}
+
+
+
+        inline const_iterator(const const_iterator &o) noexcept : i(o.i) {}
+
+
+
+
+        inline const_iterator(const iterator &o) noexcept : i(o.i) {}
+
+        inline const T &operator*() const { return i->t(); }
+        inline const T *operator->() const { return &i->t(); }
+        inline const T &operator[](difference_type j) const { return i[j].t(); }
+        inline bool operator==(const const_iterator &o) const noexcept { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const noexcept { return i != o.i; }
+        inline bool operator<(const const_iterator& other) const noexcept { return i < other.i; }
+        inline bool operator<=(const const_iterator& other) const noexcept { return i <= other.i; }
+        inline bool operator>(const const_iterator& other) const noexcept { return i > other.i; }
+        inline bool operator>=(const const_iterator& other) const noexcept { 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+=(difference_type j) { i+=j; return *this; }
+        inline const_iterator &operator-=(difference_type j) { i-=j; return *this; }
+        inline const_iterator operator+(difference_type j) const { return const_iterator(i+j); }
+        inline const_iterator operator-(difference_type j) const { return const_iterator(i-j); }
+        inline int operator-(const_iterator j) const { return int(i - j.i); }
+    };
+    friend class const_iterator;
+
+
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    inline iterator begin() { detach(); return reinterpret_cast<Node *>(p.begin()); }
+    inline const_iterator begin() const noexcept { return reinterpret_cast<Node *>(p.begin()); }
+    inline const_iterator cbegin() const noexcept { return reinterpret_cast<Node *>(p.begin()); }
+    inline const_iterator constBegin() const noexcept { return reinterpret_cast<Node *>(p.begin()); }
+    inline iterator end() { detach(); return reinterpret_cast<Node *>(p.end()); }
+    inline const_iterator end() const noexcept { return reinterpret_cast<Node *>(p.end()); }
+    inline const_iterator cend() const noexcept { return reinterpret_cast<Node *>(p.end()); }
+    inline const_iterator constEnd() const noexcept { return reinterpret_cast<Node *>(p.end()); }
+    reverse_iterator rbegin() { return reverse_iterator(end()); }
+    reverse_iterator rend() { return reverse_iterator(begin()); }
+    const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
+    const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
+    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
+    const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
+    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() { do { } while ((false) && (!isEmpty())); return *begin(); }
+    inline const T& constFirst() const { return first(); }
+    inline const T& first() const { do { } while ((false) && (!isEmpty())); return at(0); }
+    T& last() { do { } while ((false) && (!isEmpty())); return *(--end()); }
+    const T& last() const { do { } while ((false) && (!isEmpty())); return at(count() - 1); }
+    inline const T& constLast() const { return last(); }
+    inline void removeFirst() { do { } while ((false) && (!isEmpty())); erase(begin()); }
+    inline void removeLast() { do { } while ((false) && (!isEmpty())); 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; std::copy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }
+    inline std::list<T> toStdList() const
+    { std::list<T> tmp; std::copy(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);
+
+    bool isValidIterator(const iterator &i) const noexcept
+    {
+        return (constBegin().i <= i.i) && (i.i <= constEnd().i);
+    }
+
+private:
+    inline bool op_eq_impl(const QList &other, QListData::NotArrayCompatibleLayout) const;
+    inline bool op_eq_impl(const QList &other, QListData::ArrayCompatibleLayout) const;
+    inline bool contains_impl(const T &, QListData::NotArrayCompatibleLayout) const;
+    inline bool contains_impl(const T &, QListData::ArrayCompatibleLayout) const;
+    inline int count_impl(const T &, QListData::NotArrayCompatibleLayout) const;
+    inline int count_impl(const T &, QListData::ArrayCompatibleLayout) const;
+};
+
+
+
+
+
+
+
+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, static_cast<const void *>(&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)
+{
+    do { } while ((false) && (isValidIterator(before)));
+
+    int iBefore = int(before.i - reinterpret_cast<Node *>(p.begin()));
+    Node *n = 0;
+    if (d->ref.isShared())
+        n = detach_helper_grow(iBefore, 1);
+    else
+        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)
+{
+    do { } while ((false) && (isValidIterator(it)));
+    if (d->ref.isShared()) {
+        int offset = int(it.i - reinterpret_cast<Node *>(p.begin()));
+        it = begin();
+        it += offset;
+    }
+    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
+{ do { } while ((false) && (i >= 0 && i < p.size()));
+ return reinterpret_cast<Node *>(p.at(i))->t(); }
+template <typename T>
+inline const T &QList<T>::operator[](int i) const
+{ do { } while ((false) && (i >= 0 && i < p.size()));
+ return reinterpret_cast<Node *>(p.at(i))->t(); }
+template <typename T>
+inline T &QList<T>::operator[](int i)
+{ do { } while ((false) && (i >= 0 && i < p.size()));
+  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)
+{ do { } while ((false) && (i >= 0 && i < p.size()));
+ 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(0x7fffffff, 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)
+{
+    do { } while ((false) && (i >= 0 && i < p.size()));
+    detach();
+    reinterpret_cast<Node *>(p.at(i))->t() = t;
+}
+
+template <typename T>
+inline void QList<T>::swap(int i, int j)
+{
+    do { } while ((false) && (i >= 0 && i < p.size() && j >= 0 && j < p.size()))
+                                                       ;
+    detach();
+    std::swap(d->array[d->begin + i], d->array[d->begin + j]);
+}
+
+template <typename T>
+inline void QList<T>::move(int from, int to)
+{
+    do { } while ((false) && (from >= 0 && from < p.size() && to >= 0 && to < p.size()))
+                                                      ;
+    detach();
+    p.move(from, to);
+}
+
+template<typename T>
+ QList<T> QList<T>::mid(int pos, int alength) const
+{
+    using namespace QtPrivate;
+    switch (QContainerImplHelper::mid(size(), &pos, &alength)) {
+    case QContainerImplHelper::Null:
+    case QContainerImplHelper::Empty:
+        return QList<T>();
+    case QContainerImplHelper::Full:
+        return *this;
+    case QContainerImplHelper::Subset:
+        break;
+    }
+
+    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 (...) {
+        p.dispose();
+        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));
+        p.dispose();
+        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 (...) {
+        p.dispose();
+        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)
+    : QListSpecialMethods<T>(l), d(l.d)
+{
+    if (!d->ref.ref()) {
+        p.detach(d->alloc);
+
+        try {
+            node_copy(reinterpret_cast<Node *>(p.begin()),
+                    reinterpret_cast<Node *>(p.end()),
+                    reinterpret_cast<Node *>(l.p.begin()));
+        } catch (...) {
+            QListData::dispose(d);
+            throw;
+        }
+    }
+}
+
+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 (d == l.d)
+        return true;
+    if (p.size() != l.p.size())
+        return false;
+    return this->op_eq_impl(l, MemoryLayout());
+}
+
+template <typename T>
+inline bool QList<T>::op_eq_impl(const QList &l, QListData::NotArrayCompatibleLayout) const
+{
+    Node *i = reinterpret_cast<Node *>(p.begin());
+    Node *e = reinterpret_cast<Node *>(p.end());
+    Node *li = reinterpret_cast<Node *>(l.p.begin());
+    for (; i != e; ++i, ++li) {
+        if (!(i->t() == li->t()))
+            return false;
+    }
+    return true;
+}
+
+template <typename T>
+inline bool QList<T>::op_eq_impl(const QList &l, QListData::ArrayCompatibleLayout) const
+{
+    const T *lb = reinterpret_cast<const T*>(l.p.begin());
+    const T *b = reinterpret_cast<const T*>(p.begin());
+    const T *e = reinterpret_cast<const T*>(p.end());
+    return std::equal(b, e, lb);
+}
+
+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));
+    QListData::dispose(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)
+{
+    do { } while ((false) && (isValidIterator(afirst)));
+    do { } while ((false) && (isValidIterator(alast)));
+
+    if (d->ref.isShared()) {
+
+        int offsetfirst = int(afirst.i - reinterpret_cast<Node *>(p.begin()));
+        int offsetlast = int(alast.i - reinterpret_cast<Node *>(p.begin()));
+        afirst = begin();
+        alast = afirst;
+        afirst += offsetfirst;
+        alast += offsetlast;
+    }
+
+    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 (d == &QListData::shared_null) {
+            *this = l;
+        } else {
+            Node *n = (d->ref.isShared())
+                      ? detach_helper_grow(0x7fffffff, 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
+{
+    return contains_impl(t, MemoryLayout());
+}
+
+template <typename T>
+inline bool QList<T>::contains_impl(const T &t, QListData::NotArrayCompatibleLayout) const
+{
+    Node *e = reinterpret_cast<Node *>(p.end());
+    Node *i = reinterpret_cast<Node *>(p.begin());
+    for (; i != e; ++i)
+        if (i->t() == t)
+            return true;
+    return false;
+}
+
+template <typename T>
+inline bool QList<T>::contains_impl(const T &t, QListData::ArrayCompatibleLayout) const
+{
+    const T *b = reinterpret_cast<const T*>(p.begin());
+    const T *e = reinterpret_cast<const T*>(p.end());
+    return std::find(b, e, t) != e;
+}
+
+template <typename T>
+ int QList<T>::count(const T &t) const
+{
+    return this->count_impl(t, MemoryLayout());
+}
+
+template <typename T>
+inline int QList<T>::count_impl(const T &t, QListData::NotArrayCompatibleLayout) const
+{
+    int c = 0;
+    Node *e = reinterpret_cast<Node *>(p.end());
+    Node *i = reinterpret_cast<Node *>(p.begin());
+    for (; i != e; ++i)
+        if (i->t() == t)
+            ++c;
+    return c;
+}
+
+template <typename T>
+inline int QList<T>::count_impl(const T &t, QListData::ArrayCompatibleLayout) const
+{
+    return int(std::count(reinterpret_cast<const T*>(p.begin()),
+                          reinterpret_cast<const T*>(p.end()),
+                          t));
+}
+
+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) { i = c->begin(); n = c->end(); } inline QMutableListIterator &operator=(QList<T> &container) { c = &container; 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() { do { } while ((false) && (item_exists())); return *n; } inline const T &value() const { do { } while ((false) && (item_exists())); 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; } };
+
+template <typename T>
+uint qHash(const QList<T> &key, uint seed = 0)
+    noexcept(noexcept(qHashRange(key.cbegin(), key.cend(), seed)))
+{
+    return qHashRange(key.cbegin(), key.cend(), seed);
+}
+
+template <typename T>
+bool operator<(const QList<T> &lhs, const QList<T> &rhs)
+    noexcept(noexcept(std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end())))
+
+{
+    return std::lexicographical_compare(lhs.begin(), lhs.end(),
+                                        rhs.begin(), rhs.end());
+}
+
+template <typename T>
+inline bool operator>(const QList<T> &lhs, const QList<T> &rhs)
+    noexcept(noexcept(lhs < rhs))
+{
+    return rhs < lhs;
+}
+
+template <typename T>
+inline bool operator<=(const QList<T> &lhs, const QList<T> &rhs)
+    noexcept(noexcept(lhs < rhs))
+{
+    return !(lhs > rhs);
+}
+
+template <typename T>
+inline bool operator>=(const QList<T> &lhs, const QList<T> &rhs)
+    noexcept(noexcept(lhs < rhs))
+{
+    return !(lhs < rhs);
+}
+
+
+
+# 1 "../../include/QtCore/qbytearraylist.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearraylist.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearraylist.h"
+# 1 "../../include/QtCore/qlist.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 1
+# 1 "../../include/QtCore/qlist.h" 2
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearraylist.h" 2
+
+
+
+
+# 1 "../../include/QtCore/qbytearray.h" 1
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearraylist.h" 2
+
+
+
+typedef QListIterator<QByteArray> QByteArrayListIterator;
+typedef QMutableListIterator<QByteArray> QMutableByteArrayListIterator;
+typedef QList<QByteArray> QByteArrayList;
+
+namespace QtPrivate {
+    QByteArray __attribute__((visibility("default"))) QByteArrayList_join(const QByteArrayList *that, const char *separator, int separatorLength);
+}
+
+
+
+
+template <> struct QListSpecialMethods<QByteArray>
+
+{
+
+protected:
+    ~QListSpecialMethods() {}
+
+public:
+    inline QByteArray join() const
+    { return QtPrivate::QByteArrayList_join(self(), nullptr, 0); }
+    inline QByteArray join(const QByteArray &sep) const
+    { return QtPrivate::QByteArrayList_join(self(), sep.constData(), sep.size()); }
+    inline QByteArray join(char sep) const
+    { return QtPrivate::QByteArrayList_join(self(), &sep, 1); }
+
+private:
+    typedef QList<QByteArray> Self;
+    Self *self() { return static_cast<Self *>(this); }
+    const Self *self() const { return static_cast<const Self *>(this); }
+};
+
+
+# 1 "../../include/QtCore/qbytearraylist.h" 2
+# 1090 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 2
+# 1 "../../include/QtCore/qstringlist.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h"
+# 1 "../../include/QtCore/qlist.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 2
+
+
+
+
+# 1 "../../include/QtCore/qalgorithms.h" 1
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 2
+# 1 "../../include/QtCore/qregexp.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qregexp.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qregexp.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qregexp.h" 2
+
+
+
+# 1 "../../include/QtCore/qstring.h" 1
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qregexp.h" 2
+
+
+
+
+struct QRegExpPrivate;
+class QStringList;
+class QRegExp;
+
+__attribute__((visibility("default"))) uint qHash(const QRegExp &key, uint seed = 0) noexcept;
+
+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);
+
+    QRegExp &operator=(QRegExp &&other) noexcept { swap(other); return *this; }
+
+    void swap(QRegExp &other) noexcept { 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);
+
+    friend __attribute__((visibility("default"))) uint qHash(const QRegExp &key, uint seed) noexcept;
+
+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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QRegExp)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QRegExp >::value, 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 "../../include/QtCore/qregexp.h" 2
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 2
+# 1 "../../include/QtCore/qstring.h" 1
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 2
+# 1 "../../include/QtCore/qstringmatcher.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringmatcher.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringmatcher.h"
+# 1 "../../include/QtCore/qstring.h" 1
+# 44 "../../include/QtCore/../../../../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 "../../include/QtCore/qstringmatcher.h" 2
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 2
+
+
+
+class QRegExp;
+class QRegularExpression;
+
+typedef QListIterator<QString> QStringListIterator;
+typedef QMutableListIterator<QString> QMutableStringListIterator;
+
+class QStringList;
+
+
+
+
+template <> struct QListSpecialMethods<QString>
+
+{
+
+protected:
+    ~QListSpecialMethods() {}
+
+public:
+    inline void sort(Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    inline int removeDuplicates();
+
+    inline QString join(const QString &sep) const;
+    inline QString join(QChar sep) const;
+
+    inline QStringList filter(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 filter(const QRegExp &rx) const;
+    inline QStringList &replaceInStrings(const QRegExp &rx, const QString &after);
+
+
+
+
+    inline QStringList filter(const QRegularExpression &re) const;
+    inline QStringList &replaceInStrings(const QRegularExpression &re, const QString &after);
+
+
+
+
+private:
+    inline QStringList *self();
+    inline const QStringList *self() const;
+};
+
+
+class QStringList : public QList<QString>
+{
+
+public:
+    inline QStringList() noexcept { }
+    inline explicit QStringList(const QString &i) { append(i); }
+    inline QStringList(const QList<QString> &l) : QList<QString>(l) { }
+
+    inline QStringList(QList<QString> &&l) noexcept : QList<QString>(std::move(l)) { }
+
+
+    inline QStringList(std::initializer_list<QString> args) : QList<QString>(args) { }
+
+
+    QStringList &operator=(const QList<QString> &other)
+    { QList<QString>::operator=(other); return *this; }
+
+    QStringList &operator=(QList<QString> &&other) noexcept
+    { QList<QString>::operator=(std::move(other)); return *this; }
+
+
+    inline bool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+    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 &operator<<(const QList<QString> &l)
+    { *this += l; return *this; }
+
+
+    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 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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QStringList)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QStringList >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QStringList) }; static inline const char *name() { return "QStringList"; } };
+
+inline QStringList *QListSpecialMethods<QString>::self()
+{ return static_cast<QStringList *>(this); }
+inline const QStringList *QListSpecialMethods<QString>::self() const
+{ return static_cast<const QStringList *>(this); }
+
+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 QChar *sep, int seplen);
+    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 QListSpecialMethods<QString>::sort(Qt::CaseSensitivity cs)
+{
+    QtPrivate::QStringList_sort(self(), cs);
+}
+
+inline int QListSpecialMethods<QString>::removeDuplicates()
+{
+    return QtPrivate::QStringList_removeDuplicates(self());
+}
+
+inline QString QListSpecialMethods<QString>::join(const QString &sep) const
+{
+    return QtPrivate::QStringList_join(self(), sep.constData(), sep.length());
+}
+
+inline QString QListSpecialMethods<QString>::join(QChar sep) const
+{
+    return QtPrivate::QStringList_join(self(), &sep, 1);
+}
+
+inline QStringList QListSpecialMethods<QString>::filter(const QString &str, Qt::CaseSensitivity cs) const
+{
+    return QtPrivate::QStringList_filter(self(), str, cs);
+}
+
+inline bool QStringList::contains(const QString &str, Qt::CaseSensitivity cs) const
+{
+    return QtPrivate::QStringList_contains(this, str, cs);
+}
+
+inline QStringList &QListSpecialMethods<QString>::replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs)
+{
+    QtPrivate::QStringList_replaceInStrings(self(), before, after, cs);
+    return *self();
+}
+
+inline QStringList operator+(const QList<QString> &one, const QStringList &other)
+{
+    QStringList n = one;
+    n += other;
+    return n;
+}
+
+
+inline QStringList &QListSpecialMethods<QString>::replaceInStrings(const QRegExp &rx, const QString &after)
+{
+    QtPrivate::QStringList_replaceInStrings(self(), rx, after);
+    return *self();
+}
+
+inline QStringList QListSpecialMethods<QString>::filter(const QRegExp &rx) const
+{
+    return QtPrivate::QStringList_filter(self(), 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 &QListSpecialMethods<QString>::replaceInStrings(const QRegularExpression &rx, const QString &after)
+{
+    QtPrivate::QStringList_replaceInStrings(self(), rx, after);
+    return *self();
+}
+
+inline QStringList QListSpecialMethods<QString>::filter(const QRegularExpression &rx) const
+{
+    return QtPrivate::QStringList_filter(self(), 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);
+}
+
+
+
+
+# 1 "../../include/QtCore/qstringlist.h" 2
+# 1091 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlist.h" 2
+# 1 "../../include/QtCore/qlist.h" 2
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+# 1 "../../include/QtCore/qmetatype.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+# 1 "../../include/QtCore/qatomic.h" 2
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
+# 1 "../../include/QtCore/qbytearray.h" 1
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
+# 1 "../../include/QtCore/qvarlengtharray.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvarlengtharray.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvarlengtharray.h"
+# 1 "../../include/QtCore/qcontainerfwd.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qcontainerfwd.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qcontainerfwd.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../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 "../../include/QtCore/qcontainerfwd.h" 2
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvarlengtharray.h" 2
+# 1 "../../include/QtCore/qglobal.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvarlengtharray.h" 2
+# 1 "../../include/QtCore/qalgorithms.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvarlengtharray.h" 2
+# 56 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvarlengtharray.h"
+
+
+
+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());
+    }
+
+
+    QVarLengthArray(std::initializer_list<T> args)
+        : a(Prealloc), s(0), ptr(reinterpret_cast<T *>(array))
+    {
+        append(args.begin(), args.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;
+    }
+
+
+    QVarLengthArray<T, Prealloc> &operator=(std::initializer_list<T> list)
+    {
+        resize(list.size());
+        std::copy(list.begin(), list.end(), this->begin());
+        return *this;
+    }
+
+
+    inline void removeLast() {
+        do { } while ((false) && (s > 0));
+        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() { do { } while ((false) && (!isEmpty())); return *begin(); }
+    inline const T& first() const { do { } while ((false) && (!isEmpty())); return *begin(); }
+    T& last() { do { } while ((false) && (!isEmpty())); return *(end() - 1); }
+    const T& last() const { do { } while ((false) && (!isEmpty())); return *(end() - 1); }
+    inline bool isEmpty() const { return (s == 0); }
+    inline void resize(int size);
+    inline void clear() { resize(0); }
+    inline void squeeze();
+
+    inline int capacity() const { return a; }
+    inline void reserve(int size);
+
+    inline int indexOf(const T &t, int from = 0) const;
+    inline int lastIndexOf(const T &t, int from = -1) const;
+    inline bool contains(const T &t) const;
+
+    inline T &operator[](int idx) {
+        do { } while ((false) && (idx >= 0 && idx < s));
+        return ptr[idx];
+    }
+    inline const T &operator[](int idx) const {
+        do { } while ((false) && (idx >= 0 && idx < s));
+        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;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_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; }
+    reverse_iterator rbegin() { return reverse_iterator(end()); }
+    reverse_iterator rend() { return reverse_iterator(begin()); }
+    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
+    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
+    const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }
+    const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }
+    iterator insert(const_iterator before, int n, const T &x);
+    inline iterator insert(const_iterator before, const T &x) { return insert(before, 1, x); }
+    iterator erase(const_iterator begin, const_iterator end);
+    inline iterator erase(const_iterator pos) { return erase(pos, pos+1); }
+
+
+    inline bool empty() const { return isEmpty(); }
+    inline void push_back(const T &t) { append(t); }
+    inline void pop_back() { removeLast(); }
+    inline T &front() { return first(); }
+    inline const T &front() const { return first(); }
+    inline T &back() { return last(); }
+    inline const T &back() const { return last(); }
+
+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;
+    };
+
+    bool isValidIterator(const const_iterator &i) const
+    {
+        return (i <= constEnd()) && (constBegin() <= i);
+    }
+};
+
+template <class T, int Prealloc>
+inline QVarLengthArray<T, Prealloc>::QVarLengthArray(int asize)
+    : s(asize) {
+    static_assert(bool(Prealloc > 0), "QVarLengthArray Prealloc must be greater than 0.");
+    do { } while ((false) && (s >= 0));
+    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>
+inline int QVarLengthArray<T, Prealloc>::indexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from = qMax(from + s, 0);
+    if (from < s) {
+        T *n = ptr + from - 1;
+        T *e = ptr + s;
+        while (++n != e)
+            if (*n == t)
+                return n - ptr;
+    }
+    return -1;
+}
+
+template <class T, int Prealloc>
+inline int QVarLengthArray<T, Prealloc>::lastIndexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from += s;
+    else if (from >= s)
+        from = s - 1;
+    if (from >= 0) {
+        T *b = ptr;
+        T *n = ptr + from + 1;
+        while (n != b) {
+            if (*--n == t)
+                return n - b;
+        }
+    }
+    return -1;
+}
+
+template <class T, int Prealloc>
+inline bool QVarLengthArray<T, Prealloc>::contains(const T &t) const
+{
+    T *b = ptr;
+    T *i = ptr + s;
+    while (i != b) {
+        if (*--i == t)
+            return true;
+    }
+    return false;
+}
+
+template <class T, int Prealloc>
+ void QVarLengthArray<T, Prealloc>::append(const T *abuf, int increment)
+{
+    do { } while ((false) && (abuf));
+    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>
+inline void QVarLengthArray<T, Prealloc>::squeeze()
+{ realloc(s, s); }
+
+template <class T, int Prealloc>
+ void QVarLengthArray<T, Prealloc>::realloc(int asize, int aalloc)
+{
+    do { } while ((false) && (aalloc >= asize));
+    T *oldPtr = ptr;
+    int osize = s;
+
+    const int copySize = qMin(asize, osize);
+    if (aalloc != a) {
+        if (aalloc > Prealloc) {
+            T* newPtr = reinterpret_cast<T *>(malloc(aalloc * sizeof(T)));
+            do { if (!(newPtr)) qBadAlloc(); } while (0);
+
+            ptr = newPtr;
+            a = aalloc;
+        } else {
+            ptr = reinterpret_cast<T *>(array);
+            a = Prealloc;
+        }
+        s = 0;
+        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));
+        }
+    }
+    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 (uint(i) >= uint(size())) {
+        return T();
+    }
+    return at(i);
+}
+template <class T, int Prealloc>
+ T QVarLengthArray<T, Prealloc>::value(int i, const T &defaultValue) const
+{
+    return (uint(i) >= uint(size())) ? defaultValue : at(i);
+}
+
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::insert(int i, const T &t)
+{ do { } while ((false) && (i >= 0 && i <= s));
+  insert(begin() + i, 1, t); }
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::insert(int i, int n, const T &t)
+{ do { } while ((false) && (i >= 0 && i <= s));
+  insert(begin() + i, n, t); }
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::remove(int i, int n)
+{ do { } while ((false) && (i >= 0 && n >= 0 && i + n <= s));
+  erase(begin() + i, begin() + i + n); }
+template <class T, int Prealloc>
+inline void QVarLengthArray<T, Prealloc>::remove(int i)
+{ do { } while ((false) && (i >= 0 && i < s));
+  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)
+{
+    do { } while ((false) && (i >= 0 && i < s));
+    const T copy(t);
+    data()[i] = copy;
+}
+
+
+template <class T, int Prealloc>
+ typename QVarLengthArray<T, Prealloc>::iterator QVarLengthArray<T, Prealloc>::insert(const_iterator before, size_type n, const T &t)
+{
+    do { } while ((false) && (isValidIterator(before)));
+
+    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(const_iterator abegin, const_iterator aend)
+{
+    do { } while ((false) && (isValidIterator(abegin)));
+    do { } while ((false) && (isValidIterator(aend)));
+
+    int f = int(abegin - ptr);
+    int l = int(aend - ptr);
+    int n = l - f;
+    if (QTypeInfo<T>::isComplex) {
+        std::copy(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;
+    const T *rb = r.begin();
+    const T *b = l.begin();
+    const T *e = l.end();
+    return std::equal(b, e, rb);
+}
+
+template <typename T, int Prealloc1, int Prealloc2>
+bool operator!=(const QVarLengthArray<T, Prealloc1> &l, const QVarLengthArray<T, Prealloc2> &r)
+{
+    return !(l == r);
+}
+
+template <typename T, int Prealloc1, int Prealloc2>
+bool operator<(const QVarLengthArray<T, Prealloc1> &lhs, const QVarLengthArray<T, Prealloc2> &rhs)
+    noexcept(noexcept(std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end())))
+
+{
+    return std::lexicographical_compare(lhs.begin(), lhs.end(),
+                                        rhs.begin(), rhs.end());
+}
+
+template <typename T, int Prealloc1, int Prealloc2>
+inline bool operator>(const QVarLengthArray<T, Prealloc1> &lhs, const QVarLengthArray<T, Prealloc2> &rhs)
+    noexcept(noexcept(lhs < rhs))
+{
+    return rhs < lhs;
+}
+
+template <typename T, int Prealloc1, int Prealloc2>
+inline bool operator<=(const QVarLengthArray<T, Prealloc1> &lhs, const QVarLengthArray<T, Prealloc2> &rhs)
+    noexcept(noexcept(lhs < rhs))
+{
+    return !(lhs > rhs);
+}
+
+template <typename T, int Prealloc1, int Prealloc2>
+inline bool operator>=(const QVarLengthArray<T, Prealloc1> &lhs, const QVarLengthArray<T, Prealloc2> &rhs)
+    noexcept(noexcept(lhs < rhs))
+{
+    return !(lhs < rhs);
+}
+
+
+# 1 "../../include/QtCore/qvarlengtharray.h" 2
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
+# 1 "../../include/QtCore/qisenum.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h" 1
+# 40 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qisenum.h" 2
+# 1 "../../include/QtCore/qisenum.h" 2
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
+# 1 "../../include/QtCore/qtypetraits.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 1
+# 107 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 108 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 2
+# 1 "../../include/QtCore/qtypetraits.h" 2
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
+
+# 1 "../../include/QtCore/qobjectdefs.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobjectdefs.h" 1
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobjectdefs.h"
+# 1 "../../include/QtCore/qnamespace.h" 1
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobjectdefs.h" 2
+
+# 1 "../../include/QtCore/qobjectdefs_impl.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobjectdefs_impl.h" 1
+# 53 "../../include/QtCore/../../../../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; };
+# 74 "../../include/QtCore/../../../../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;
+        explicit ApplyReturnValue(void *data_) : data(data_) {}
+    };
+    template<typename T, typename U>
+    void operator,(const T &value, const ApplyReturnValue<U> &container) {
+        if (container.data)
+            *reinterpret_cast<U*>(container.data) = value;
+    }
+
+    template<typename T, typename U>
+    void operator,(T &&value, const ApplyReturnValue<U> &container) {
+        if (container.data)
+            *reinterpret_cast<U*>(container.data) = value;
+    }
+
+    template<typename T>
+    void operator,(T, const ApplyReturnValue<void> &) {}
+# 488 "../../include/QtCore/../../../../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, IsPointerToMemberFunction = false}; };
+
+    template <typename, typename, typename, typename> struct FunctorCall;
+    template <int... II, typename... SignalArgs, typename R, typename Function>
+    struct FunctorCall<IndexesList<II...>, List<SignalArgs...>, R, Function> {
+        static void call(Function f, void **arg) {
+            f((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+1]))...), ApplyReturnValue<R>(arg[0]);
+        }
+    };
+    template <int... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
+    struct FunctorCall<IndexesList<II...>, 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[II+1]))...), ApplyReturnValue<R>(arg[0]);
+        }
+    };
+    template <int... II, typename... SignalArgs, typename R, typename... SlotArgs, typename SlotRet, class Obj>
+    struct FunctorCall<IndexesList<II...>, List<SignalArgs...>, R, SlotRet (Obj::*)(SlotArgs...) const> {
+        static void call(SlotRet (Obj::*f)(SlotArgs...) const, Obj *o, void **arg) {
+            (o->*f)((*reinterpret_cast<typename RemoveRef<SignalArgs>::Type *>(arg[II+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), IsPointerToMemberFunction = true};
+        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<class Obj, typename Ret, typename... Args> struct FunctionPointer<Ret (Obj::*) (Args...) const>
+    {
+        typedef Obj Object;
+        typedef List<Args...> Arguments;
+        typedef Ret ReturnType;
+        typedef Ret (Obj::*Function) (Args...) const;
+        enum {ArgumentCount = sizeof...(Args), IsPointerToMemberFunction = true};
+        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), IsPointerToMemberFunction = false};
+        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(const typename RemoveRef<A2>::Type&);
+        static char test(...);
+        static const typename RemoveRef<A1>::Type &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 }; };
+# 591 "../../include/QtCore/../../../../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 };
+    };
+# 608 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobjectdefs_impl.h"
+    template <typename Functor, typename ArgList> struct ComputeFunctorArgumentCount;
+
+    template <typename Functor, typename ArgList, bool Done> struct ComputeFunctorArgumentCountHelper
+    { enum { Value = -1 }; };
+    template <typename Functor, typename First, typename... ArgList>
+    struct ComputeFunctorArgumentCountHelper<Functor, List<First, ArgList...>, false>
+        : ComputeFunctorArgumentCount<Functor,
+            typename List_Left<List<First, ArgList...>, sizeof...(ArgList)>::Value> {};
+
+    template <typename Functor, typename... ArgList> struct ComputeFunctorArgumentCount<Functor, List<ArgList...>>
+    {
+        template <typename D> static D dummy();
+        template <typename F> static auto test(F f) -> decltype(((f.operator()((dummy<ArgList>())...)), int()));
+        static char test(...);
+        enum {
+            Ok = sizeof(test(dummy<Functor>())) == sizeof(int),
+            Value = Ok ? int(sizeof...(ArgList)) : int(ComputeFunctorArgumentCountHelper<Functor, List<ArgList...>, Ok>::Value)
+        };
+    };
+
+
+    template <typename Functor, typename ArgList> struct FunctorReturnType;
+    template <typename Functor, typename ... ArgList> struct FunctorReturnType<Functor, List<ArgList...>> {
+        template <typename D> static D dummy();
+        typedef decltype(dummy<Functor>().operator()((dummy<ArgList>())...)) Value;
+    };
+
+
+}
+
+
+# 1 "../../include/QtCore/qobjectdefs_impl.h" 2
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobjectdefs.h" 2
+
+
+
+
+class QByteArray;
+struct QArrayData;
+typedef QArrayData QByteArrayData;
+
+class QString;
+# 167 "../../include/QtCore/../../../../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) {}
+# 270 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobjectdefs.h"
+__attribute__((visibility("default"))) const char *qFlagLocation(const char *method);
+# 296 "../../include/QtCore/../../../../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 = nullptr, const void *aData = nullptr)
+        : _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 = nullptr, void *aData = nullptr)
+        : 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;
+
+    bool inherits(const QMetaObject *metaObject) const noexcept;
+    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 = nullptr);
+
+    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 signal_offset, int local_signal_index, void **argv);
+
+    static bool invokeMethod(QObject *obj, const char *member,
+                             Qt::ConnectionType,
+                             QGenericReturnArgument ret,
+                             QGenericArgument val0 = QGenericArgument(nullptr),
+                             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(nullptr),
+                             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(nullptr),
+                             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(nullptr),
+                             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(nullptr),
+                         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,
+        RegisterPropertyMetaType,
+        RegisterMethodArgumentMetaType
+    };
+
+    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 * const *relatedMetaObjects;
+        void *extradata;
+    } d;
+};
+
+class __attribute__((visibility("default"))) QMetaObject::Connection {
+    void *d_ptr;
+    explicit Connection(void *data) : d_ptr(data) { }
+    friend class QObject;
+    friend class QObjectPrivate;
+    friend struct QMetaObject;
+    bool isConnected_helper() const;
+public:
+    ~Connection();
+    Connection();
+    Connection(const Connection &other);
+    Connection &operator=(const Connection &other);
+
+
+
+    typedef void *Connection::*RestrictedBool;
+    operator RestrictedBool() const { return d_ptr && isConnected_helper() ? &Connection::d_ptr : nullptr; }
+
+
+
+    inline Connection(Connection &&o) : d_ptr(o.d_ptr) { o.d_ptr = nullptr; }
+    inline Connection &operator=(Connection &&other)
+    { qSwap(d_ptr, other.d_ptr); return *this; }
+
+};
+
+inline const QMetaObject *QMetaObject::superClass() const
+{ return d.superdata; }
+
+namespace QtPrivate {
+
+    template <typename Object> struct HasQ_OBJECT_Macro {
+        template <typename T>
+        static char test(int (T::*)(QMetaObject::Call, int, void **));
+        static int test(int (Object::*)(QMetaObject::Call, int, void **));
+        enum { Value = sizeof(test(&Object::qt_metacall)) == sizeof(int) };
+    };
+}
+
+
+# 1 "../../include/QtCore/qobjectdefs.h" 2
+# 52 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/map" 1 3
+# 58 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/map" 3
+       
+# 59 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/map" 3
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 1 3
+# 61 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 3
+       
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 3
+
+
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/aligned_buffer.h" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/aligned_buffer.h" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/aligned_buffer.h" 3
+
+
+
+
+
+
+
+
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/ext/aligned_buffer.h" 3
+namespace __gnu_cxx
+{
+
+
+
+
+  template<typename _Tp>
+    struct __aligned_membuf
+    {
+
+
+
+      struct _Tp2 { _Tp _M_t; };
+
+      alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];
+
+      __aligned_membuf() = default;
+
+
+      __aligned_membuf(std::nullptr_t) { }
+
+      void*
+      _M_addr() noexcept
+      { return static_cast<void*>(&_M_storage); }
+
+      const void*
+      _M_addr() const noexcept
+      { return static_cast<const void*>(&_M_storage); }
+
+      _Tp*
+      _M_ptr() noexcept
+      { return static_cast<_Tp*>(_M_addr()); }
+
+      const _Tp*
+      _M_ptr() const noexcept
+      { return static_cast<const _Tp*>(_M_addr()); }
+    };
+
+
+
+
+
+
+  template<typename _Tp>
+    struct __aligned_buffer
+    : std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>
+    {
+      typename
+ std::aligned_storage<sizeof(_Tp), std::alignment_of<_Tp>::value>::type
+ _M_storage;
+
+      __aligned_buffer() = default;
+
+
+      __aligned_buffer(std::nullptr_t) { }
+
+      void*
+      _M_addr() noexcept
+      {
+        return static_cast<void*>(&_M_storage);
+      }
+
+      const void*
+      _M_addr() const noexcept
+      {
+        return static_cast<const void*>(&_M_storage);
+      }
+
+      _Tp*
+      _M_ptr() noexcept
+      { return static_cast<_Tp*>(_M_addr()); }
+
+      const _Tp*
+      _M_ptr() const noexcept
+      { return static_cast<const _Tp*>(_M_addr()); }
+    };
+
+}
+# 70 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 92 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 3
+  enum _Rb_tree_color { _S_red = false, _S_black = true };
+
+  struct _Rb_tree_node_base
+  {
+    typedef _Rb_tree_node_base* _Base_ptr;
+    typedef const _Rb_tree_node_base* _Const_Base_ptr;
+
+    _Rb_tree_color _M_color;
+    _Base_ptr _M_parent;
+    _Base_ptr _M_left;
+    _Base_ptr _M_right;
+
+    static _Base_ptr
+    _S_minimum(_Base_ptr __x) noexcept
+    {
+      while (__x->_M_left != 0) __x = __x->_M_left;
+      return __x;
+    }
+
+    static _Const_Base_ptr
+    _S_minimum(_Const_Base_ptr __x) noexcept
+    {
+      while (__x->_M_left != 0) __x = __x->_M_left;
+      return __x;
+    }
+
+    static _Base_ptr
+    _S_maximum(_Base_ptr __x) noexcept
+    {
+      while (__x->_M_right != 0) __x = __x->_M_right;
+      return __x;
+    }
+
+    static _Const_Base_ptr
+    _S_maximum(_Const_Base_ptr __x) noexcept
+    {
+      while (__x->_M_right != 0) __x = __x->_M_right;
+      return __x;
+    }
+  };
+
+  template<typename _Val>
+    struct _Rb_tree_node : public _Rb_tree_node_base
+    {
+      typedef _Rb_tree_node<_Val>* _Link_type;
+# 149 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 3
+      __gnu_cxx::__aligned_membuf<_Val> _M_storage;
+
+      _Val*
+      _M_valptr()
+      { return _M_storage._M_ptr(); }
+
+      const _Val*
+      _M_valptr() const
+      { return _M_storage._M_ptr(); }
+
+    };
+
+  __attribute__ ((__pure__)) _Rb_tree_node_base*
+  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
+
+  __attribute__ ((__pure__)) const _Rb_tree_node_base*
+  _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
+
+  __attribute__ ((__pure__)) _Rb_tree_node_base*
+  _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
+
+  __attribute__ ((__pure__)) const _Rb_tree_node_base*
+  _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
+
+  template<typename _Tp>
+    struct _Rb_tree_iterator
+    {
+      typedef _Tp value_type;
+      typedef _Tp& reference;
+      typedef _Tp* pointer;
+
+      typedef bidirectional_iterator_tag iterator_category;
+      typedef ptrdiff_t difference_type;
+
+      typedef _Rb_tree_iterator<_Tp> _Self;
+      typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
+      typedef _Rb_tree_node<_Tp>* _Link_type;
+
+      _Rb_tree_iterator() noexcept
+      : _M_node() { }
+
+      explicit
+      _Rb_tree_iterator(_Base_ptr __x) noexcept
+      : _M_node(__x) { }
+
+      reference
+      operator*() const noexcept
+      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
+
+      pointer
+      operator->() const noexcept
+      { return static_cast<_Link_type> (_M_node)->_M_valptr(); }
+
+      _Self&
+      operator++() noexcept
+      {
+ _M_node = _Rb_tree_increment(_M_node);
+ return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_increment(_M_node);
+ return __tmp;
+      }
+
+      _Self&
+      operator--() noexcept
+      {
+ _M_node = _Rb_tree_decrement(_M_node);
+ return *this;
+      }
+
+      _Self
+      operator--(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_decrement(_M_node);
+ return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const noexcept
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const noexcept
+      { return _M_node != __x._M_node; }
+
+      _Base_ptr _M_node;
+  };
+
+  template<typename _Tp>
+    struct _Rb_tree_const_iterator
+    {
+      typedef _Tp value_type;
+      typedef const _Tp& reference;
+      typedef const _Tp* pointer;
+
+      typedef _Rb_tree_iterator<_Tp> iterator;
+
+      typedef bidirectional_iterator_tag iterator_category;
+      typedef ptrdiff_t difference_type;
+
+      typedef _Rb_tree_const_iterator<_Tp> _Self;
+      typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
+      typedef const _Rb_tree_node<_Tp>* _Link_type;
+
+      _Rb_tree_const_iterator() noexcept
+      : _M_node() { }
+
+      explicit
+      _Rb_tree_const_iterator(_Base_ptr __x) noexcept
+      : _M_node(__x) { }
+
+      _Rb_tree_const_iterator(const iterator& __it) noexcept
+      : _M_node(__it._M_node) { }
+
+      iterator
+      _M_const_cast() const noexcept
+      { return iterator(const_cast<typename iterator::_Base_ptr>(_M_node)); }
+
+      reference
+      operator*() const noexcept
+      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }
+
+      pointer
+      operator->() const noexcept
+      { return static_cast<_Link_type>(_M_node)->_M_valptr(); }
+
+      _Self&
+      operator++() noexcept
+      {
+ _M_node = _Rb_tree_increment(_M_node);
+ return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_increment(_M_node);
+ return __tmp;
+      }
+
+      _Self&
+      operator--() noexcept
+      {
+ _M_node = _Rb_tree_decrement(_M_node);
+ return *this;
+      }
+
+      _Self
+      operator--(int) noexcept
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_decrement(_M_node);
+ return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const noexcept
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const noexcept
+      { return _M_node != __x._M_node; }
+
+      _Base_ptr _M_node;
+    };
+
+  template<typename _Val>
+    inline bool
+    operator==(const _Rb_tree_iterator<_Val>& __x,
+               const _Rb_tree_const_iterator<_Val>& __y) noexcept
+    { return __x._M_node == __y._M_node; }
+
+  template<typename _Val>
+    inline bool
+    operator!=(const _Rb_tree_iterator<_Val>& __x,
+               const _Rb_tree_const_iterator<_Val>& __y) noexcept
+    { return __x._M_node != __y._M_node; }
+
+  void
+  _Rb_tree_insert_and_rebalance(const bool __insert_left,
+                                _Rb_tree_node_base* __x,
+                                _Rb_tree_node_base* __p,
+                                _Rb_tree_node_base& __header) throw ();
+
+  _Rb_tree_node_base*
+  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
+          _Rb_tree_node_base& __header) throw ();
+
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc = allocator<_Val> >
+    class _Rb_tree
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+        rebind<_Rb_tree_node<_Val> >::other _Node_allocator;
+
+      typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits;
+
+    protected:
+      typedef _Rb_tree_node_base* _Base_ptr;
+      typedef const _Rb_tree_node_base* _Const_Base_ptr;
+      typedef _Rb_tree_node<_Val>* _Link_type;
+      typedef const _Rb_tree_node<_Val>* _Const_Link_type;
+
+    private:
+
+
+      struct _Reuse_or_alloc_node
+      {
+ _Reuse_or_alloc_node(_Rb_tree& __t)
+   : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t)
+ {
+   if (_M_root)
+     {
+       _M_root->_M_parent = 0;
+
+       if (_M_nodes->_M_left)
+  _M_nodes = _M_nodes->_M_left;
+     }
+   else
+     _M_nodes = 0;
+ }
+
+
+ _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;
+
+
+ ~_Reuse_or_alloc_node()
+ { _M_t._M_erase(static_cast<_Link_type>(_M_root)); }
+
+ template<typename _Arg>
+   _Link_type
+
+
+
+   operator()(_Arg&& __arg)
+
+   {
+     _Link_type __node = static_cast<_Link_type>(_M_extract());
+     if (__node)
+       {
+  _M_t._M_destroy_node(__node);
+  _M_t._M_construct_node(__node, std::forward<_Arg>(__arg));
+  return __node;
+       }
+
+     return _M_t._M_create_node(std::forward<_Arg>(__arg));
+   }
+
+      private:
+ _Base_ptr
+ _M_extract()
+ {
+   if (!_M_nodes)
+     return _M_nodes;
+
+   _Base_ptr __node = _M_nodes;
+   _M_nodes = _M_nodes->_M_parent;
+   if (_M_nodes)
+     {
+       if (_M_nodes->_M_right == __node)
+  {
+    _M_nodes->_M_right = 0;
+
+    if (_M_nodes->_M_left)
+      {
+        _M_nodes = _M_nodes->_M_left;
+
+        while (_M_nodes->_M_right)
+   _M_nodes = _M_nodes->_M_right;
+
+        if (_M_nodes->_M_left)
+   _M_nodes = _M_nodes->_M_left;
+      }
+  }
+       else
+  _M_nodes->_M_left = 0;
+     }
+   else
+     _M_root = 0;
+
+   return __node;
+ }
+
+ _Base_ptr _M_root;
+ _Base_ptr _M_nodes;
+ _Rb_tree& _M_t;
+      };
+
+
+
+      struct _Alloc_node
+      {
+ _Alloc_node(_Rb_tree& __t)
+   : _M_t(__t) { }
+
+ template<typename _Arg>
+   _Link_type
+
+
+
+   operator()(_Arg&& __arg) const
+
+   { return _M_t._M_create_node(std::forward<_Arg>(__arg)); }
+
+      private:
+ _Rb_tree& _M_t;
+      };
+
+    public:
+      typedef _Key key_type;
+      typedef _Val value_type;
+      typedef value_type* pointer;
+      typedef const value_type* const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+
+      _Node_allocator&
+      _M_get_Node_allocator() noexcept
+      { return *static_cast<_Node_allocator*>(&this->_M_impl); }
+
+      const _Node_allocator&
+      _M_get_Node_allocator() const noexcept
+      { return *static_cast<const _Node_allocator*>(&this->_M_impl); }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Node_allocator()); }
+
+    protected:
+      _Link_type
+      _M_get_node()
+      { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); }
+
+      void
+      _M_put_node(_Link_type __p) noexcept
+      { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); }
+# 522 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 3
+      template<typename... _Args>
+ void
+ _M_construct_node(_Link_type __node, _Args&&... __args)
+ {
+   try
+     {
+       ::new(__node) _Rb_tree_node<_Val>;
+       _Alloc_traits::construct(_M_get_Node_allocator(),
+           __node->_M_valptr(),
+           std::forward<_Args>(__args)...);
+     }
+   catch(...)
+     {
+       __node->~_Rb_tree_node<_Val>();
+       _M_put_node(__node);
+       throw;
+     }
+ }
+
+      template<typename... _Args>
+        _Link_type
+        _M_create_node(_Args&&... __args)
+ {
+   _Link_type __tmp = _M_get_node();
+   _M_construct_node(__tmp, std::forward<_Args>(__args)...);
+   return __tmp;
+ }
+
+      void
+      _M_destroy_node(_Link_type __p) noexcept
+      {
+ _Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
+ __p->~_Rb_tree_node<_Val>();
+      }
+
+
+      void
+      _M_drop_node(_Link_type __p) noexcept
+      {
+ _M_destroy_node(__p);
+ _M_put_node(__p);
+      }
+
+      template<typename _NodeGen>
+ _Link_type
+ _M_clone_node(_Const_Link_type __x, _NodeGen& __node_gen)
+ {
+   _Link_type __tmp = __node_gen(*__x->_M_valptr());
+   __tmp->_M_color = __x->_M_color;
+   __tmp->_M_left = 0;
+   __tmp->_M_right = 0;
+   return __tmp;
+ }
+
+    protected:
+
+      template<typename _Key_compare,
+        bool = __is_pod(_Key_compare)>
+        struct _Rb_tree_impl : public _Node_allocator
+        {
+   _Key_compare _M_key_compare;
+   _Rb_tree_node_base _M_header;
+   size_type _M_node_count;
+
+   _Rb_tree_impl()
+   : _Node_allocator(), _M_key_compare(), _M_header(),
+     _M_node_count(0)
+   { _M_initialize(); }
+
+   _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
+   : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
+     _M_node_count(0)
+   { _M_initialize(); }
+
+
+   _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
+   : _Node_allocator(std::move(__a)), _M_key_compare(__comp),
+     _M_header(), _M_node_count(0)
+   { _M_initialize(); }
+
+
+   void
+   _M_reset()
+   {
+     this->_M_header._M_parent = 0;
+     this->_M_header._M_left = &this->_M_header;
+     this->_M_header._M_right = &this->_M_header;
+     this->_M_node_count = 0;
+   }
+
+ private:
+   void
+   _M_initialize()
+   {
+     this->_M_header._M_color = _S_red;
+     this->_M_header._M_parent = 0;
+     this->_M_header._M_left = &this->_M_header;
+     this->_M_header._M_right = &this->_M_header;
+   }
+ };
+
+      _Rb_tree_impl<_Compare> _M_impl;
+
+    protected:
+      _Base_ptr&
+      _M_root() noexcept
+      { return this->_M_impl._M_header._M_parent; }
+
+      _Const_Base_ptr
+      _M_root() const noexcept
+      { return this->_M_impl._M_header._M_parent; }
+
+      _Base_ptr&
+      _M_leftmost() noexcept
+      { return this->_M_impl._M_header._M_left; }
+
+      _Const_Base_ptr
+      _M_leftmost() const noexcept
+      { return this->_M_impl._M_header._M_left; }
+
+      _Base_ptr&
+      _M_rightmost() noexcept
+      { return this->_M_impl._M_header._M_right; }
+
+      _Const_Base_ptr
+      _M_rightmost() const noexcept
+      { return this->_M_impl._M_header._M_right; }
+
+      _Link_type
+      _M_begin() noexcept
+      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
+
+      _Const_Link_type
+      _M_begin() const noexcept
+      {
+ return static_cast<_Const_Link_type>
+   (this->_M_impl._M_header._M_parent);
+      }
+
+      _Link_type
+      _M_end() noexcept
+      { return reinterpret_cast<_Link_type>(&this->_M_impl._M_header); }
+
+      _Const_Link_type
+      _M_end() const noexcept
+      { return reinterpret_cast<_Const_Link_type>(&this->_M_impl._M_header); }
+
+      static const_reference
+      _S_value(_Const_Link_type __x)
+      { return *__x->_M_valptr(); }
+
+      static const _Key&
+      _S_key(_Const_Link_type __x)
+      { return _KeyOfValue()(_S_value(__x)); }
+
+      static _Link_type
+      _S_left(_Base_ptr __x) noexcept
+      { return static_cast<_Link_type>(__x->_M_left); }
+
+      static _Const_Link_type
+      _S_left(_Const_Base_ptr __x) noexcept
+      { return static_cast<_Const_Link_type>(__x->_M_left); }
+
+      static _Link_type
+      _S_right(_Base_ptr __x) noexcept
+      { return static_cast<_Link_type>(__x->_M_right); }
+
+      static _Const_Link_type
+      _S_right(_Const_Base_ptr __x) noexcept
+      { return static_cast<_Const_Link_type>(__x->_M_right); }
+
+      static const_reference
+      _S_value(_Const_Base_ptr __x)
+      { return *static_cast<_Const_Link_type>(__x)->_M_valptr(); }
+
+      static const _Key&
+      _S_key(_Const_Base_ptr __x)
+      { return _KeyOfValue()(_S_value(__x)); }
+
+      static _Base_ptr
+      _S_minimum(_Base_ptr __x) noexcept
+      { return _Rb_tree_node_base::_S_minimum(__x); }
+
+      static _Const_Base_ptr
+      _S_minimum(_Const_Base_ptr __x) noexcept
+      { return _Rb_tree_node_base::_S_minimum(__x); }
+
+      static _Base_ptr
+      _S_maximum(_Base_ptr __x) noexcept
+      { return _Rb_tree_node_base::_S_maximum(__x); }
+
+      static _Const_Base_ptr
+      _S_maximum(_Const_Base_ptr __x) noexcept
+      { return _Rb_tree_node_base::_S_maximum(__x); }
+
+    public:
+      typedef _Rb_tree_iterator<value_type> iterator;
+      typedef _Rb_tree_const_iterator<value_type> const_iterator;
+
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+    private:
+      pair<_Base_ptr, _Base_ptr>
+      _M_get_insert_unique_pos(const key_type& __k);
+
+      pair<_Base_ptr, _Base_ptr>
+      _M_get_insert_equal_pos(const key_type& __k);
+
+      pair<_Base_ptr, _Base_ptr>
+      _M_get_insert_hint_unique_pos(const_iterator __pos,
+        const key_type& __k);
+
+      pair<_Base_ptr, _Base_ptr>
+      _M_get_insert_hint_equal_pos(const_iterator __pos,
+       const key_type& __k);
+
+
+      template<typename _Arg, typename _NodeGen>
+        iterator
+ _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);
+
+      iterator
+      _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z);
+
+      template<typename _Arg>
+        iterator
+        _M_insert_lower(_Base_ptr __y, _Arg&& __v);
+
+      template<typename _Arg>
+        iterator
+        _M_insert_equal_lower(_Arg&& __x);
+
+      iterator
+      _M_insert_lower_node(_Base_ptr __p, _Link_type __z);
+
+      iterator
+      _M_insert_equal_lower_node(_Link_type __z);
+# 775 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 3
+      template<typename _NodeGen>
+ _Link_type
+ _M_copy(_Const_Link_type __x, _Link_type __p, _NodeGen&);
+
+      _Link_type
+      _M_copy(_Const_Link_type __x, _Link_type __p)
+      {
+ _Alloc_node __an(*this);
+ return _M_copy(__x, __p, __an);
+      }
+
+      void
+      _M_erase(_Link_type __x);
+
+      iterator
+      _M_lower_bound(_Link_type __x, _Link_type __y,
+       const _Key& __k);
+
+      const_iterator
+      _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
+       const _Key& __k) const;
+
+      iterator
+      _M_upper_bound(_Link_type __x, _Link_type __y,
+       const _Key& __k);
+
+      const_iterator
+      _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
+       const _Key& __k) const;
+
+    public:
+
+      _Rb_tree() { }
+
+      _Rb_tree(const _Compare& __comp,
+        const allocator_type& __a = allocator_type())
+      : _M_impl(__comp, _Node_allocator(__a)) { }
+
+      _Rb_tree(const _Rb_tree& __x)
+      : _M_impl(__x._M_impl._M_key_compare,
+         _Alloc_traits::_S_select_on_copy(__x._M_get_Node_allocator()))
+      {
+ if (__x._M_root() != 0)
+   {
+     _M_root() = _M_copy(__x._M_begin(), _M_end());
+     _M_leftmost() = _S_minimum(_M_root());
+     _M_rightmost() = _S_maximum(_M_root());
+     _M_impl._M_node_count = __x._M_impl._M_node_count;
+   }
+      }
+
+
+      _Rb_tree(const allocator_type& __a)
+      : _M_impl(_Compare(), _Node_allocator(__a))
+      { }
+
+      _Rb_tree(const _Rb_tree& __x, const allocator_type& __a)
+      : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a))
+      {
+ if (__x._M_root() != nullptr)
+   {
+     _M_root() = _M_copy(__x._M_begin(), _M_end());
+     _M_leftmost() = _S_minimum(_M_root());
+     _M_rightmost() = _S_maximum(_M_root());
+     _M_impl._M_node_count = __x._M_impl._M_node_count;
+   }
+      }
+
+      _Rb_tree(_Rb_tree&& __x)
+      : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
+      {
+ if (__x._M_root() != 0)
+   _M_move_data(__x, std::true_type());
+      }
+
+      _Rb_tree(_Rb_tree&& __x, const allocator_type& __a)
+      : _Rb_tree(std::move(__x), _Node_allocator(__a))
+      { }
+
+      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a);
+
+
+      ~_Rb_tree() noexcept
+      { _M_erase(_M_begin()); }
+
+      _Rb_tree&
+      operator=(const _Rb_tree& __x);
+
+
+      _Compare
+      key_comp() const
+      { return _M_impl._M_key_compare; }
+
+      iterator
+      begin() noexcept
+      { return iterator(this->_M_impl._M_header._M_left); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(this->_M_impl._M_header._M_left); }
+
+      iterator
+      end() noexcept
+      { return iterator(&this->_M_impl._M_header); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(&this->_M_impl._M_header); }
+
+      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()); }
+
+      bool
+      empty() const noexcept
+      { return _M_impl._M_node_count == 0; }
+
+      size_type
+      size() const noexcept
+      { return _M_impl._M_node_count; }
+
+      size_type
+      max_size() const noexcept
+      { return _Alloc_traits::max_size(_M_get_Node_allocator()); }
+
+      void
+
+      swap(_Rb_tree& __t) noexcept(_Alloc_traits::_S_nothrow_swap());
+
+
+
+
+
+
+      template<typename _Arg>
+        pair<iterator, bool>
+        _M_insert_unique(_Arg&& __x);
+
+      template<typename _Arg>
+        iterator
+        _M_insert_equal(_Arg&& __x);
+
+      template<typename _Arg, typename _NodeGen>
+        iterator
+ _M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&);
+
+      template<typename _Arg>
+ iterator
+ _M_insert_unique_(const_iterator __pos, _Arg&& __x)
+ {
+   _Alloc_node __an(*this);
+   return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an);
+ }
+
+      template<typename _Arg, typename _NodeGen>
+ iterator
+ _M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&);
+
+      template<typename _Arg>
+ iterator
+ _M_insert_equal_(const_iterator __pos, _Arg&& __x)
+ {
+   _Alloc_node __an(*this);
+   return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an);
+ }
+
+      template<typename... _Args>
+ pair<iterator, bool>
+ _M_emplace_unique(_Args&&... __args);
+
+      template<typename... _Args>
+ iterator
+ _M_emplace_equal(_Args&&... __args);
+
+      template<typename... _Args>
+ iterator
+ _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);
+
+      template<typename... _Args>
+ iterator
+ _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);
+# 999 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 3
+      template<typename _InputIterator>
+        void
+        _M_insert_unique(_InputIterator __first, _InputIterator __last);
+
+      template<typename _InputIterator>
+        void
+        _M_insert_equal(_InputIterator __first, _InputIterator __last);
+
+    private:
+      void
+      _M_erase_aux(const_iterator __position);
+
+      void
+      _M_erase_aux(const_iterator __first, const_iterator __last);
+
+    public:
+
+
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(const_iterator __position)
+      {
+ const_iterator __result = __position;
+ ++__result;
+ _M_erase_aux(__position);
+ return __result._M_const_cast();
+      }
+
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(iterator __position)
+      {
+ iterator __result = __position;
+ ++__result;
+ _M_erase_aux(__position);
+ return __result;
+      }
+# 1047 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 3
+      size_type
+      erase(const key_type& __x);
+
+
+
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      {
+ _M_erase_aux(__first, __last);
+ return __last._M_const_cast();
+      }
+# 1069 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_tree.h" 3
+      void
+      erase(const key_type* __first, const key_type* __last);
+
+      void
+      clear() noexcept
+      {
+        _M_erase(_M_begin());
+ _M_impl._M_reset();
+      }
+
+
+      iterator
+      find(const key_type& __k);
+
+      const_iterator
+      find(const key_type& __k) const;
+
+      size_type
+      count(const key_type& __k) const;
+
+      iterator
+      lower_bound(const key_type& __k)
+      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
+
+      const_iterator
+      lower_bound(const key_type& __k) const
+      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
+
+      iterator
+      upper_bound(const key_type& __k)
+      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
+
+      const_iterator
+      upper_bound(const key_type& __k) const
+      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
+
+      pair<iterator, iterator>
+      equal_range(const key_type& __k);
+
+      pair<const_iterator, const_iterator>
+      equal_range(const key_type& __k) const;
+
+
+      template<typename _Cmp, typename _Kt, typename = __void_t<>>
+ struct __is_transparent { };
+
+      template<typename _Cmp, typename _Kt>
+ struct
+ __is_transparent<_Cmp, _Kt, __void_t<typename _Cmp::is_transparent>>
+ { typedef void type; };
+
+      static auto _S_iter(_Link_type __x) { return iterator(__x); }
+
+      static auto _S_iter(_Const_Link_type __x) { return const_iterator(__x); }
+
+      template<typename _Cmp, typename _Link, typename _Kt>
+ static auto
+ _S_lower_bound_tr(_Cmp& __cmp, _Link __x, _Link __y, const _Kt& __k)
+ {
+   while (__x != 0)
+     if (!__cmp(_S_key(__x), __k))
+       __y = __x, __x = _S_left(__x);
+     else
+       __x = _S_right(__x);
+   return _S_iter(__y);
+ }
+
+      template<typename _Cmp, typename _Link, typename _Kt>
+ static auto
+ _S_upper_bound_tr(_Cmp& __cmp, _Link __x, _Link __y, const _Kt& __k)
+ {
+   while (__x != 0)
+     if (__cmp(__k, _S_key(__x)))
+       __y = __x, __x = _S_left(__x);
+     else
+       __x = _S_right(__x);
+   return _S_iter(__y);
+ }
+
+      template<typename _Kt,
+        typename _Req = typename __is_transparent<_Compare, _Kt>::type>
+ iterator
+ _M_find_tr(const _Kt& __k)
+ {
+   auto& __cmp = _M_impl._M_key_compare;
+   auto __j = _S_lower_bound_tr(__cmp, _M_begin(), _M_end(), __k);
+   return (__j == end() || __cmp(__k, _S_key(__j._M_node)))
+     ? end() : __j;
+ }
+
+      template<typename _Kt,
+        typename _Req = typename __is_transparent<_Compare, _Kt>::type>
+ const_iterator
+ _M_find_tr(const _Kt& __k) const
+ {
+   auto& __cmp = _M_impl._M_key_compare;
+   auto __j = _S_lower_bound_tr(__cmp, _M_begin(), _M_end(), __k);
+   return (__j == end() || __cmp(__k, _S_key(__j._M_node)))
+     ? end() : __j;
+ }
+
+      template<typename _Kt,
+        typename _Req = typename __is_transparent<_Compare, _Kt>::type>
+ size_type
+ _M_count_tr(const _Kt& __k) const
+ {
+   auto __p = _M_equal_range_tr(__k);
+   return std::distance(__p.first, __p.second);
+ }
+
+      template<typename _Kt,
+        typename _Req = typename __is_transparent<_Compare, _Kt>::type>
+ iterator
+ _M_lower_bound_tr(const _Kt& __k)
+ {
+   auto& __cmp = _M_impl._M_key_compare;
+   return _S_lower_bound_tr(__cmp, _M_begin(), _M_end(), __k);
+ }
+
+      template<typename _Kt,
+        typename _Req = typename __is_transparent<_Compare, _Kt>::type>
+ const_iterator
+ _M_lower_bound_tr(const _Kt& __k) const
+ {
+   auto& __cmp = _M_impl._M_key_compare;
+   return _S_lower_bound_tr(__cmp, _M_begin(), _M_end(), __k);
+ }
+
+      template<typename _Kt,
+        typename _Req = typename __is_transparent<_Compare, _Kt>::type>
+ iterator
+ _M_upper_bound_tr(const _Kt& __k)
+ {
+   auto& __cmp = _M_impl._M_key_compare;
+   return _S_upper_bound_tr(__cmp, _M_begin(), _M_end(), __k);
+ }
+
+      template<typename _Kt,
+        typename _Req = typename __is_transparent<_Compare, _Kt>::type>
+ const_iterator
+ _M_upper_bound_tr(const _Kt& __k) const
+ {
+   auto& __cmp = _M_impl._M_key_compare;
+   return _S_upper_bound_tr(__cmp, _M_begin(), _M_end(), __k);
+ }
+
+      template<typename _Kt,
+        typename _Req = typename __is_transparent<_Compare, _Kt>::type>
+ pair<iterator, iterator>
+ _M_equal_range_tr(const _Kt& __k)
+ {
+   auto __low = _M_lower_bound_tr(__k);
+   auto __high = __low;
+   auto& __cmp = _M_impl._M_key_compare;
+   while (__high != end() && !__cmp(__k, _S_key(__high._M_node)))
+     ++__high;
+   return { __low, __high };
+ }
+
+      template<typename _Kt,
+        typename _Req = typename __is_transparent<_Compare, _Kt>::type>
+ pair<const_iterator, const_iterator>
+ _M_equal_range_tr(const _Kt& __k) const
+ {
+   auto __low = _M_lower_bound_tr(__k);
+   auto __high = __low;
+   auto& __cmp = _M_impl._M_key_compare;
+   while (__high != end() && !__cmp(__k, _S_key(__high._M_node)))
+     ++__high;
+   return { __low, __high };
+ }
+
+
+
+      bool
+      __rb_verify() const;
+
+
+      _Rb_tree&
+      operator=(_Rb_tree&&) noexcept(_Alloc_traits::_S_nothrow_move());
+
+      template<typename _Iterator>
+ void
+ _M_assign_unique(_Iterator, _Iterator);
+
+      template<typename _Iterator>
+ void
+ _M_assign_equal(_Iterator, _Iterator);
+
+    private:
+
+      void
+      _M_move_data(_Rb_tree&, std::true_type);
+
+
+
+      void
+      _M_move_data(_Rb_tree&, std::false_type);
+
+    };
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    {
+      return __x.size() == __y.size()
+      && std::equal(__x.begin(), __x.end(), __y.begin());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    {
+      return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline void
+    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
+    : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
+    {
+      using __eq = integral_constant<bool, _Alloc_traits::_S_always_equal()>;
+      if (__x._M_root() != nullptr)
+ _M_move_data(__x, __eq());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_move_data(_Rb_tree& __x, std::true_type)
+    {
+      _M_root() = __x._M_root();
+      _M_leftmost() = __x._M_leftmost();
+      _M_rightmost() = __x._M_rightmost();
+      _M_root()->_M_parent = _M_end();
+
+      __x._M_root() = 0;
+      __x._M_leftmost() = __x._M_end();
+      __x._M_rightmost() = __x._M_end();
+
+      this->_M_impl._M_node_count = __x._M_impl._M_node_count;
+      __x._M_impl._M_node_count = 0;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_move_data(_Rb_tree& __x, std::false_type)
+    {
+      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
+   _M_move_data(__x, std::true_type());
+      else
+ {
+   _Alloc_node __an(*this);
+   auto __lbd =
+     [&__an](const value_type& __cval)
+     {
+       auto& __val = const_cast<value_type&>(__cval);
+       return __an(std::move_if_noexcept(__val));
+     };
+   _M_root() = _M_copy(__x._M_begin(), _M_end(), __lbd);
+   _M_leftmost() = _S_minimum(_M_root());
+   _M_rightmost() = _S_maximum(_M_root());
+   _M_impl._M_node_count = __x._M_impl._M_node_count;
+ }
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    operator=(_Rb_tree&& __x)
+    noexcept(_Alloc_traits::_S_nothrow_move())
+    {
+      _M_impl._M_key_compare = __x._M_impl._M_key_compare;
+      if (_Alloc_traits::_S_propagate_on_move_assign()
+   || _Alloc_traits::_S_always_equal()
+   || _M_get_Node_allocator() == __x._M_get_Node_allocator())
+ {
+   clear();
+   if (__x._M_root() != nullptr)
+     _M_move_data(__x, std::true_type());
+   std::__alloc_on_move(_M_get_Node_allocator(),
+          __x._M_get_Node_allocator());
+   return *this;
+ }
+
+
+
+      _Reuse_or_alloc_node __roan(*this);
+      _M_impl._M_reset();
+      if (__x._M_root() != nullptr)
+ {
+   auto __lbd =
+     [&__roan](const value_type& __cval)
+     {
+       auto& __val = const_cast<value_type&>(__cval);
+       return __roan(std::move_if_noexcept(__val));
+     };
+   _M_root() = _M_copy(__x._M_begin(), _M_end(), __lbd);
+   _M_leftmost() = _S_minimum(_M_root());
+   _M_rightmost() = _S_maximum(_M_root());
+   _M_impl._M_node_count = __x._M_impl._M_node_count;
+   __x.clear();
+ }
+      return *this;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename _Iterator>
+      void
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_assign_unique(_Iterator __first, _Iterator __last)
+      {
+ _Reuse_or_alloc_node __roan(*this);
+ _M_impl._M_reset();
+ for (; __first != __last; ++__first)
+   _M_insert_unique_(end(), *__first, __roan);
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename _Iterator>
+      void
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_assign_equal(_Iterator __first, _Iterator __last)
+      {
+ _Reuse_or_alloc_node __roan(*this);
+ _M_impl._M_reset();
+ for (; __first != __last; ++__first)
+   _M_insert_equal_(end(), *__first, __roan);
+      }
+
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    operator=(const _Rb_tree& __x)
+    {
+      if (this != &__x)
+ {
+
+
+   if (_Alloc_traits::_S_propagate_on_copy_assign())
+     {
+       auto& __this_alloc = this->_M_get_Node_allocator();
+       auto& __that_alloc = __x._M_get_Node_allocator();
+       if (!_Alloc_traits::_S_always_equal()
+    && __this_alloc != __that_alloc)
+  {
+
+
+    clear();
+    std::__alloc_on_copy(__this_alloc, __that_alloc);
+  }
+     }
+
+
+   _Reuse_or_alloc_node __roan(*this);
+   _M_impl._M_reset();
+   _M_impl._M_key_compare = __x._M_impl._M_key_compare;
+   if (__x._M_root() != 0)
+     {
+       _M_root() = _M_copy(__x._M_begin(), _M_end(), __roan);
+       _M_leftmost() = _S_minimum(_M_root());
+       _M_rightmost() = _S_maximum(_M_root());
+       _M_impl._M_node_count = __x._M_impl._M_node_count;
+     }
+ }
+
+      return *this;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+
+    template<typename _Arg, typename _NodeGen>
+
+
+
+      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_insert_(_Base_ptr __x, _Base_ptr __p,
+
+   _Arg&& __v,
+
+
+
+   _NodeGen& __node_gen)
+      {
+ bool __insert_left = (__x != 0 || __p == _M_end()
+         || _M_impl._M_key_compare(_KeyOfValue()(__v),
+       _S_key(__p)));
+
+ _Link_type __z = __node_gen(std::forward<_Arg>(__v));
+
+ _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+          this->_M_impl._M_header);
+ ++_M_impl._M_node_count;
+ return iterator(__z);
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+
+    template<typename _Arg>
+
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+
+    _M_insert_lower(_Base_ptr __p, _Arg&& __v)
+
+
+
+    {
+      bool __insert_left = (__p == _M_end()
+       || !_M_impl._M_key_compare(_S_key(__p),
+             _KeyOfValue()(__v)));
+
+      _Link_type __z = _M_create_node(std::forward<_Arg>(__v));
+
+      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+        this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+
+    template<typename _Arg>
+
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+
+    _M_insert_equal_lower(_Arg&& __v)
+
+
+
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   __y = __x;
+   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
+         _S_left(__x) : _S_right(__x);
+ }
+      return _M_insert_lower(__y, std::forward<_Arg>(__v));
+    }
+
+  template<typename _Key, typename _Val, typename _KoV,
+    typename _Compare, typename _Alloc>
+    template<typename _NodeGen>
+      typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
+      _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
+      _M_copy(_Const_Link_type __x, _Link_type __p, _NodeGen& __node_gen)
+      {
+
+ _Link_type __top = _M_clone_node(__x, __node_gen);
+ __top->_M_parent = __p;
+
+ try
+   {
+     if (__x->_M_right)
+       __top->_M_right = _M_copy(_S_right(__x), __top, __node_gen);
+     __p = __top;
+     __x = _S_left(__x);
+
+     while (__x != 0)
+       {
+  _Link_type __y = _M_clone_node(__x, __node_gen);
+  __p->_M_left = __y;
+  __y->_M_parent = __p;
+  if (__x->_M_right)
+    __y->_M_right = _M_copy(_S_right(__x), __y, __node_gen);
+  __p = __y;
+  __x = _S_left(__x);
+       }
+   }
+ catch(...)
+   {
+     _M_erase(__top);
+     throw;
+   }
+ return __top;
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase(_Link_type __x)
+    {
+
+      while (__x != 0)
+ {
+   _M_erase(_S_right(__x));
+   _Link_type __y = _S_left(__x);
+   _M_drop_node(__x);
+   __x = __y;
+ }
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_lower_bound(_Link_type __x, _Link_type __y,
+     const _Key& __k)
+    {
+      while (__x != 0)
+ if (!_M_impl._M_key_compare(_S_key(__x), __k))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
+     const _Key& __k) const
+    {
+      while (__x != 0)
+ if (!_M_impl._M_key_compare(_S_key(__x), __k))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return const_iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_upper_bound(_Link_type __x, _Link_type __y,
+     const _Key& __k)
+    {
+      while (__x != 0)
+ if (_M_impl._M_key_compare(__k, _S_key(__x)))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
+     const _Key& __k) const
+    {
+      while (__x != 0)
+ if (_M_impl._M_key_compare(__k, _S_key(__x)))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return const_iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::iterator,
+  typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::iterator>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    equal_range(const _Key& __k)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   if (_M_impl._M_key_compare(_S_key(__x), __k))
+     __x = _S_right(__x);
+   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
+     __y = __x, __x = _S_left(__x);
+   else
+     {
+       _Link_type __xu(__x), __yu(__y);
+       __y = __x, __x = _S_left(__x);
+       __xu = _S_right(__xu);
+       return pair<iterator,
+            iterator>(_M_lower_bound(__x, __y, __k),
+        _M_upper_bound(__xu, __yu, __k));
+     }
+ }
+      return pair<iterator, iterator>(iterator(__y),
+          iterator(__y));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::const_iterator,
+  typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::const_iterator>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    equal_range(const _Key& __k) const
+    {
+      _Const_Link_type __x = _M_begin();
+      _Const_Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   if (_M_impl._M_key_compare(_S_key(__x), __k))
+     __x = _S_right(__x);
+   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
+     __y = __x, __x = _S_left(__x);
+   else
+     {
+       _Const_Link_type __xu(__x), __yu(__y);
+       __y = __x, __x = _S_left(__x);
+       __xu = _S_right(__xu);
+       return pair<const_iterator,
+            const_iterator>(_M_lower_bound(__x, __y, __k),
+       _M_upper_bound(__xu, __yu, __k));
+     }
+ }
+      return pair<const_iterator, const_iterator>(const_iterator(__y),
+        const_iterator(__y));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
+
+    noexcept(_Alloc_traits::_S_nothrow_swap())
+
+    {
+      if (_M_root() == 0)
+ {
+   if (__t._M_root() != 0)
+     {
+       _M_root() = __t._M_root();
+       _M_leftmost() = __t._M_leftmost();
+       _M_rightmost() = __t._M_rightmost();
+       _M_root()->_M_parent = _M_end();
+       _M_impl._M_node_count = __t._M_impl._M_node_count;
+
+       __t._M_impl._M_reset();
+     }
+ }
+      else if (__t._M_root() == 0)
+ {
+   __t._M_root() = _M_root();
+   __t._M_leftmost() = _M_leftmost();
+   __t._M_rightmost() = _M_rightmost();
+   __t._M_root()->_M_parent = __t._M_end();
+   __t._M_impl._M_node_count = _M_impl._M_node_count;
+
+   _M_impl._M_reset();
+ }
+      else
+ {
+   std::swap(_M_root(),__t._M_root());
+   std::swap(_M_leftmost(),__t._M_leftmost());
+   std::swap(_M_rightmost(),__t._M_rightmost());
+
+   _M_root()->_M_parent = _M_end();
+   __t._M_root()->_M_parent = __t._M_end();
+   std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
+ }
+
+      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
+
+      _Alloc_traits::_S_on_swap(_M_get_Node_allocator(),
+    __t._M_get_Node_allocator());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::_Base_ptr,
+  typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::_Base_ptr>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_get_insert_unique_pos(const key_type& __k)
+    {
+      typedef pair<_Base_ptr, _Base_ptr> _Res;
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      bool __comp = true;
+      while (__x != 0)
+ {
+   __y = __x;
+   __comp = _M_impl._M_key_compare(__k, _S_key(__x));
+   __x = __comp ? _S_left(__x) : _S_right(__x);
+ }
+      iterator __j = iterator(__y);
+      if (__comp)
+ {
+   if (__j == begin())
+     return _Res(__x, __y);
+   else
+     --__j;
+ }
+      if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
+ return _Res(__x, __y);
+      return _Res(__j._M_node, 0);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::_Base_ptr,
+  typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::_Base_ptr>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_get_insert_equal_pos(const key_type& __k)
+    {
+      typedef pair<_Base_ptr, _Base_ptr> _Res;
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   __y = __x;
+   __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
+         _S_left(__x) : _S_right(__x);
+ }
+      return _Res(__x, __y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+
+    template<typename _Arg>
+
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::iterator, bool>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+
+    _M_insert_unique(_Arg&& __v)
+
+
+
+    {
+      typedef pair<iterator, bool> _Res;
+      pair<_Base_ptr, _Base_ptr> __res
+ = _M_get_insert_unique_pos(_KeyOfValue()(__v));
+
+      if (__res.second)
+ {
+   _Alloc_node __an(*this);
+   return _Res(_M_insert_(__res.first, __res.second,
+     std::forward<_Arg>(__v), __an),
+        true);
+ }
+
+      return _Res(iterator(static_cast<_Link_type>(__res.first)), false);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+
+    template<typename _Arg>
+
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+
+    _M_insert_equal(_Arg&& __v)
+
+
+
+    {
+      pair<_Base_ptr, _Base_ptr> __res
+ = _M_get_insert_equal_pos(_KeyOfValue()(__v));
+      _Alloc_node __an(*this);
+      return _M_insert_(__res.first, __res.second,
+   std::forward<_Arg>(__v), __an);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::_Base_ptr,
+         typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::_Base_ptr>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_get_insert_hint_unique_pos(const_iterator __position,
+      const key_type& __k)
+    {
+      iterator __pos = __position._M_const_cast();
+      typedef pair<_Base_ptr, _Base_ptr> _Res;
+
+
+      if (__pos._M_node == _M_end())
+ {
+   if (size() > 0
+       && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
+     return _Res(0, _M_rightmost());
+   else
+     return _M_get_insert_unique_pos(__k);
+ }
+      else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
+ {
+
+   iterator __before = __pos;
+   if (__pos._M_node == _M_leftmost())
+     return _Res(_M_leftmost(), _M_leftmost());
+   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
+     {
+       if (_S_right(__before._M_node) == 0)
+  return _Res(0, __before._M_node);
+       else
+  return _Res(__pos._M_node, __pos._M_node);
+     }
+   else
+     return _M_get_insert_unique_pos(__k);
+ }
+      else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
+ {
+
+   iterator __after = __pos;
+   if (__pos._M_node == _M_rightmost())
+     return _Res(0, _M_rightmost());
+   else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
+     {
+       if (_S_right(__pos._M_node) == 0)
+  return _Res(0, __pos._M_node);
+       else
+  return _Res(__after._M_node, __after._M_node);
+     }
+   else
+     return _M_get_insert_unique_pos(__k);
+ }
+      else
+
+ return _Res(__pos._M_node, 0);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+
+    template<typename _Arg, typename _NodeGen>
+
+
+
+      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_insert_unique_(const_iterator __position,
+
+   _Arg&& __v,
+
+
+
+   _NodeGen& __node_gen)
+    {
+      pair<_Base_ptr, _Base_ptr> __res
+ = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));
+
+      if (__res.second)
+ return _M_insert_(__res.first, __res.second,
+     std::forward<_Arg>(__v),
+     __node_gen);
+      return iterator(static_cast<_Link_type>(__res.first));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::_Base_ptr,
+         typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::_Base_ptr>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
+    {
+      iterator __pos = __position._M_const_cast();
+      typedef pair<_Base_ptr, _Base_ptr> _Res;
+
+
+      if (__pos._M_node == _M_end())
+ {
+   if (size() > 0
+       && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
+     return _Res(0, _M_rightmost());
+   else
+     return _M_get_insert_equal_pos(__k);
+ }
+      else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
+ {
+
+   iterator __before = __pos;
+   if (__pos._M_node == _M_leftmost())
+     return _Res(_M_leftmost(), _M_leftmost());
+   else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
+     {
+       if (_S_right(__before._M_node) == 0)
+  return _Res(0, __before._M_node);
+       else
+  return _Res(__pos._M_node, __pos._M_node);
+     }
+   else
+     return _M_get_insert_equal_pos(__k);
+ }
+      else
+ {
+
+   iterator __after = __pos;
+   if (__pos._M_node == _M_rightmost())
+     return _Res(0, _M_rightmost());
+   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
+     {
+       if (_S_right(__pos._M_node) == 0)
+  return _Res(0, __pos._M_node);
+       else
+  return _Res(__after._M_node, __after._M_node);
+     }
+   else
+     return _Res(0, 0);
+ }
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+
+    template<typename _Arg, typename _NodeGen>
+
+
+
+      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_insert_equal_(const_iterator __position,
+
+         _Arg&& __v,
+
+
+
+         _NodeGen& __node_gen)
+      {
+ pair<_Base_ptr, _Base_ptr> __res
+   = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));
+
+ if (__res.second)
+   return _M_insert_(__res.first, __res.second,
+       std::forward<_Arg>(__v),
+       __node_gen);
+
+ return _M_insert_equal_lower(std::forward<_Arg>(__v));
+      }
+
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z)
+    {
+      bool __insert_left = (__x != 0 || __p == _M_end()
+       || _M_impl._M_key_compare(_S_key(__z),
+            _S_key(__p)));
+
+      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+        this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_lower_node(_Base_ptr __p, _Link_type __z)
+    {
+      bool __insert_left = (__p == _M_end()
+       || !_M_impl._M_key_compare(_S_key(__p),
+             _S_key(__z)));
+
+      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+        this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_equal_lower_node(_Link_type __z)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   __y = __x;
+   __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ?
+         _S_left(__x) : _S_right(__x);
+ }
+      return _M_insert_lower_node(__y, __z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename... _Args>
+      pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator, bool>
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_emplace_unique(_Args&&... __args)
+      {
+ _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
+
+ try
+   {
+     typedef pair<iterator, bool> _Res;
+     auto __res = _M_get_insert_unique_pos(_S_key(__z));
+     if (__res.second)
+       return _Res(_M_insert_node(__res.first, __res.second, __z), true);
+
+     _M_drop_node(__z);
+     return _Res(iterator(static_cast<_Link_type>(__res.first)), false);
+   }
+ catch(...)
+   {
+     _M_drop_node(__z);
+     throw;
+   }
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename... _Args>
+      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_emplace_equal(_Args&&... __args)
+      {
+ _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
+
+ try
+   {
+     auto __res = _M_get_insert_equal_pos(_S_key(__z));
+     return _M_insert_node(__res.first, __res.second, __z);
+   }
+ catch(...)
+   {
+     _M_drop_node(__z);
+     throw;
+   }
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename... _Args>
+      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
+      {
+ _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
+
+ try
+   {
+     auto __res = _M_get_insert_hint_unique_pos(__pos, _S_key(__z));
+
+     if (__res.second)
+       return _M_insert_node(__res.first, __res.second, __z);
+
+     _M_drop_node(__z);
+     return iterator(static_cast<_Link_type>(__res.first));
+   }
+ catch(...)
+   {
+     _M_drop_node(__z);
+     throw;
+   }
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    template<typename... _Args>
+      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+      _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
+      {
+ _Link_type __z = _M_create_node(std::forward<_Args>(__args)...);
+
+ try
+   {
+     auto __res = _M_get_insert_hint_equal_pos(__pos, _S_key(__z));
+
+     if (__res.second)
+       return _M_insert_node(__res.first, __res.second, __z);
+
+     return _M_insert_equal_lower_node(__z);
+   }
+ catch(...)
+   {
+     _M_drop_node(__z);
+     throw;
+   }
+      }
+
+
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Cmp, typename _Alloc>
+    template<class _II>
+      void
+      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
+      _M_insert_unique(_II __first, _II __last)
+      {
+ _Alloc_node __an(*this);
+ for (; __first != __last; ++__first)
+   _M_insert_unique_(end(), *__first, __an);
+      }
+
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Cmp, typename _Alloc>
+    template<class _II>
+      void
+      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
+      _M_insert_equal(_II __first, _II __last)
+      {
+ _Alloc_node __an(*this);
+ for (; __first != __last; ++__first)
+   _M_insert_equal_(end(), *__first, __an);
+      }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase_aux(const_iterator __position)
+    {
+      _Link_type __y =
+ static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
+    (const_cast<_Base_ptr>(__position._M_node),
+     this->_M_impl._M_header));
+      _M_drop_node(__y);
+      --_M_impl._M_node_count;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase_aux(const_iterator __first, const_iterator __last)
+    {
+      if (__first == begin() && __last == end())
+ clear();
+      else
+ while (__first != __last)
+   erase(__first++);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const _Key& __x)
+    {
+      pair<iterator, iterator> __p = equal_range(__x);
+      const size_type __old_size = size();
+      erase(__p.first, __p.second);
+      return __old_size - size();
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const _Key* __first, const _Key* __last)
+    {
+      while (__first != __last)
+ erase(*__first++);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    find(const _Key& __k)
+    {
+      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
+      return (__j == end()
+       || _M_impl._M_key_compare(__k,
+     _S_key(__j._M_node))) ? end() : __j;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    find(const _Key& __k) const
+    {
+      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
+      return (__j == end()
+       || _M_impl._M_key_compare(__k,
+     _S_key(__j._M_node))) ? end() : __j;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    count(const _Key& __k) const
+    {
+      pair<const_iterator, const_iterator> __p = equal_range(__k);
+      const size_type __n = std::distance(__p.first, __p.second);
+      return __n;
+    }
+
+  __attribute__ ((__pure__)) unsigned int
+  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
+                       const _Rb_tree_node_base* __root) throw ();
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    bool
+    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
+    {
+      if (_M_impl._M_node_count == 0 || begin() == end())
+ return _M_impl._M_node_count == 0 && begin() == end()
+        && this->_M_impl._M_header._M_left == _M_end()
+        && this->_M_impl._M_header._M_right == _M_end();
+
+      unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
+      for (const_iterator __it = begin(); __it != end(); ++__it)
+ {
+   _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
+   _Const_Link_type __L = _S_left(__x);
+   _Const_Link_type __R = _S_right(__x);
+
+   if (__x->_M_color == _S_red)
+     if ((__L && __L->_M_color == _S_red)
+  || (__R && __R->_M_color == _S_red))
+       return false;
+
+   if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
+     return false;
+   if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
+     return false;
+
+   if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
+     return false;
+ }
+
+      if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
+ return false;
+      if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
+ return false;
+      return true;
+    }
+
+
+}
+# 61 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/map" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 1 3
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/tuple" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/tuple" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/tuple" 3
+
+
+
+
+
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/array" 1 3
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/array" 3
+       
+# 33 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/array" 3
+# 42 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/array" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __array_traits
+    {
+      typedef _Tp _Type[_Nm];
+
+      static constexpr _Tp&
+      _S_ref(const _Type& __t, std::size_t __n) noexcept
+      { return const_cast<_Tp&>(__t[__n]); }
+
+      static constexpr _Tp*
+      _S_ptr(const _Type& __t) noexcept
+      { return const_cast<_Tp*>(__t); }
+    };
+
+ template<typename _Tp>
+   struct __array_traits<_Tp, 0>
+   {
+     struct _Type { };
+
+     static constexpr _Tp&
+     _S_ref(const _Type&, std::size_t) noexcept
+     { return *static_cast<_Tp*>(nullptr); }
+
+     static constexpr _Tp*
+     _S_ptr(const _Type&) noexcept
+     { return nullptr; }
+   };
+# 88 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/array" 3
+  template<typename _Tp, std::size_t _Nm>
+    struct array
+    {
+      typedef _Tp value_type;
+      typedef value_type* pointer;
+      typedef const value_type* const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+      typedef value_type* iterator;
+      typedef const value_type* const_iterator;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+
+      typedef std::__array_traits<_Tp, _Nm> _AT_Type;
+      typename _AT_Type::_Type _M_elems;
+
+
+
+
+      void
+      fill(const value_type& __u)
+      { std::fill_n(begin(), size(), __u); }
+
+      void
+      swap(array& __other)
+      noexcept(noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())))
+      { std::swap_ranges(begin(), end(), __other.begin()); }
+
+
+      iterator
+      begin() noexcept
+      { return iterator(data()); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(data()); }
+
+      iterator
+      end() noexcept
+      { return iterator(data() + _Nm); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      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(data()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(data() + _Nm); }
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return const_reverse_iterator(end()); }
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(begin()); }
+
+
+      constexpr size_type
+      size() const noexcept { return _Nm; }
+
+      constexpr size_type
+      max_size() const noexcept { return _Nm; }
+
+      constexpr bool
+      empty() const noexcept { return size() == 0; }
+
+
+      reference
+      operator[](size_type __n) noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+
+      constexpr const_reference
+      operator[](size_type __n) const noexcept
+      { return _AT_Type::_S_ref(_M_elems, __n); }
+
+      reference
+      at(size_type __n)
+      {
+ if (__n >= _Nm)
+   std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
+                                 ,
+     __n, _Nm);
+ return _AT_Type::_S_ref(_M_elems, __n);
+      }
+
+      constexpr const_reference
+      at(size_type __n) const
+      {
+
+
+ return __n < _Nm ? _AT_Type::_S_ref(_M_elems, __n)
+   : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)")
+                                    ,
+        __n, _Nm),
+      _AT_Type::_S_ref(_M_elems, 0));
+      }
+
+      reference
+      front() noexcept
+      { return *begin(); }
+
+      constexpr const_reference
+      front() const noexcept
+      { return _AT_Type::_S_ref(_M_elems, 0); }
+
+      reference
+      back() noexcept
+      { return _Nm ? *(end() - 1) : *end(); }
+
+      constexpr const_reference
+      back() const noexcept
+      {
+ return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1)
+             : _AT_Type::_S_ref(_M_elems, 0);
+      }
+
+      pointer
+      data() noexcept
+      { return _AT_Type::_S_ptr(_M_elems); }
+
+      const_pointer
+      data() const noexcept
+      { return _AT_Type::_S_ptr(_M_elems); }
+    };
+
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return std::equal(__one.begin(), __one.end(), __two.begin()); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one == __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
+    {
+      return std::lexicographical_compare(__a.begin(), __a.end(),
+       __b.begin(), __b.end());
+    }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return __two < __one; }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one > __two); }
+
+  template<typename _Tp, std::size_t _Nm>
+    inline bool
+    operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
+    { return !(__one < __two); }
+
+
+  template<typename _Tp, std::size_t _Nm>
+    inline void
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    noexcept(noexcept(__one.swap(__two)))
+    { __one.swap(__two); }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&
+    get(array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return std::__array_traits<_Tp, _Nm>::
+ _S_ref(__arr._M_elems, _Int);
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&&
+    get(array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return std::move(std::get<_Int>(__arr));
+    }
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr const _Tp&
+    get(const array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      return std::__array_traits<_Tp, _Nm>::
+ _S_ref(__arr._M_elems, _Int);
+    }
+
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  template<typename _Tp>
+    class tuple_size;
+
+
+  template<typename _Tp, std::size_t _Nm>
+    struct tuple_size<std::array<_Tp, _Nm>>
+    : public integral_constant<std::size_t, _Nm> { };
+
+
+  template<std::size_t _Int, typename _Tp>
+    class tuple_element;
+
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    struct tuple_element<_Int, std::array<_Tp, _Nm>>
+    {
+      static_assert(_Int < _Nm, "index is out of bounds");
+      typedef _Tp type;
+    };
+
+
+}
+# 40 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/tuple" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/uses_allocator.h" 1 3
+# 34 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/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, typename _Alloc, typename = __void_t<>>
+    struct __uses_allocator_helper
+    : false_type { };
+
+  template<typename _Tp, typename _Alloc>
+    struct __uses_allocator_helper<_Tp, _Alloc,
+       __void_t<typename _Tp::allocator_type>>
+    : is_convertible<_Alloc, typename _Tp::allocator_type>::type
+    { };
+
+
+  template<typename _Tp, typename _Alloc>
+    struct uses_allocator
+    : __uses_allocator_helper<_Tp, _Alloc>::type
+    { };
+
+  struct __uses_alloc_base { };
+
+  struct __uses_alloc0 : __uses_alloc_base
+  {
+    struct _Sink { void operator=(const void*) { } } _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 _Tp, 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>
+    using __uses_alloc_t =
+      __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline __uses_alloc_t<_Tp, _Alloc, _Args...>
+    __use_alloc(const _Alloc& __a)
+    {
+      __uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
+      __ret._M_a = &__a;
+      return __ret;
+    }
+
+
+}
+# 41 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/tuple" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  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) { }
+
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+
+      template<typename _UHead>
+        constexpr _Head_base(_UHead&& __h)
+ : _Head(std::forward<_UHead>(__h)) { }
+
+      _Head_base(allocator_arg_t, __uses_alloc0)
+      : _Head() { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
+ : _Head(allocator_arg, *__a._M_a) { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __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) { }
+
+      constexpr _Head_base(const _Head_base&) = default;
+      constexpr _Head_base(_Head_base&&) = default;
+
+      template<typename _UHead>
+        constexpr _Head_base(_UHead&& __h)
+ : _M_head_impl(std::forward<_UHead>(__h)) { }
+
+      _Head_base(allocator_arg_t, __uses_alloc0)
+      : _M_head_impl() { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
+ : _M_head_impl(allocator_arg, *__a._M_a) { }
+
+      template<typename _Alloc>
+ _Head_base(allocator_arg_t, __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;
+    };
+# 158 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/tuple" 3
+  template<std::size_t _Idx, typename... _Elements>
+    struct _Tuple_impl;
+
+  template<typename _Tp>
+    struct __is_empty_non_tuple : is_empty<_Tp> { };
+
+
+  template<typename _El0, typename... _El>
+    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
+
+
+  template<typename _Tp>
+    using __empty_not_final
+    = typename conditional<__is_final(_Tp), false_type,
+      __is_empty_non_tuple<_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(__tag, __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<std::size_t _Idx, typename _Head>
+    struct _Tuple_impl<_Idx, _Head>
+    : private _Head_base<_Idx, _Head, __empty_not_final<_Head>::value>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+
+      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); }
+
+      constexpr _Tuple_impl()
+      : _Base() { }
+
+      explicit
+      constexpr _Tuple_impl(const _Head& __head)
+      : _Base(__head) { }
+
+      template<typename _UHead>
+        explicit
+        constexpr _Tuple_impl(_UHead&& __head)
+ : _Base(std::forward<_UHead>(__head)) { }
+
+      constexpr _Tuple_impl(const _Tuple_impl&) = default;
+
+      constexpr
+      _Tuple_impl(_Tuple_impl&& __in)
+      noexcept(is_nothrow_move_constructible<_Head>::value)
+      : _Base(std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename _UHead>
+        constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
+ : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+
+      template<typename _UHead>
+        constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
+ : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
+ : _Base(__tag, __use_alloc<_Head>(__a)) { }
+
+      template<typename _Alloc>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+      const _Head& __head)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _UHead&& __head)
+ : _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)
+ : _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)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+         std::forward<_Head>(_M_head(__in))) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             const _Tuple_impl<_Idx, _UHead>& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
+  _Tuple_impl<_Idx, _UHead>::_M_head(__in)) { }
+
+      template<typename _Alloc, typename _UHead>
+ _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
+             _Tuple_impl<_Idx, _UHead>&& __in)
+ : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
+                std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ { }
+
+      _Tuple_impl&
+      operator=(const _Tuple_impl& __in)
+      {
+ _M_head(*this) = _M_head(__in);
+ return *this;
+      }
+
+      _Tuple_impl&
+      operator=(_Tuple_impl&& __in)
+      noexcept(is_nothrow_move_assignable<_Head>::value)
+      {
+ _M_head(*this) = std::forward<_Head>(_M_head(__in));
+ return *this;
+      }
+
+      template<typename _UHead>
+        _Tuple_impl&
+        operator=(const _Tuple_impl<_Idx, _UHead>& __in)
+        {
+   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
+   return *this;
+ }
+
+      template<typename _UHead>
+        _Tuple_impl&
+        operator=(_Tuple_impl<_Idx, _UHead>&& __in)
+        {
+   _M_head(*this)
+     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
+   return *this;
+ }
+
+    protected:
+      void
+      _M_swap(_Tuple_impl& __in)
+      noexcept(noexcept(swap(std::declval<_Head&>(), std::declval<_Head&>())))
+      {
+ using std::swap;
+ swap(_M_head(*this), _M_head(__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>
+    using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const _Tp>
+    {
+      typedef typename add_const<__tuple_element_t<__i, _Tp>>::type type;
+    };
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, volatile _Tp>
+    {
+      typedef typename add_volatile<__tuple_element_t<__i, _Tp>>::type type;
+    };
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element<__i, const volatile _Tp>
+    {
+      typedef typename add_cv<__tuple_element_t<__i, _Tp>>::type type;
+    };
+
+
+
+
+  template<std::size_t __i, typename _Tp>
+    using tuple_element_t = typename tuple_element<__i, _Tp>::type;
+
+
+
+  template<typename _Tp>
+    struct tuple_size;
+
+
+
+  template<typename _Tp>
+    struct tuple_size<const _Tp>
+    : integral_constant<size_t, tuple_size<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct tuple_size<volatile _Tp>
+    : integral_constant<size_t, tuple_size<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct tuple_size<const volatile _Tp>
+    : integral_constant<size_t, 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 _Head&
+    __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 const _Head&
+    __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 __tuple_element_t<__i, tuple<_Elements...>>&
+    get(tuple<_Elements...>& __t) noexcept
+    { return std::__get_helper<__i>(__t); }
+
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
+    get(const tuple<_Elements...>& __t) noexcept
+    { return std::__get_helper<__i>(__t); }
+
+
+  template<std::size_t __i, typename... _Elements>
+    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
+    get(tuple<_Elements...>&& __t) noexcept
+    {
+      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
+      return std::forward<__element_type&&>(std::get<__i>(__t));
+    }
+
+
+
+
+
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr _Head&
+    __get_helper2(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+  template<typename _Head, size_t __i, typename... _Tail>
+    constexpr const _Head&
+    __get_helper2(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
+    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&
+    get(tuple<_Types...>& __t) noexcept
+    { return std::__get_helper2<_Tp>(__t); }
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr _Tp&&
+    get(tuple<_Types...>&& __t) noexcept
+    { return std::forward<_Tp&&>(std::__get_helper2<_Tp>(__t)); }
+
+
+  template <typename _Tp, typename... _Types>
+    constexpr const _Tp&
+    get(const tuple<_Types...>& __t) noexcept
+    { return std::__get_helper2<_Tp>(__t); }
+
+
+
+  template<typename _Tp, typename _Up, size_t __i, size_t __size>
+    struct __tuple_compare
+    {
+      static constexpr bool
+      __eq(const _Tp& __t, const _Up& __u)
+      {
+ return bool(std::get<__i>(__t) == std::get<__i>(__u))
+   && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
+      }
+
+      static constexpr bool
+      __less(const _Tp& __t, const _Up& __u)
+      {
+ return bool(std::get<__i>(__t) < std::get<__i>(__u))
+   || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
+       && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
+      }
+    };
+
+  template<typename _Tp, typename _Up, size_t __size>
+    struct __tuple_compare<_Tp, _Up, __size, __size>
+    {
+      static constexpr bool
+      __eq(const _Tp&, const _Up&) { return true; }
+
+      static constexpr bool
+      __less(const _Tp&, const _Up&) { return false; }
+    };
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator==(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    {
+      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
+   "tuple objects can only be compared if they have equal sizes.");
+      using __compare = __tuple_compare<tuple<_TElements...>,
+     tuple<_UElements...>,
+     0, sizeof...(_TElements)>;
+      return __compare::__eq(__t, __u);
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<(const tuple<_TElements...>& __t,
+       const tuple<_UElements...>& __u)
+    {
+      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
+   "tuple objects can only be compared if they have equal sizes.");
+      using __compare = __tuple_compare<tuple<_TElements...>,
+     tuple<_UElements...>,
+     0, sizeof...(_TElements)>;
+      return __compare::__less(__t, __u);
+    }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator!=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__t == __u); }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator>(const tuple<_TElements...>& __t,
+       const tuple<_UElements...>& __u)
+    { return __u < __t; }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr bool
+    operator<=(const tuple<_TElements...>& __t,
+        const tuple<_UElements...>& __u)
+    { return !(__u < __t); }
+
+  template<typename... _TElements, typename... _UElements>
+    constexpr 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>
+    tuple<_Elements&&...>
+    forward_as_tuple(_Elements&&... __args) noexcept
+    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
+
+  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<size_t, typename, typename, size_t>
+    struct __make_tuple_impl;
+
+  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
+    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
+    : __make_tuple_impl<_Idx + 1,
+   tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
+   _Tuple, _Nm>
+    { };
+
+  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
+    : __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))...)
+      { }
+
+
+
+
+}
+# 64 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 94 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
+            typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class map
+    {
+    public:
+      typedef _Key key_type;
+      typedef _Tp mapped_type;
+      typedef std::pair<const _Key, _Tp> value_type;
+      typedef _Compare key_compare;
+      typedef _Alloc allocator_type;
+
+    private:
+
+      typedef typename _Alloc::value_type _Alloc_value_type;
+     
+     
+
+     
+
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+ friend class map<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+ _Compare comp;
+
+ value_compare(_Compare __c)
+ : comp(__c) { }
+
+      public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+      };
+
+    private:
+
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<value_type>::other _Pair_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+         key_compare, _Pair_alloc_type> _Rep_type;
+
+
+      _Rep_type _M_t;
+
+      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;
+
+    public:
+
+
+      typedef typename _Alloc_traits::pointer pointer;
+      typedef typename _Alloc_traits::const_pointer const_pointer;
+      typedef typename _Alloc_traits::reference reference;
+      typedef typename _Alloc_traits::const_reference const_reference;
+      typedef typename _Rep_type::iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      typedef typename _Rep_type::reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+
+
+
+
+
+
+
+      map()
+
+      noexcept(is_nothrow_default_constructible<allocator_type>::value)
+
+      : _M_t() { }
+
+
+
+
+
+
+      explicit
+      map(const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a)) { }
+# 185 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      map(const map& __x)
+      : _M_t(__x._M_t) { }
+# 196 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      map(map&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _M_t(std::move(__x._M_t)) { }
+# 211 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      map(initializer_list<value_type> __l,
+   const _Compare& __comp = _Compare(),
+   const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a))
+      { _M_t._M_insert_unique(__l.begin(), __l.end()); }
+
+
+      explicit
+      map(const allocator_type& __a)
+      : _M_t(_Compare(), _Pair_alloc_type(__a)) { }
+
+
+      map(const map& __m, const allocator_type& __a)
+      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }
+
+
+      map(map&& __m, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+        && _Alloc_traits::_S_always_equal())
+      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }
+
+
+      map(initializer_list<value_type> __l, const allocator_type& __a)
+      : _M_t(_Compare(), _Pair_alloc_type(__a))
+      { _M_t._M_insert_unique(__l.begin(), __l.end()); }
+
+
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+     const allocator_type& __a)
+ : _M_t(_Compare(), _Pair_alloc_type(__a))
+        { _M_t._M_insert_unique(__first, __last); }
+# 255 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+        { _M_t._M_insert_unique(__first, __last); }
+# 272 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+     const _Compare& __comp,
+     const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _Pair_alloc_type(__a))
+        { _M_t._M_insert_unique(__first, __last); }
+# 295 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      map&
+      operator=(const map& __x)
+      {
+ _M_t = __x._M_t;
+ return *this;
+      }
+
+
+
+      map&
+      operator=(map&&) = default;
+# 318 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      map&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_t._M_assign_unique(__l.begin(), __l.end());
+ return *this;
+      }
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_t.get_allocator()); }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin() noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      reverse_iterator
+      rend() noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+      bool
+      empty() const noexcept
+      { return _M_t.empty(); }
+
+
+      size_type
+      size() const noexcept
+      { return _M_t.size(); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _M_t.max_size(); }
+# 473 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      mapped_type&
+      operator[](const key_type& __k)
+      {
+
+
+
+ iterator __i = lower_bound(__k);
+
+ if (__i == end() || key_comp()(__k, (*__i).first))
+
+   __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
+         std::tuple<const key_type&>(__k),
+         std::tuple<>());
+
+
+
+ return (*__i).second;
+      }
+
+
+      mapped_type&
+      operator[](key_type&& __k)
+      {
+
+
+
+ iterator __i = lower_bound(__k);
+
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
+     std::forward_as_tuple(std::move(__k)),
+     std::tuple<>());
+ return (*__i).second;
+      }
+# 518 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      mapped_type&
+      at(const key_type& __k)
+      {
+ iterator __i = lower_bound(__k);
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __throw_out_of_range(("map::at"));
+ return (*__i).second;
+      }
+
+      const mapped_type&
+      at(const key_type& __k) const
+      {
+ const_iterator __i = lower_bound(__k);
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __throw_out_of_range(("map::at"));
+ return (*__i).second;
+      }
+# 556 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      template<typename... _Args>
+ std::pair<iterator, bool>
+ emplace(_Args&&... __args)
+ { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
+# 586 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __pos, _Args&&... __args)
+ {
+   return _M_t._M_emplace_hint_unique(__pos,
+          std::forward<_Args>(__args)...);
+ }
+# 611 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_t._M_insert_unique(__x); }
+
+
+      template<typename _Pair, typename = typename
+        std::enable_if<std::is_constructible<value_type,
+          _Pair&&>::value>::type>
+        std::pair<iterator, bool>
+        insert(_Pair&& __x)
+        { return _M_t._M_insert_unique(std::forward<_Pair>(__x)); }
+# 632 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      void
+      insert(std::initializer_list<value_type> __list)
+      { insert(__list.begin(), __list.end()); }
+# 660 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      iterator
+
+      insert(const_iterator __position, const value_type& __x)
+
+
+
+      { return _M_t._M_insert_unique_(__position, __x); }
+
+
+      template<typename _Pair, typename = typename
+        std::enable_if<std::is_constructible<value_type,
+          _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __position, _Pair&& __x)
+        { return _M_t._M_insert_unique_(__position,
+     std::forward<_Pair>(__x)); }
+# 686 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_unique(__first, __last); }
+# 707 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+# 743 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 763 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+# 795 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      void
+      swap(map& __x)
+
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+
+      { _M_t.swap(__x._M_t); }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_t.clear(); }
+
+
+
+
+
+
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+
+
+
+
+
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+# 844 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+
+
+      template<typename _Kt>
+ auto
+ find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x))
+ { return _M_t._M_find_tr(__x); }
+# 869 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+
+
+      template<typename _Kt>
+ auto
+ find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x))
+ { return _M_t._M_find_tr(__x); }
+# 890 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
+
+
+      template<typename _Kt>
+ auto
+ count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x))
+ { return _M_t._M_find_tr(__x) == _M_t.end() ? 0 : 1; }
+# 914 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ lower_bound(const _Kt& __x)
+ -> decltype(_M_t._M_lower_bound_tr(__x))
+ { return _M_t._M_lower_bound_tr(__x); }
+# 939 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ lower_bound(const _Kt& __x) const
+ -> decltype(_M_t._M_lower_bound_tr(__x))
+ { return _M_t._M_lower_bound_tr(__x); }
+# 959 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ upper_bound(const _Kt& __x)
+ -> decltype(_M_t._M_upper_bound_tr(__x))
+ { return _M_t._M_upper_bound_tr(__x); }
+# 979 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ upper_bound(const _Kt& __x) const
+ -> decltype(_M_t._M_upper_bound_tr(__x))
+ { return _M_t._M_upper_bound_tr(__x); }
+# 1008 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+
+
+      template<typename _Kt>
+ auto
+ equal_range(const _Kt& __x)
+ -> decltype(_M_t._M_equal_range_tr(__x))
+ { return _M_t._M_equal_range_tr(__x); }
+# 1037 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+
+
+      template<typename _Kt>
+ auto
+ equal_range(const _Kt& __x) const
+ -> decltype(_M_t._M_equal_range_tr(__x))
+ { return _M_t._M_equal_range_tr(__x); }
+
+
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator==(const map<_K1, _T1, _C1, _A1>&,
+     const map<_K1, _T1, _C1, _A1>&);
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator<(const map<_K1, _T1, _C1, _A1>&,
+    const map<_K1, _T1, _C1, _A1>&);
+    };
+# 1071 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+# 1088 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_map.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+              const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+              const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
+  map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+
+}
+# 62 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/map" 2 3
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 1 3
+# 64 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 92 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+  template <typename _Key, typename _Tp,
+     typename _Compare = std::less<_Key>,
+     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class multimap
+    {
+    public:
+      typedef _Key key_type;
+      typedef _Tp mapped_type;
+      typedef std::pair<const _Key, _Tp> value_type;
+      typedef _Compare key_compare;
+      typedef _Alloc allocator_type;
+
+    private:
+
+      typedef typename _Alloc::value_type _Alloc_value_type;
+     
+     
+
+     
+
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+ friend class multimap<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+ _Compare comp;
+
+ value_compare(_Compare __c)
+ : comp(__c) { }
+
+      public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+      };
+
+    private:
+
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<value_type>::other _Pair_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+         key_compare, _Pair_alloc_type> _Rep_type;
+
+      _Rep_type _M_t;
+
+      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;
+
+    public:
+
+
+      typedef typename _Alloc_traits::pointer pointer;
+      typedef typename _Alloc_traits::const_pointer const_pointer;
+      typedef typename _Alloc_traits::reference reference;
+      typedef typename _Alloc_traits::const_reference const_reference;
+      typedef typename _Rep_type::iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      typedef typename _Rep_type::reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+
+
+
+
+
+
+
+      multimap()
+
+      noexcept(is_nothrow_default_constructible<allocator_type>::value)
+
+      : _M_t() { }
+
+
+
+
+
+
+      explicit
+      multimap(const _Compare& __comp,
+        const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a)) { }
+# 183 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      multimap(const multimap& __x)
+      : _M_t(__x._M_t) { }
+# 194 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      multimap(multimap&& __x)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value)
+      : _M_t(std::move(__x._M_t)) { }
+# 208 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      multimap(initializer_list<value_type> __l,
+        const _Compare& __comp = _Compare(),
+        const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a))
+      { _M_t._M_insert_equal(__l.begin(), __l.end()); }
+
+
+      explicit
+      multimap(const allocator_type& __a)
+      : _M_t(_Compare(), _Pair_alloc_type(__a)) { }
+
+
+      multimap(const multimap& __m, const allocator_type& __a)
+      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }
+
+
+      multimap(multimap&& __m, const allocator_type& __a)
+      noexcept(is_nothrow_copy_constructible<_Compare>::value
+        && _Alloc_traits::_S_always_equal())
+      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }
+
+
+      multimap(initializer_list<value_type> __l, const allocator_type& __a)
+      : _M_t(_Compare(), _Pair_alloc_type(__a))
+      { _M_t._M_insert_equal(__l.begin(), __l.end()); }
+
+
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last,
+   const allocator_type& __a)
+ : _M_t(_Compare(), _Pair_alloc_type(__a))
+        { _M_t._M_insert_equal(__first, __last); }
+# 251 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+        { _M_t._M_insert_equal(__first, __last); }
+# 267 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last,
+   const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+ : _M_t(__comp, _Pair_alloc_type(__a))
+        { _M_t._M_insert_equal(__first, __last); }
+# 290 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      multimap&
+      operator=(const multimap& __x)
+      {
+ _M_t = __x._M_t;
+ return *this;
+      }
+
+
+
+      multimap&
+      operator=(multimap&&) = default;
+# 313 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_t._M_assign_equal(__l.begin(), __l.end());
+ return *this;
+      }
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_t.get_allocator()); }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin() noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      reverse_iterator
+      rend() noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return _M_t.rend(); }
+
+
+
+
+
+
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      cend() const noexcept
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crbegin() const noexcept
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return _M_t.rend(); }
+
+
+
+
+      bool
+      empty() const noexcept
+      { return _M_t.empty(); }
+
+
+      size_type
+      size() const noexcept
+      { return _M_t.size(); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _M_t.max_size(); }
+# 471 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(_Args&&... __args)
+ { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
+# 498 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __pos, _Args&&... __args)
+ {
+   return _M_t._M_emplace_hint_equal(__pos,
+         std::forward<_Args>(__args)...);
+ }
+# 519 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      iterator
+      insert(const value_type& __x)
+      { return _M_t._M_insert_equal(__x); }
+
+
+      template<typename _Pair, typename = typename
+        std::enable_if<std::is_constructible<value_type,
+          _Pair&&>::value>::type>
+        iterator
+        insert(_Pair&& __x)
+        { return _M_t._M_insert_equal(std::forward<_Pair>(__x)); }
+# 552 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      iterator
+
+      insert(const_iterator __position, const value_type& __x)
+
+
+
+      { return _M_t._M_insert_equal_(__position, __x); }
+
+
+      template<typename _Pair, typename = typename
+        std::enable_if<std::is_constructible<value_type,
+          _Pair&&>::value>::type>
+        iterator
+        insert(const_iterator __position, _Pair&& __x)
+        { return _M_t._M_insert_equal_(__position,
+           std::forward<_Pair>(__x)); }
+# 579 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_equal(__first, __last); }
+# 592 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+# 613 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      iterator
+      erase(const_iterator __position)
+      { return _M_t.erase(__position); }
+
+
+      __attribute ((__abi_tag__ ("cxx11")))
+      iterator
+      erase(iterator __position)
+      { return _M_t.erase(__position); }
+# 649 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 670 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+# 705 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      void
+      swap(multimap& __x)
+
+      noexcept(_Alloc_traits::_S_nothrow_swap())
+
+      { _M_t.swap(__x._M_t); }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_t.clear(); }
+
+
+
+
+
+
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+
+
+
+
+
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+# 753 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+
+
+      template<typename _Kt>
+ auto
+ find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x))
+ { return _M_t._M_find_tr(__x); }
+# 777 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+
+
+      template<typename _Kt>
+ auto
+ find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x))
+ { return _M_t._M_find_tr(__x); }
+# 795 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.count(__x); }
+
+
+      template<typename _Kt>
+ auto
+ count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x))
+ { return _M_t._M_count_tr(__x); }
+# 819 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ lower_bound(const _Kt& __x)
+ -> decltype(_M_t._M_lower_bound_tr(__x))
+ { return _M_t._M_lower_bound_tr(__x); }
+# 844 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ lower_bound(const _Kt& __x) const
+ -> decltype(_M_t._M_lower_bound_tr(__x))
+ { return _M_t._M_lower_bound_tr(__x); }
+# 864 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ upper_bound(const _Kt& __x)
+ -> decltype(_M_t._M_upper_bound_tr(__x))
+ { return _M_t._M_upper_bound_tr(__x); }
+# 884 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+
+
+      template<typename _Kt>
+ auto
+ upper_bound(const _Kt& __x) const
+ -> decltype(_M_t._M_upper_bound_tr(__x))
+ { return _M_t._M_upper_bound_tr(__x); }
+# 911 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+
+
+      template<typename _Kt>
+ auto
+ equal_range(const _Kt& __x)
+ -> decltype(_M_t._M_equal_range_tr(__x))
+ { return _M_t._M_equal_range_tr(__x); }
+# 938 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+
+
+      template<typename _Kt>
+ auto
+ equal_range(const _Kt& __x) const
+ -> decltype(_M_t._M_equal_range_tr(__x))
+ { return _M_t._M_equal_range_tr(__x); }
+
+
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator==(const multimap<_K1, _T1, _C1, _A1>&,
+     const multimap<_K1, _T1, _C1, _A1>&);
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator<(const multimap<_K1, _T1, _C1, _A1>&,
+    const multimap<_K1, _T1, _C1, _A1>&);
+  };
+# 972 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+# 989 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/bits/stl_multimap.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+         multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+
+}
+# 63 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/aarch64-linux-gnu/include/c++/5.3.1/map" 2 3
+# 58 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h" 2
+
+
+
+
+
+
+
+
+# 65 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+template <typename T>
+struct QMetaTypeId2;
+
+template <typename T>
+inline constexpr int qMetaTypeId();
+# 217 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+class QDataStream;
+class QMetaTypeInterface;
+struct QMetaObject;
+
+namespace QtPrivate
+{
+
+
+
+
+template<typename From, typename To>
+To convertImplicit(const From& from)
+{
+    return from;
+}
+
+
+struct AbstractDebugStreamFunction
+{
+    typedef void (*Stream)(const AbstractDebugStreamFunction *, QDebug&, const void *);
+    typedef void (*Destroy)(AbstractDebugStreamFunction *);
+    explicit AbstractDebugStreamFunction(Stream s = nullptr, Destroy d = nullptr)
+        : stream(s), destroy(d) {}
+    AbstractDebugStreamFunction(const AbstractDebugStreamFunction &) = delete; AbstractDebugStreamFunction &operator=(const AbstractDebugStreamFunction &) = delete;
+    Stream stream;
+    Destroy destroy;
+};
+
+template<typename T>
+struct BuiltInDebugStreamFunction : public AbstractDebugStreamFunction
+{
+    BuiltInDebugStreamFunction()
+        : AbstractDebugStreamFunction(stream, destroy) {}
+    static void stream(const AbstractDebugStreamFunction *, QDebug& dbg, const void *r)
+    {
+        const T *rhs = static_cast<const T *>(r);
+        operator<<(dbg, *rhs);
+    }
+
+    static void destroy(AbstractDebugStreamFunction *_this)
+    {
+        delete static_cast<BuiltInDebugStreamFunction *>(_this);
+    }
+};
+
+
+struct AbstractComparatorFunction
+{
+    typedef bool (*LessThan)(const AbstractComparatorFunction *, const void *, const void *);
+    typedef bool (*Equals)(const AbstractComparatorFunction *, const void *, const void *);
+    typedef void (*Destroy)(AbstractComparatorFunction *);
+    explicit AbstractComparatorFunction(LessThan lt = nullptr, Equals e = nullptr, Destroy d = nullptr)
+        : lessThan(lt), equals(e), destroy(d) {}
+    AbstractComparatorFunction(const AbstractComparatorFunction &) = delete; AbstractComparatorFunction &operator=(const AbstractComparatorFunction &) = delete;
+    LessThan lessThan;
+    Equals equals;
+    Destroy destroy;
+};
+
+template<typename T>
+struct BuiltInComparatorFunction : public AbstractComparatorFunction
+{
+    BuiltInComparatorFunction()
+        : AbstractComparatorFunction(lessThan, equals, destroy) {}
+    static bool lessThan(const AbstractComparatorFunction *, const void *l, const void *r)
+    {
+        const T *lhs = static_cast<const T *>(l);
+        const T *rhs = static_cast<const T *>(r);
+        return *lhs < *rhs;
+    }
+
+    static bool equals(const AbstractComparatorFunction *, const void *l, const void *r)
+    {
+        const T *lhs = static_cast<const T *>(l);
+        const T *rhs = static_cast<const T *>(r);
+        return *lhs == *rhs;
+    }
+
+    static void destroy(AbstractComparatorFunction *_this)
+    {
+        delete static_cast<BuiltInComparatorFunction *>(_this);
+    }
+};
+
+template<typename T>
+struct BuiltInEqualsComparatorFunction : public AbstractComparatorFunction
+{
+    BuiltInEqualsComparatorFunction()
+        : AbstractComparatorFunction(nullptr, equals, destroy) {}
+    static bool equals(const AbstractComparatorFunction *, const void *l, const void *r)
+    {
+        const T *lhs = static_cast<const T *>(l);
+        const T *rhs = static_cast<const T *>(r);
+        return *lhs == *rhs;
+    }
+
+    static void destroy(AbstractComparatorFunction *_this)
+    {
+        delete static_cast<BuiltInEqualsComparatorFunction *>(_this);
+    }
+};
+
+struct AbstractConverterFunction
+{
+    typedef bool (*Converter)(const AbstractConverterFunction *, const void *, void*);
+    explicit AbstractConverterFunction(Converter c = nullptr)
+        : convert(c) {}
+    AbstractConverterFunction(const AbstractConverterFunction &) = delete; AbstractConverterFunction &operator=(const AbstractConverterFunction &) = delete;
+    Converter convert;
+};
+
+template<typename From, typename To>
+struct ConverterMemberFunction : public AbstractConverterFunction
+{
+    explicit ConverterMemberFunction(To(From::*function)() const)
+        : AbstractConverterFunction(convert),
+          m_function(function) {}
+    ~ConverterMemberFunction();
+    static bool convert(const AbstractConverterFunction *_this, const void *in, void *out)
+    {
+        const From *f = static_cast<const From *>(in);
+        To *t = static_cast<To *>(out);
+        const ConverterMemberFunction *_typedThis =
+            static_cast<const ConverterMemberFunction *>(_this);
+        *t = (f->*_typedThis->m_function)();
+        return true;
+    }
+
+    To(From::* const m_function)() const;
+};
+
+template<typename From, typename To>
+struct ConverterMemberFunctionOk : public AbstractConverterFunction
+{
+    explicit ConverterMemberFunctionOk(To(From::*function)(bool *) const)
+        : AbstractConverterFunction(convert),
+          m_function(function) {}
+    ~ConverterMemberFunctionOk();
+    static bool convert(const AbstractConverterFunction *_this, const void *in, void *out)
+    {
+        const From *f = static_cast<const From *>(in);
+        To *t = static_cast<To *>(out);
+        bool ok = false;
+        const ConverterMemberFunctionOk *_typedThis =
+            static_cast<const ConverterMemberFunctionOk *>(_this);
+        *t = (f->*_typedThis->m_function)(&ok);
+        if (!ok)
+            *t = To();
+        return ok;
+    }
+
+    To(From::* const m_function)(bool*) const;
+};
+
+template<typename From, typename To, typename UnaryFunction>
+struct ConverterFunctor : public AbstractConverterFunction
+{
+    explicit ConverterFunctor(UnaryFunction function)
+        : AbstractConverterFunction(convert),
+          m_function(function) {}
+    ~ConverterFunctor();
+    static bool convert(const AbstractConverterFunction *_this, const void *in, void *out)
+    {
+        const From *f = static_cast<const From *>(in);
+        To *t = static_cast<To *>(out);
+        const ConverterFunctor *_typedThis =
+            static_cast<const ConverterFunctor *>(_this);
+        *t = _typedThis->m_function(*f);
+        return true;
+    }
+
+    UnaryFunction m_function;
+};
+
+    template<typename T, bool>
+    struct ValueTypeIsMetaType;
+    template<typename T, bool>
+    struct AssociativeValueTypeIsMetaType;
+    template<typename T, bool>
+    struct IsMetaTypePair;
+    template<typename, typename>
+    struct MetaTypeSmartPointerHelper;
+}
+
+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, MetaObjectEx = 0x200
+                       };
+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 = 40, 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, QPersistentModelIndex = 50, QObjectStar = 39, QVariantMap = 8, QVariantList = 9, QVariantHash = 28, QByteArrayList = 49, 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 = QPersistentModelIndex,
+        FirstGuiType = QFont,
+        LastGuiType = QPolygonF,
+        FirstWidgetsType = QSizePolicy,
+        LastWidgetsType = QSizePolicy,
+        HighestInternalId = LastWidgetsType,
+
+        QReal = sizeof(qreal) == sizeof(double) ? Double : Float,
+
+        UnknownType = 0,
+        User = 1024
+    };
+# 456 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+    enum TypeFlag {
+        NeedsConstruction = 0x1,
+        NeedsDestruction = 0x2,
+        MovableType = 0x4,
+        PointerToQObject = 0x8,
+        IsEnumeration = 0x10,
+        SharedPointerToQObject = 0x20,
+        WeakPointerToQObject = 0x40,
+        TrackingPointerToQObject = 0x80,
+        WasDeclaredAsMetaType = 0x100,
+        IsGadget = 0x200
+    };
+    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 bool unregisterType(int type);
+    static int registerNormalizedType(const ::QByteArray &normalizedTypeName, Deleter deleter,
+                            Creator creator,
+                            Destructor destructor,
+                            Constructor constructor,
+                            int size,
+                            QMetaType::TypeFlags flags,
+                            const QMetaObject *metaObject);
+    static int registerNormalizedType(const ::QByteArray &normalizedTypeName, 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 int type(const ::QByteArray &typeName);
+
+
+
+    static const char *typeName(int type);
+    static int sizeOf(int type);
+    static TypeFlags typeFlags(int type);
+    static const QMetaObject *metaObjectForType(int type);
+    static bool isRegistered(int type);
+    static void *create(int type, const void *copy = nullptr);
+
+
+
+
+    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 const QMetaObject *metaObject() const;
+
+    inline void *create(const void *copy = nullptr) const;
+    inline void destroy(void *data) const;
+    inline void *construct(void *where, const void *copy = nullptr) const;
+    inline void destruct(void *data) const;
+
+public:
+    template<typename T>
+    static bool registerComparators()
+    {
+        static_assert(bool((!QMetaTypeId2<T>::IsBuiltIn)), "QMetaType::registerComparators: The type must be a custom type.")
+                                                                              ;
+
+        const int typeId = qMetaTypeId<T>();
+        static const QtPrivate::BuiltInComparatorFunction<T> f;
+        return registerComparatorFunction( &f, typeId);
+    }
+    template<typename T>
+    static bool registerEqualsComparator()
+    {
+        static_assert(bool((!QMetaTypeId2<T>::IsBuiltIn)), "QMetaType::registerEqualsComparator: The type must be a custom type.")
+                                                                                   ;
+        const int typeId = qMetaTypeId<T>();
+        static const QtPrivate::BuiltInEqualsComparatorFunction<T> f;
+        return registerComparatorFunction( &f, typeId);
+    }
+
+    template<typename T>
+    static bool hasRegisteredComparators()
+    {
+        return hasRegisteredComparators(qMetaTypeId<T>());
+    }
+    static bool hasRegisteredComparators(int typeId);
+
+
+
+    template<typename T>
+    static bool registerDebugStreamOperator()
+    {
+        static_assert(bool((!QMetaTypeId2<T>::IsBuiltIn)), "QMetaType::registerDebugStreamOperator: The type must be a custom type.")
+                                                                                      ;
+
+        const int typeId = qMetaTypeId<T>();
+        static const QtPrivate::BuiltInDebugStreamFunction<T> f;
+        return registerDebugStreamOperatorFunction(&f, typeId);
+    }
+    template<typename T>
+    static bool hasRegisteredDebugStreamOperator()
+    {
+        return hasRegisteredDebugStreamOperator(qMetaTypeId<T>());
+    }
+    static bool hasRegisteredDebugStreamOperator(int typeId);
+
+
+
+    template<typename From, typename To>
+    static bool registerConverter()
+    {
+        return registerConverter<From, To>(QtPrivate::convertImplicit<From, To>);
+    }
+
+
+
+
+
+
+
+    template<typename From, typename To>
+    static bool registerConverter(To(From::*function)() const)
+    {
+        static_assert(bool((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn)), "QMetaType::registerConverter: At least one of the types must be a custom type.")
+                                                                                             ;
+
+        const int fromTypeId = qMetaTypeId<From>();
+        const int toTypeId = qMetaTypeId<To>();
+        static const QtPrivate::ConverterMemberFunction<From, To> f(function);
+        return registerConverterFunction(&f, fromTypeId, toTypeId);
+    }
+
+
+    template<typename From, typename To>
+    static bool registerConverter(To(From::*function)(bool*) const)
+    {
+        static_assert(bool((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn)), "QMetaType::registerConverter: At least one of the types must be a custom type.")
+                                                                                             ;
+
+        const int fromTypeId = qMetaTypeId<From>();
+        const int toTypeId = qMetaTypeId<To>();
+        static const QtPrivate::ConverterMemberFunctionOk<From, To> f(function);
+        return registerConverterFunction(&f, fromTypeId, toTypeId);
+    }
+
+
+    template<typename From, typename To, typename UnaryFunction>
+    static bool registerConverter(UnaryFunction function)
+    {
+        static_assert(bool((!QMetaTypeId2<To>::IsBuiltIn || !QMetaTypeId2<From>::IsBuiltIn)), "QMetaType::registerConverter: At least one of the types must be a custom type.")
+                                                                                             ;
+
+        const int fromTypeId = qMetaTypeId<From>();
+        const int toTypeId = qMetaTypeId<To>();
+        static const QtPrivate::ConverterFunctor<From, To, UnaryFunction> f(function);
+        return registerConverterFunction(&f, fromTypeId, toTypeId);
+    }
+
+
+    static bool convert(const void *from, int fromTypeId, void *to, int toTypeId);
+    static bool compare(const void *lhs, const void *rhs, int typeId, int* result);
+    static bool equals(const void *lhs, const void *rhs, int typeId, int* result);
+    static bool debugStream(QDebug& dbg, const void *rhs, int typeId);
+
+    template<typename From, typename To>
+    static bool hasRegisteredConverterFunction()
+    {
+        return hasRegisteredConverterFunction(qMetaTypeId<From>(), qMetaTypeId<To>());
+    }
+
+    static bool hasRegisteredConverterFunction(int fromTypeId, int toTypeId);
+
+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;
+    const QMetaObject *metaObjectExtended() const;
+    void *createExtended(const void *copy = nullptr) const;
+    void destroyExtended(void *data) const;
+    void *constructExtended(void *where, const void *copy = nullptr) const;
+    void destructExtended(void *data) const;
+
+    static bool registerComparatorFunction(const QtPrivate::AbstractComparatorFunction *f, int type);
+
+    static bool registerDebugStreamOperatorFunction(const QtPrivate::AbstractDebugStreamFunction *f, int type);
+
+
+
+
+
+    template<typename, bool> friend struct QtPrivate::ValueTypeIsMetaType;
+    template<typename, typename> friend struct QtPrivate::ConverterMemberFunction;
+    template<typename, typename> friend struct QtPrivate::ConverterMemberFunctionOk;
+    template<typename, typename, typename> friend struct QtPrivate::ConverterFunctor;
+    template<typename, bool> friend struct QtPrivate::AssociativeValueTypeIsMetaType;
+    template<typename, bool> friend struct QtPrivate::IsMetaTypePair;
+    template<typename, typename> friend struct QtPrivate::MetaTypeSmartPointerHelper;
+
+
+
+
+    static bool registerConverterFunction(const QtPrivate::AbstractConverterFunction *f, int from, int to);
+    static void unregisterConverterFunction(int from, int to);
+private:
+
+    Creator m_creator_unused;
+    Deleter m_deleter_unused;
+    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) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QMetaType::TypeFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+
+namespace QtPrivate {
+
+template<typename From, typename To>
+ConverterMemberFunction<From, To>::~ConverterMemberFunction()
+{
+    QMetaType::unregisterConverterFunction(qMetaTypeId<From>(), qMetaTypeId<To>());
+}
+template<typename From, typename To>
+ConverterMemberFunctionOk<From, To>::~ConverterMemberFunctionOk()
+{
+    QMetaType::unregisterConverterFunction(qMetaTypeId<From>(), qMetaTypeId<To>());
+}
+template<typename From, typename To, typename UnaryFunction>
+ConverterFunctor<From, To, UnaryFunction>::~ConverterFunctor()
+{
+    QMetaType::unregisterConverterFunction(qMetaTypeId<From>(), qMetaTypeId<To>());
+}
+
+}
+
+
+
+
+
+
+namespace QtMetaTypePrivate {
+template <typename T, bool Accepted = true>
+struct QMetaTypeFunctionHelper {
+    static void Destruct(void *t)
+    {
+        (void)t;
+        static_cast<T*>(t)->~T();
+    }
+
+    static void *Construct(void *where, const void *t)
+    {
+        if (t)
+            return new (where) T(*static_cast<const T*>(t));
+        return new (where) T;
+    }
+
+    static void Save(QDataStream &stream, const void *t)
+    {
+        stream << *static_cast<const T*>(t);
+    }
+
+    static void Load(QDataStream &stream, void *t)
+    {
+        stream >> *static_cast<T*>(t);
+    }
+
+};
+
+template <typename T>
+struct QMetaTypeFunctionHelper<T, false> {
+    static void Destruct(void *) {}
+    static void *Construct(void *, const void *) { return nullptr; }
+
+    static void Save(QDataStream &, const void *) {}
+    static void Load(QDataStream &, void *) {}
+
+};
+template <>
+struct QMetaTypeFunctionHelper<void, true>
+        : public QMetaTypeFunctionHelper<void, false>
+{};
+
+struct VariantData
+{
+    VariantData(const int metaTypeId_,
+                const void *data_,
+                const uint flags_)
+      : metaTypeId(metaTypeId_)
+      , data(data_)
+      , flags(flags_)
+    {
+    }
+    VariantData(const VariantData &other)
+        : metaTypeId(other.metaTypeId), data(other.data), flags(other.flags){}
+    const int metaTypeId;
+    const void *data;
+    const uint flags;
+private:
+
+    VariantData &operator=(const VariantData &) = delete;
+};
+
+template<typename const_iterator>
+struct IteratorOwnerCommon
+{
+    static void assign(void **ptr, const_iterator iterator)
+    {
+        *ptr = new const_iterator(iterator);
+    }
+    static void assign(void **ptr, void * const * src)
+    {
+        *ptr = new const_iterator(*static_cast<const_iterator*>(*src));
+    }
+
+    static void advance(void **iterator, int step)
+    {
+        const_iterator &it = *static_cast<const_iterator*>(*iterator);
+        std::advance(it, step);
+    }
+
+    static void destroy(void **ptr)
+    {
+        delete static_cast<const_iterator*>(*ptr);
+    }
+
+    static bool equal(void * const *it, void * const *other)
+    {
+        return *static_cast<const_iterator*>(*it) == *static_cast<const_iterator*>(*other);
+    }
+};
+
+template<typename const_iterator>
+struct IteratorOwner : IteratorOwnerCommon<const_iterator>
+{
+    static const void *getData(void * const *iterator)
+    {
+        return &**static_cast<const_iterator*>(*iterator);
+    }
+
+    static const void *getData(const_iterator it)
+    {
+        return &*it;
+    }
+};
+
+struct __attribute__((visibility("default"))) VectorBoolElements
+{
+  static const bool true_element;
+  static const bool false_element;
+};
+
+template<>
+struct IteratorOwner<std::vector<bool>::const_iterator> : IteratorOwnerCommon<std::vector<bool>::const_iterator>
+{
+public:
+    static const void *getData(void * const *iterator)
+    {
+        return **static_cast<std::vector<bool>::const_iterator*>(*iterator) ?
+            &VectorBoolElements::true_element : &VectorBoolElements::false_element;
+    }
+
+    static const void *getData(const std::vector<bool>::const_iterator& it)
+    {
+        return *it ? &VectorBoolElements::true_element : &VectorBoolElements::false_element;
+    }
+};
+
+template<typename value_type>
+struct IteratorOwner<const value_type*>
+{
+private:
+
+
+
+    struct Dummy {};
+    typedef typename QtPrivate::if_<QtPrivate::is_same<value_type, void*>::value, Dummy, value_type>::type value_type_OR_Dummy;
+public:
+    static void assign(void **ptr, const value_type_OR_Dummy *iterator )
+    {
+        *ptr = const_cast<value_type*>(iterator);
+    }
+    static void assign(void **ptr, void * const * src)
+    {
+        *ptr = static_cast<value_type*>(*src);
+    }
+
+    static void advance(void **iterator, int step)
+    {
+        value_type *it = static_cast<value_type*>(*iterator);
+        std::advance(it, step);
+        *iterator = it;
+    }
+
+    static void destroy(void **)
+    {
+    }
+
+    static const void *getData(void * const *iterator)
+    {
+        return *iterator;
+    }
+
+    static const void *getData(const value_type_OR_Dummy *it)
+    {
+        return it;
+    }
+
+    static bool equal(void * const *it, void * const *other)
+    {
+        return static_cast<value_type*>(*it) == static_cast<value_type*>(*other);
+    }
+};
+
+enum IteratorCapability
+{
+    ForwardCapability = 1,
+    BiDirectionalCapability = 2,
+    RandomAccessCapability = 4
+};
+
+template<typename T, typename Category = typename std::iterator_traits<typename T::const_iterator>::iterator_category>
+struct CapabilitiesImpl;
+
+template<typename T>
+struct CapabilitiesImpl<T, std::forward_iterator_tag>
+{ enum { IteratorCapabilities = ForwardCapability }; };
+template<typename T>
+struct CapabilitiesImpl<T, std::bidirectional_iterator_tag>
+{ enum { IteratorCapabilities = BiDirectionalCapability | ForwardCapability }; };
+template<typename T>
+struct CapabilitiesImpl<T, std::random_access_iterator_tag>
+{ enum { IteratorCapabilities = RandomAccessCapability | BiDirectionalCapability | ForwardCapability }; };
+
+template<typename T>
+struct ContainerAPI : CapabilitiesImpl<T>
+{
+    static int size(const T *t) { return int(std::distance(t->begin(), t->end())); }
+};
+
+template<typename T>
+struct ContainerAPI<QList<T> > : CapabilitiesImpl<QList<T> >
+{ static int size(const QList<T> *t) { return t->size(); } };
+
+template<typename T>
+struct ContainerAPI<QVector<T> > : CapabilitiesImpl<QVector<T> >
+{ static int size(const QVector<T> *t) { return t->size(); } };
+
+template<typename T>
+struct ContainerAPI<std::vector<T> > : CapabilitiesImpl<std::vector<T> >
+{ static int size(const std::vector<T> *t) { return int(t->size()); } };
+
+template<typename T>
+struct ContainerAPI<std::list<T> > : CapabilitiesImpl<std::list<T> >
+{ static int size(const std::list<T> *t) { return int(t->size()); } };
+
+class QSequentialIterableImpl
+{
+public:
+    const void * _iterable;
+    void *_iterator;
+    int _metaType_id;
+    uint _metaType_flags;
+    uint _iteratorCapabilities;
+    typedef int(*sizeFunc)(const void *p);
+    typedef const void * (*atFunc)(const void *p, int);
+    typedef void (*moveIteratorFunc)(const void *p, void **);
+    typedef void (*advanceFunc)(void **p, int);
+    typedef VariantData (*getFunc)( void * const *p, int metaTypeId, uint flags);
+    typedef void (*destroyIterFunc)(void **p);
+    typedef bool (*equalIterFunc)(void * const *p, void * const *other);
+    typedef void (*copyIterFunc)(void **, void * const *);
+
+    sizeFunc _size;
+    atFunc _at;
+    moveIteratorFunc _moveToBegin;
+    moveIteratorFunc _moveToEnd;
+    advanceFunc _advance;
+    getFunc _get;
+    destroyIterFunc _destroyIter;
+    equalIterFunc _equalIter;
+    copyIterFunc _copyIter;
+
+    template<class T>
+    static int sizeImpl(const void *p)
+    { return ContainerAPI<T>::size(static_cast<const T*>(p)); }
+
+    template<class T>
+    static const void* atImpl(const void *p, int idx)
+    {
+        typename T::const_iterator i = static_cast<const T*>(p)->begin();
+        std::advance(i, idx);
+        return IteratorOwner<typename T::const_iterator>::getData(i);
+    }
+
+    template<class T>
+    static void moveToBeginImpl(const void *container, void **iterator)
+    { IteratorOwner<typename T::const_iterator>::assign(iterator, static_cast<const T*>(container)->begin()); }
+
+    template<class T>
+    static void moveToEndImpl(const void *container, void **iterator)
+    { IteratorOwner<typename T::const_iterator>::assign(iterator, static_cast<const T*>(container)->end()); }
+
+    template<class T>
+    static VariantData getImpl(void * const *iterator, int metaTypeId, uint flags)
+    { return VariantData(metaTypeId, IteratorOwner<typename T::const_iterator>::getData(iterator), flags); }
+
+public:
+    template<class T> QSequentialIterableImpl(const T*p)
+      : _iterable(p)
+      , _iterator(nullptr)
+      , _metaType_id(qMetaTypeId<typename T::value_type>())
+      , _metaType_flags(QTypeInfo<typename T::value_type>::isPointer)
+      , _iteratorCapabilities(ContainerAPI<T>::IteratorCapabilities)
+      , _size(sizeImpl<T>)
+      , _at(atImpl<T>)
+      , _moveToBegin(moveToBeginImpl<T>)
+      , _moveToEnd(moveToEndImpl<T>)
+      , _advance(IteratorOwner<typename T::const_iterator>::advance)
+      , _get(getImpl<T>)
+      , _destroyIter(IteratorOwner<typename T::const_iterator>::destroy)
+      , _equalIter(IteratorOwner<typename T::const_iterator>::equal)
+      , _copyIter(IteratorOwner<typename T::const_iterator>::assign)
+    {
+    }
+
+    QSequentialIterableImpl()
+      : _iterable(nullptr)
+      , _iterator(nullptr)
+      , _metaType_id(QMetaType::UnknownType)
+      , _metaType_flags(0)
+      , _iteratorCapabilities(0)
+      , _size(nullptr)
+      , _at(nullptr)
+      , _moveToBegin(nullptr)
+      , _moveToEnd(nullptr)
+      , _advance(nullptr)
+      , _get(nullptr)
+      , _destroyIter(nullptr)
+      , _equalIter(nullptr)
+      , _copyIter(nullptr)
+    {
+    }
+
+    inline void moveToBegin() { _moveToBegin(_iterable, &_iterator); }
+    inline void moveToEnd() { _moveToEnd(_iterable, &_iterator); }
+    inline bool equal(const QSequentialIterableImpl&other) const { return _equalIter(&_iterator, &other._iterator); }
+    inline QSequentialIterableImpl &advance(int i) {
+      do { } while ((false) && (i > 0 || _iteratorCapabilities & BiDirectionalCapability));
+      _advance(&_iterator, i);
+      return *this;
+    }
+
+    inline VariantData getCurrent() const { return _get(&_iterator, _metaType_id, _metaType_flags); }
+
+    VariantData at(int idx) const
+    { return VariantData(_metaType_id, _at(_iterable, idx), _metaType_flags); }
+
+    int size() const { do { } while ((false) && (_iterable)); return _size(_iterable); }
+
+    inline void destroyIter() { _destroyIter(&_iterator); }
+
+    void copy(const QSequentialIterableImpl &other)
+    {
+      *this = other;
+      _copyIter(&_iterator, &other._iterator);
+    }
+};
+} template<> class QTypeInfo<QtMetaTypePrivate:: QSequentialIterableImpl > { public: enum { isComplex = ((((Q_MOVABLE_TYPE)) & Q_PRIMITIVE_TYPE) == 0), isStatic = ((((Q_MOVABLE_TYPE)) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || (((Q_MOVABLE_TYPE)) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QtMetaTypePrivate:: QSequentialIterableImpl)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QtMetaTypePrivate:: QSequentialIterableImpl >::value, isDummy = ((((Q_MOVABLE_TYPE)) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QtMetaTypePrivate:: QSequentialIterableImpl) }; static inline const char *name() { return "QtMetaTypePrivate:: QSequentialIterableImpl"; } }; namespace QtMetaTypePrivate {
+
+template<typename From>
+struct QSequentialIterableConvertFunctor
+{
+    QSequentialIterableImpl operator()(const From &f) const
+    {
+        return QSequentialIterableImpl(&f);
+    }
+};
+}
+
+namespace QtMetaTypePrivate {
+template<typename T, bool = QtPrivate::is_same<typename T::const_iterator::value_type, typename T::mapped_type>::value>
+struct AssociativeContainerAccessor
+{
+    static const typename T::key_type& getKey(const typename T::const_iterator &it)
+    {
+        return it.key();
+    }
+
+    static const typename T::mapped_type& getValue(const typename T::const_iterator &it)
+    {
+        return it.value();
+    }
+};
+
+template<typename T, bool = QtPrivate::is_same<typename T::const_iterator::value_type, std::pair<const typename T::key_type, typename T::mapped_type> >::value>
+struct StlStyleAssociativeContainerAccessor;
+
+template<typename T>
+struct StlStyleAssociativeContainerAccessor<T, true>
+{
+    static const typename T::key_type& getKey(const typename T::const_iterator &it)
+    {
+        return it->first;
+    }
+
+    static const typename T::mapped_type& getValue(const typename T::const_iterator &it)
+    {
+        return it->second;
+    }
+};
+
+template<typename T>
+struct AssociativeContainerAccessor<T, false> : public StlStyleAssociativeContainerAccessor<T>
+{
+};
+
+class QAssociativeIterableImpl
+{
+public:
+    const void *_iterable;
+    void *_iterator;
+    int _metaType_id_key;
+    uint _metaType_flags_key;
+    int _metaType_id_value;
+    uint _metaType_flags_value;
+    typedef int(*sizeFunc)(const void *p);
+    typedef void (*findFunc)(const void *container, const void *p, void **iterator);
+    typedef void (*beginFunc)(const void *p, void **);
+    typedef void (*advanceFunc)(void **p, int);
+    typedef VariantData (*getFunc)(void * const *p, int metaTypeId, uint flags);
+    typedef void (*destroyIterFunc)(void **p);
+    typedef bool (*equalIterFunc)(void * const *p, void * const *other);
+    typedef void (*copyIterFunc)(void **, void * const *);
+
+    sizeFunc _size;
+    findFunc _find;
+    beginFunc _begin;
+    beginFunc _end;
+    advanceFunc _advance;
+    getFunc _getKey;
+    getFunc _getValue;
+    destroyIterFunc _destroyIter;
+    equalIterFunc _equalIter;
+    copyIterFunc _copyIter;
+
+    template<class T>
+    static int sizeImpl(const void *p)
+    { return int(std::distance(static_cast<const T*>(p)->begin(),
+                               static_cast<const T*>(p)->end())); }
+
+    template<class T>
+    static void findImpl(const void *container, const void *p, void **iterator)
+    { IteratorOwner<typename T::const_iterator>::assign(iterator,
+                                                        static_cast<const T*>(container)->find(*static_cast<const typename T::key_type*>(p))); }
+
+    template<class T>
+    static void advanceImpl(void **p, int step)
+    { std::advance(*static_cast<typename T::const_iterator*>(*p), step); }
+
+    template<class T>
+    static void beginImpl(const void *container, void **iterator)
+    { IteratorOwner<typename T::const_iterator>::assign(iterator, static_cast<const T*>(container)->begin()); }
+
+    template<class T>
+    static void endImpl(const void *container, void **iterator)
+    { IteratorOwner<typename T::const_iterator>::assign(iterator, static_cast<const T*>(container)->end()); }
+
+    template<class T>
+    static VariantData getKeyImpl(void * const *iterator, int metaTypeId, uint flags)
+    { return VariantData(metaTypeId, &AssociativeContainerAccessor<T>::getKey(*static_cast<typename T::const_iterator*>(*iterator)), flags); }
+
+    template<class T>
+    static VariantData getValueImpl(void * const *iterator, int metaTypeId, uint flags)
+    { return VariantData(metaTypeId, &AssociativeContainerAccessor<T>::getValue(*static_cast<typename T::const_iterator*>(*iterator)), flags); }
+
+public:
+    template<class T> QAssociativeIterableImpl(const T*p)
+      : _iterable(p)
+      , _metaType_id_key(qMetaTypeId<typename T::key_type>())
+      , _metaType_flags_key(QTypeInfo<typename T::key_type>::isPointer)
+      , _metaType_id_value(qMetaTypeId<typename T::mapped_type>())
+      , _metaType_flags_value(QTypeInfo<typename T::mapped_type>::isPointer)
+      , _size(sizeImpl<T>)
+      , _find(findImpl<T>)
+      , _begin(beginImpl<T>)
+      , _end(endImpl<T>)
+      , _advance(advanceImpl<T>)
+      , _getKey(getKeyImpl<T>)
+      , _getValue(getValueImpl<T>)
+      , _destroyIter(IteratorOwner<typename T::const_iterator>::destroy)
+      , _equalIter(IteratorOwner<typename T::const_iterator>::equal)
+      , _copyIter(IteratorOwner<typename T::const_iterator>::assign)
+    {
+    }
+
+    QAssociativeIterableImpl()
+      : _iterable(nullptr)
+      , _metaType_id_key(QMetaType::UnknownType)
+      , _metaType_flags_key(0)
+      , _metaType_id_value(QMetaType::UnknownType)
+      , _metaType_flags_value(0)
+      , _size(nullptr)
+      , _find(nullptr)
+      , _begin(nullptr)
+      , _end(nullptr)
+      , _advance(nullptr)
+      , _getKey(nullptr)
+      , _getValue(nullptr)
+      , _destroyIter(nullptr)
+      , _equalIter(nullptr)
+      , _copyIter(nullptr)
+    {
+    }
+
+    inline void begin() { _begin(_iterable, &_iterator); }
+    inline void end() { _end(_iterable, &_iterator); }
+    inline bool equal(const QAssociativeIterableImpl&other) const { return _equalIter(&_iterator, &other._iterator); }
+    inline QAssociativeIterableImpl &advance(int i) { _advance(&_iterator, i); return *this; }
+
+    inline void destroyIter() { _destroyIter(&_iterator); }
+
+    inline VariantData getCurrentKey() const { return _getKey(&_iterator, _metaType_id_key, _metaType_flags_key); }
+    inline VariantData getCurrentValue() const { return _getValue(&_iterator, _metaType_id_value, _metaType_flags_value); }
+
+    inline void find(const VariantData &key)
+    { _find(_iterable, key.data, &_iterator); }
+
+    int size() const { do { } while ((false) && (_iterable)); return _size(_iterable); }
+
+    void copy(const QAssociativeIterableImpl &other)
+    {
+      *this = other;
+      _copyIter(&_iterator, &other._iterator);
+    }
+};
+} template<> class QTypeInfo<QtMetaTypePrivate:: QAssociativeIterableImpl > { public: enum { isComplex = ((((Q_MOVABLE_TYPE)) & Q_PRIMITIVE_TYPE) == 0), isStatic = ((((Q_MOVABLE_TYPE)) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || (((Q_MOVABLE_TYPE)) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QtMetaTypePrivate:: QAssociativeIterableImpl)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QtMetaTypePrivate:: QAssociativeIterableImpl >::value, isDummy = ((((Q_MOVABLE_TYPE)) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QtMetaTypePrivate:: QAssociativeIterableImpl) }; static inline const char *name() { return "QtMetaTypePrivate:: QAssociativeIterableImpl"; } }; namespace QtMetaTypePrivate {
+
+template<typename From>
+struct QAssociativeIterableConvertFunctor
+{
+    QAssociativeIterableImpl operator()(const From& f) const
+    {
+        return QAssociativeIterableImpl(&f);
+    }
+};
+
+class QPairVariantInterfaceImpl
+{
+    const void *_pair;
+    int _metaType_id_first;
+    uint _metaType_flags_first;
+    int _metaType_id_second;
+    uint _metaType_flags_second;
+
+    typedef VariantData (*getFunc)(const void * const *p, int metaTypeId, uint flags);
+
+    getFunc _getFirst;
+    getFunc _getSecond;
+
+    template<class T>
+    static VariantData getFirstImpl(const void * const *pair, int metaTypeId, uint flags)
+    { return VariantData(metaTypeId, &static_cast<const T*>(*pair)->first, flags); }
+    template<class T>
+    static VariantData getSecondImpl(const void * const *pair, int metaTypeId, uint flags)
+    { return VariantData(metaTypeId, &static_cast<const T*>(*pair)->second, flags); }
+
+public:
+    template<class T> QPairVariantInterfaceImpl(const T*p)
+      : _pair(p)
+      , _metaType_id_first(qMetaTypeId<typename T::first_type>())
+      , _metaType_flags_first(QTypeInfo<typename T::first_type>::isPointer)
+      , _metaType_id_second(qMetaTypeId<typename T::second_type>())
+      , _metaType_flags_second(QTypeInfo<typename T::second_type>::isPointer)
+      , _getFirst(getFirstImpl<T>)
+      , _getSecond(getSecondImpl<T>)
+    {
+    }
+
+    QPairVariantInterfaceImpl()
+      : _pair(nullptr)
+      , _metaType_id_first(QMetaType::UnknownType)
+      , _metaType_flags_first(0)
+      , _metaType_id_second(QMetaType::UnknownType)
+      , _metaType_flags_second(0)
+      , _getFirst(nullptr)
+      , _getSecond(nullptr)
+    {
+    }
+
+    inline VariantData first() const { return _getFirst(&_pair, _metaType_id_first, _metaType_flags_first); }
+    inline VariantData second() const { return _getSecond(&_pair, _metaType_id_second, _metaType_flags_second); }
+};
+} template<> class QTypeInfo<QtMetaTypePrivate:: QPairVariantInterfaceImpl > { public: enum { isComplex = ((((Q_MOVABLE_TYPE)) & Q_PRIMITIVE_TYPE) == 0), isStatic = ((((Q_MOVABLE_TYPE)) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || (((Q_MOVABLE_TYPE)) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QtMetaTypePrivate:: QPairVariantInterfaceImpl)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QtMetaTypePrivate:: QPairVariantInterfaceImpl >::value, isDummy = ((((Q_MOVABLE_TYPE)) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QtMetaTypePrivate:: QPairVariantInterfaceImpl) }; static inline const char *name() { return "QtMetaTypePrivate:: QPairVariantInterfaceImpl"; } }; namespace QtMetaTypePrivate {
+
+template<typename From>
+struct QPairVariantInterfaceConvertFunctor;
+
+template<typename T, typename U>
+struct QPairVariantInterfaceConvertFunctor<QPair<T, U> >
+{
+    QPairVariantInterfaceImpl operator()(const QPair<T, U>& f) const
+    {
+        return QPairVariantInterfaceImpl(&f);
+    }
+};
+
+template<typename T, typename U>
+struct QPairVariantInterfaceConvertFunctor<std::pair<T, U> >
+{
+    QPairVariantInterfaceImpl operator()(const std::pair<T, U>& f) const
+    {
+        return QPairVariantInterfaceImpl(&f);
+    }
+};
+
+}
+
+class QObject;
+class QWidget;
+
+
+
+
+template <class T> class QSharedPointer; template <class T> class QWeakPointer; template <class T> class QPointer;
+
+namespace QtPrivate
+{
+    template<typename T>
+    struct IsPointerToTypeDerivedFromQObject
+    {
+        enum { Value = false };
+    };
+
+
+    template<>
+    struct IsPointerToTypeDerivedFromQObject<void*>
+    {
+        enum { Value = false };
+    };
+    template<>
+    struct IsPointerToTypeDerivedFromQObject<const void*>
+    {
+        enum { Value = false };
+    };
+    template<>
+    struct IsPointerToTypeDerivedFromQObject<QObject*>
+    {
+        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*>(nullptr))) == sizeof(yes_type) };
+    };
+
+    template<typename T, typename Enable = void>
+    struct IsGadgetHelper { enum { Value = false }; };
+
+    template<typename T>
+    struct IsGadgetHelper<T, typename T::QtGadgetHelper>
+    {
+        template <typename X>
+        static char checkType(void (X::*)());
+        static void *checkType(void (T::*)());
+        enum { Value = sizeof(checkType(&T::qt_check_for_QGADGET_macro)) == sizeof(void *) };
+    };
+
+
+
+# 1391 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+#pragma GCC diagnostic push
+# 1391 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+
+
+
+
+    template<typename T> char qt_getEnumMetaObject(const T&);
+
+    template<typename T>
+    struct IsQEnumHelper {
+        static const T &declval();
+
+
+
+
+        enum { Value = sizeof(qt_getEnumMetaObject(declval())) == sizeof(QMetaObject*) };
+    };
+    template<> struct IsQEnumHelper<void> { enum { Value = false }; };
+
+# 1407 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+#pragma GCC diagnostic pop
+# 1407 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+
+
+    template<typename T, typename Enable = void>
+    struct MetaObjectForType
+    {
+        static inline const QMetaObject *value() { return nullptr; }
+    };
+    template<>
+    struct MetaObjectForType<void>
+    {
+        static inline const QMetaObject *value() { return nullptr; }
+    };
+    template<typename T>
+    struct MetaObjectForType<T*, typename QEnableIf<IsPointerToTypeDerivedFromQObject<T*>::Value>::Type>
+    {
+        static inline const QMetaObject *value() { return &T::staticMetaObject; }
+    };
+    template<typename T>
+    struct MetaObjectForType<T, typename QEnableIf<IsGadgetHelper<T>::Value>::Type>
+    {
+        static inline const QMetaObject *value() { return &T::staticMetaObject; }
+    };
+    template<typename T>
+    struct MetaObjectForType<T, typename QEnableIf<IsQEnumHelper<T>::Value>::Type >
+    {
+        static inline const QMetaObject *value() { return qt_getEnumMetaObject(T()); }
+    };
+
+    template<typename T>
+    struct IsSharedPointerToTypeDerivedFromQObject
+    {
+        enum { Value = false };
+    };
+
+    template<typename T>
+    struct IsSharedPointerToTypeDerivedFromQObject<QSharedPointer<T> > : IsPointerToTypeDerivedFromQObject<T*>
+    {
+    };
+
+    template<typename T>
+    struct IsWeakPointerToTypeDerivedFromQObject
+    {
+        enum { Value = false };
+    };
+
+    template<typename T>
+    struct IsWeakPointerToTypeDerivedFromQObject<QWeakPointer<T> > : IsPointerToTypeDerivedFromQObject<T*>
+    {
+    };
+
+    template<typename T>
+    struct IsTrackingPointerToTypeDerivedFromQObject
+    {
+        enum { Value = false };
+    };
+
+    template<typename T>
+    struct IsTrackingPointerToTypeDerivedFromQObject<QPointer<T> >
+    {
+        enum { Value = true };
+    };
+
+    template<typename T>
+    struct IsSequentialContainer
+    {
+        enum { Value = false };
+    };
+
+    template<typename T>
+    struct IsAssociativeContainer
+    {
+        enum { Value = false };
+    };
+
+    template<typename T, bool = QtPrivate::IsSequentialContainer<T>::Value>
+    struct SequentialContainerConverterHelper
+    {
+        static bool registerConverter(int)
+        {
+            return false;
+        }
+    };
+
+    template<typename T, bool = QMetaTypeId2<typename T::value_type>::Defined>
+    struct ValueTypeIsMetaType
+    {
+        static bool registerConverter(int)
+        {
+            return false;
+        }
+    };
+
+    template<typename T>
+    struct SequentialContainerConverterHelper<T, true> : ValueTypeIsMetaType<T>
+    {
+    };
+
+    template<typename T, bool = QtPrivate::IsAssociativeContainer<T>::Value>
+    struct AssociativeContainerConverterHelper
+    {
+        static bool registerConverter(int)
+        {
+            return false;
+        }
+    };
+
+    template<typename T, bool = QMetaTypeId2<typename T::mapped_type>::Defined>
+    struct AssociativeValueTypeIsMetaType
+    {
+        static bool registerConverter(int)
+        {
+            return false;
+        }
+    };
+
+    template<typename T, bool = QMetaTypeId2<typename T::key_type>::Defined>
+    struct KeyAndValueTypeIsMetaType
+    {
+        static bool registerConverter(int)
+        {
+            return false;
+        }
+    };
+
+    template<typename T>
+    struct KeyAndValueTypeIsMetaType<T, true> : AssociativeValueTypeIsMetaType<T>
+    {
+    };
+
+    template<typename T>
+    struct AssociativeContainerConverterHelper<T, true> : KeyAndValueTypeIsMetaType<T>
+    {
+    };
+
+    template<typename T, bool = QMetaTypeId2<typename T::first_type>::Defined
+                                && QMetaTypeId2<typename T::second_type>::Defined>
+    struct IsMetaTypePair
+    {
+        static bool registerConverter(int)
+        {
+            return false;
+        }
+    };
+
+    template<typename T>
+    struct IsMetaTypePair<T, true>
+    {
+        inline static bool registerConverter(int id);
+    };
+
+    template<typename T>
+    struct IsPair
+    {
+        static bool registerConverter(int)
+        {
+            return false;
+        }
+    };
+    template<typename T, typename U>
+    struct IsPair<QPair<T, U> > : IsMetaTypePair<QPair<T, U> > {};
+    template<typename T, typename U>
+    struct IsPair<std::pair<T, U> > : IsMetaTypePair<std::pair<T, U> > {};
+
+    template<typename T>
+    struct MetaTypePairHelper : IsPair<T> {};
+
+    template<typename T, typename = void>
+    struct MetaTypeSmartPointerHelper
+    {
+        static bool registerConverter(int) { return false; }
+    };
+
+    __attribute__((visibility("default"))) bool isBuiltinType(const QByteArray &type);
+}
+
+template <typename T, int =
+    QtPrivate::IsPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::PointerToQObject :
+    QtPrivate::IsGadgetHelper<T>::Value ? QMetaType::IsGadget :
+    QtPrivate::IsQEnumHelper<T>::Value ? QMetaType::IsEnumeration : 0>
+struct QMetaTypeIdQObject
+{
+    enum {
+        Defined = 0
+    };
+};
+
+template <typename T>
+struct QMetaTypeId : public QMetaTypeIdQObject<T>
+{
+};
+
+template <typename T>
+struct QMetaTypeId2
+{
+    enum { Defined = QMetaTypeId<T>::Defined, IsBuiltIn=false };
+    static inline constexpr int qt_metatype_id() { return QMetaTypeId<T>::qt_metatype_id(); }
+};
+
+template <typename T>
+struct QMetaTypeId2<const T&> : QMetaTypeId2<T> {};
+
+template <typename T>
+struct QMetaTypeId2<T&> { enum {Defined = false }; };
+
+namespace QtPrivate {
+    template <typename T, bool Defined = QMetaTypeId2<T>::Defined>
+    struct QMetaTypeIdHelper {
+        static inline constexpr int qt_metatype_id()
+        { return QMetaTypeId2<T>::qt_metatype_id(); }
+    };
+    template <typename T> struct QMetaTypeIdHelper<T, false> {
+        static inline constexpr int qt_metatype_id()
+        { return -1; }
+    };
+# 1629 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+    template <typename Result, typename... Args>
+    struct IsPointerToTypeDerivedFromQObject<Result(*)(Args...)> { enum { Value = false }; };
+
+
+    template<typename T>
+    struct QMetaTypeTypeFlags
+    {
+        enum { Flags = (QTypeInfoQuery<T>::isRelocatable ? QMetaType::MovableType : 0)
+                     | (QTypeInfo<T>::isComplex ? QMetaType::NeedsConstruction : 0)
+                     | (QTypeInfo<T>::isComplex ? QMetaType::NeedsDestruction : 0)
+                     | (IsPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::PointerToQObject : 0)
+                     | (IsSharedPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::SharedPointerToQObject : 0)
+                     | (IsWeakPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::WeakPointerToQObject : 0)
+                     | (IsTrackingPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::TrackingPointerToQObject : 0)
+                     | (__is_enum(T) ? QMetaType::IsEnumeration : 0)
+                     | (IsGadgetHelper<T>::Value ? QMetaType::IsGadget : 0)
+             };
+    };
+
+    template<typename T, bool defined>
+    struct MetaTypeDefinedHelper
+    {
+        enum DefinedType { Defined = defined };
+    };
+
+    template<typename SmartPointer>
+    struct QSmartPointerConvertFunctor
+    {
+        QObject* operator()(const SmartPointer &p) const
+        {
+            return p.operator->();
+        }
+    };
+
+    template<typename T>
+    struct QSmartPointerConvertFunctor<QWeakPointer<T> >
+    {
+        QObject* operator()(const QWeakPointer<T> &p) const
+        {
+            return p.data();
+        }
+    };
+}
+
+template <typename T>
+int qRegisterNormalizedMetaType(const ::QByteArray &normalizedTypeName
+
+    , T * dummy = 0
+    , typename QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::DefinedType defined = QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::Defined
+
+)
+{
+
+    do { } while ((false) && (normalizedTypeName == QMetaObject::normalizedType(normalizedTypeName.constData())));
+
+    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);
+
+    if (defined)
+        flags |= QMetaType::WasDeclaredAsMetaType;
+
+    const int id = QMetaType::registerNormalizedType(normalizedTypeName,
+                                   QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Destruct,
+                                   QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Construct,
+                                   int(sizeof(T)),
+                                   flags,
+                                   QtPrivate::MetaObjectForType<T>::value());
+
+    if (id > 0) {
+        QtPrivate::SequentialContainerConverterHelper<T>::registerConverter(id);
+        QtPrivate::AssociativeContainerConverterHelper<T>::registerConverter(id);
+        QtPrivate::MetaTypePairHelper<T>::registerConverter(id);
+        QtPrivate::MetaTypeSmartPointerHelper<T>::registerConverter(id);
+    }
+
+    return id;
+}
+
+template <typename T>
+int qRegisterMetaType(const char *typeName
+
+    , T * dummy = nullptr
+    , typename QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::DefinedType defined = QtPrivate::MetaTypeDefinedHelper<T, QMetaTypeId2<T>::Defined && !QMetaTypeId2<T>::IsBuiltIn>::Defined
+
+)
+{
+
+
+
+    ::QByteArray normalizedTypeName = QMetaObject::normalizedType(typeName);
+
+    return qRegisterNormalizedMetaType<T>(normalizedTypeName, dummy, defined);
+}
+
+
+template <typename T>
+void qRegisterMetaTypeStreamOperators(const char *typeName
+
+    , T * = nullptr
+
+)
+{
+    qRegisterMetaType<T>(typeName);
+    QMetaType::registerStreamOperators(typeName, QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Save,
+                                                 QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Load);
+}
+
+
+template <typename T>
+inline constexpr int qMetaTypeId()
+{
+    static_assert(bool(QMetaTypeId2<T>::Defined), "Type is not registered, please use the Q_DECLARE_METATYPE macro to make it known to Qt's meta-object system");
+    return QMetaTypeId2<T>::qt_metatype_id();
+}
+
+template <typename T>
+inline constexpr int qRegisterMetaType()
+{
+    return qMetaTypeId<T>();
+}
+
+
+
+template <typename T>
+__attribute__ ((__deprecated__)) inline constexpr int qMetaTypeId(T *)
+{ return qMetaTypeId<T>(); }
+
+template <typename T>
+__attribute__ ((__deprecated__)) inline constexpr int qRegisterMetaType(T *)
+{ return qRegisterMetaType<T>(); }
+
+
+
+
+template <typename T>
+struct QMetaTypeIdQObject<T*, QMetaType::PointerToQObject>
+{
+    enum {
+        Defined = 1
+    };
+
+    static int qt_metatype_id()
+    {
+        static QBasicAtomicInt metatype_id = { 0 };
+        if (const int id = metatype_id.loadAcquire())
+            return id;
+        const char * const cName = T::staticMetaObject.className();
+        QByteArray typeName;
+        typeName.reserve(int(strlen(cName)) + 1);
+        typeName.append(cName).append('*');
+        const int newId = qRegisterNormalizedMetaType<T*>(
+                        typeName,
+                        reinterpret_cast<T**>(quintptr(-1)));
+        metatype_id.storeRelease(newId);
+        return newId;
+    }
+};
+
+template <typename T>
+struct QMetaTypeIdQObject<T, QMetaType::IsGadget>
+{
+    enum {
+        Defined = QtPrivate::is_default_constructible<T>::value
+    };
+
+    static int qt_metatype_id()
+    {
+        static QBasicAtomicInt metatype_id = { 0 };
+        if (const int id = metatype_id.loadAcquire())
+            return id;
+        const char * const cName = T::staticMetaObject.className();
+        const int newId = qRegisterNormalizedMetaType<T>(
+            cName,
+            reinterpret_cast<T*>(quintptr(-1)));
+        metatype_id.storeRelease(newId);
+        return newId;
+    }
+};
+
+template <typename T>
+struct QMetaTypeIdQObject<T, QMetaType::IsEnumeration>
+{
+    enum {
+        Defined = 1
+    };
+
+    static int qt_metatype_id()
+    {
+        static QBasicAtomicInt metatype_id = { 0 };
+        if (const int id = metatype_id.loadAcquire())
+            return id;
+        const char *eName = qt_getEnumName(T());
+        const char *cName = qt_getEnumMetaObject(T())->className();
+        QByteArray typeName;
+        typeName.reserve(int(strlen(cName) + 2 + strlen(eName)));
+        typeName.append(cName).append("::").append(eName);
+        const int newId = qRegisterNormalizedMetaType<T>(
+            typeName,
+            reinterpret_cast<T*>(quintptr(-1)));
+        metatype_id.storeRelease(newId);
+        return newId;
+    }
+};
+
+
+
+template <typename T>
+inline int qRegisterMetaTypeStreamOperators()
+{
+    int id = qMetaTypeId<T>();
+    QMetaType::registerStreamOperators(id, QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Save,
+                                           QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Load);
+    return id;
+}
+# 1891 "../../include/QtCore/../../../../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 QPersistentModelIndex;
+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;
+
+
+
+typedef QList<QVariant> QVariantList;
+typedef QMap<QString, QVariant> QVariantMap;
+typedef QHash<QString, QVariant> QVariantHash;
+typedef QList<QByteArray> QByteArrayList;
+# 1976 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+namespace QtPrivate {
+
+template<typename T, bool = false>
+struct SharedPointerMetaTypeIdHelper
+{
+    enum {
+        Defined = 0
+    };
+    static int qt_metatype_id()
+    {
+        return -1;
+    }
+};
+
+}
+# 2050 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+
+
+ template <class T> class QList; template <typename T> struct QMetaTypeId< QList<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.load()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); do { } while ((false) && (tName)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QList")) + 1 + tNameLen + 1 + 1); typeName.append("QList", int(sizeof("QList")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QList<T> >( typeName, reinterpret_cast< QList<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QList<T> > { enum { Value = true }; }; } template <class T> class QVector; template <typename T> struct QMetaTypeId< QVector<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.load()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); do { } while ((false) && (tName)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QVector")) + 1 + tNameLen + 1 + 1); typeName.append("QVector", int(sizeof("QVector")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QVector<T> >( typeName, reinterpret_cast< QVector<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QVector<T> > { enum { Value = true }; }; } template <class T> class QQueue; template <typename T> struct QMetaTypeId< QQueue<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.load()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); do { } while ((false) && (tName)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QQueue")) + 1 + tNameLen + 1 + 1); typeName.append("QQueue", int(sizeof("QQueue")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QQueue<T> >( typeName, reinterpret_cast< QQueue<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QQueue<T> > { enum { Value = true }; }; } template <class T> class QStack; template <typename T> struct QMetaTypeId< QStack<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.load()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); do { } while ((false) && (tName)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QStack")) + 1 + tNameLen + 1 + 1); typeName.append("QStack", int(sizeof("QStack")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QStack<T> >( typeName, reinterpret_cast< QStack<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QStack<T> > { enum { Value = true }; }; } template <class T> class QSet; template <typename T> struct QMetaTypeId< QSet<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.load()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); do { } while ((false) && (tName)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QSet")) + 1 + tNameLen + 1 + 1); typeName.append("QSet", int(sizeof("QSet")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QSet<T> >( typeName, reinterpret_cast< QSet<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QSet<T> > { enum { Value = true }; }; } template <class T> class QLinkedList; template <typename T> struct QMetaTypeId< QLinkedList<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.load()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); do { } while ((false) && (tName)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("QLinkedList")) + 1 + tNameLen + 1 + 1); typeName.append("QLinkedList", int(sizeof("QLinkedList")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QLinkedList<T> >( typeName, reinterpret_cast< QLinkedList<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<QLinkedList<T> > { enum { Value = true }; }; }
+
+
+
+
+
+ template <typename T> struct QMetaTypeId< std::vector<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.load()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); do { } while ((false) && (tName)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("std::vector")) + 1 + tNameLen + 1 + 1); typeName.append("std::vector", int(sizeof("std::vector")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< std::vector<T> >( typeName, reinterpret_cast< std::vector<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<std::vector<T> > { enum { Value = true }; }; }
+ template <typename T> struct QMetaTypeId< std::list<T> > { enum { Defined = QMetaTypeId2<T>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.load()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); do { } while ((false) && (tName)); const int tNameLen = int(qstrlen(tName)); QByteArray typeName; typeName.reserve(int(sizeof("std::list")) + 1 + tNameLen + 1 + 1); typeName.append("std::list", int(sizeof("std::list")) - 1) .append('<').append(tName, tNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< std::list<T> >( typeName, reinterpret_cast< std::list<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; namespace QtPrivate { template<typename T> struct IsSequentialContainer<std::list<T> > { enum { Value = true }; }; }
+
+
+
+
+
+
+ template <class T1, class T2> class QHash; template <class T1, class T2> class QMap; template <class T1, class T2> struct QPair;
+# 2082 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qmetatype.h"
+ namespace QtPrivate { template<typename T, typename U> struct IsAssociativeContainer<QHash<T, U> > { enum { Value = true }; }; } template<typename T, typename U> struct QMetaTypeId< QHash<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); do { } while ((false) && (tName)); do { } while ((false) && (uName)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("QHash")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("QHash", int(sizeof("QHash")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QHash<T, U> >( typeName, reinterpret_cast< QHash<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };
+ namespace QtPrivate { template<typename T, typename U> struct IsAssociativeContainer<QMap<T, U> > { enum { Value = true }; }; } template<typename T, typename U> struct QMetaTypeId< QMap<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); do { } while ((false) && (tName)); do { } while ((false) && (uName)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("QMap")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("QMap", int(sizeof("QMap")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QMap<T, U> >( typeName, reinterpret_cast< QMap<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };
+ namespace QtPrivate { template<typename T, typename U> struct IsAssociativeContainer<std::map<T, U> > { enum { Value = true }; }; } template<typename T, typename U> struct QMetaTypeId< std::map<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); do { } while ((false) && (tName)); do { } while ((false) && (uName)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("std::map")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("std::map", int(sizeof("std::map")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< std::map<T, U> >( typeName, reinterpret_cast< std::map<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };
+
+ template<typename T, typename U> struct QMetaTypeId< QPair<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); do { } while ((false) && (tName)); do { } while ((false) && (uName)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("QPair")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("QPair", int(sizeof("QPair")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< QPair<T, U> >( typeName, reinterpret_cast< QPair<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };
+ template<typename T, typename U> struct QMetaTypeId< std::pair<T, U> > { enum { Defined = QMetaTypeId2<T>::Defined && QMetaTypeId2<U>::Defined }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char *tName = QMetaType::typeName(qMetaTypeId<T>()); const char *uName = QMetaType::typeName(qMetaTypeId<U>()); do { } while ((false) && (tName)); do { } while ((false) && (uName)); const int tNameLen = int(qstrlen(tName)); const int uNameLen = int(qstrlen(uName)); QByteArray typeName; typeName.reserve(int(sizeof("std::pair")) + 1 + tNameLen + 1 + uNameLen + 1 + 1); typeName.append("std::pair", int(sizeof("std::pair")) - 1) .append('<').append(tName, tNameLen).append(',').append(uName, uNameLen); if (typeName.endsWith('>')) typeName.append(' '); typeName.append('>'); const int newId = qRegisterNormalizedMetaType< std::pair<T, U> >( typeName, reinterpret_cast< std::pair<T, U> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };
+
+
+
+
+
+ namespace QtPrivate { template<typename T> struct SharedPointerMetaTypeIdHelper<QSharedPointer<T>, true> { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char * const cName = T::staticMetaObject.className(); QByteArray typeName; typeName.reserve(int(sizeof("QSharedPointer") + 1 + strlen(cName) + 1)); typeName.append("QSharedPointer", int(sizeof("QSharedPointer")) - 1) .append('<').append(cName).append('>'); const int newId = qRegisterNormalizedMetaType< QSharedPointer<T> >( typeName, reinterpret_cast< QSharedPointer<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; template<typename T> struct MetaTypeSmartPointerHelper<QSharedPointer<T> , typename QEnableIf<IsPointerToTypeDerivedFromQObject<T*>::Value >::Type> { static bool registerConverter(int id) { const int toId = QMetaType::QObjectStar; if (!QMetaType::hasRegisteredConverterFunction(id, toId)) { QtPrivate::QSmartPointerConvertFunctor<QSharedPointer<T> > o; static const QtPrivate::ConverterFunctor<QSharedPointer<T>, QObject*, QSmartPointerConvertFunctor<QSharedPointer<T> > > f(o); return QMetaType::registerConverterFunction(&f, id, toId); } return true; } }; } template <typename T> struct QMetaTypeId< QSharedPointer<T> > : QtPrivate::SharedPointerMetaTypeIdHelper< QSharedPointer<T>, QtPrivate::IsPointerToTypeDerivedFromQObject<T*>::Value> { }; namespace QtPrivate { template<typename T> struct SharedPointerMetaTypeIdHelper<QWeakPointer<T>, true> { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char * const cName = T::staticMetaObject.className(); QByteArray typeName; typeName.reserve(int(sizeof("QWeakPointer") + 1 + strlen(cName) + 1)); typeName.append("QWeakPointer", int(sizeof("QWeakPointer")) - 1) .append('<').append(cName).append('>'); const int newId = qRegisterNormalizedMetaType< QWeakPointer<T> >( typeName, reinterpret_cast< QWeakPointer<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; template<typename T> struct MetaTypeSmartPointerHelper<QWeakPointer<T> , typename QEnableIf<IsPointerToTypeDerivedFromQObject<T*>::Value >::Type> { static bool registerConverter(int id) { const int toId = QMetaType::QObjectStar; if (!QMetaType::hasRegisteredConverterFunction(id, toId)) { QtPrivate::QSmartPointerConvertFunctor<QWeakPointer<T> > o; static const QtPrivate::ConverterFunctor<QWeakPointer<T>, QObject*, QSmartPointerConvertFunctor<QWeakPointer<T> > > f(o); return QMetaType::registerConverterFunction(&f, id, toId); } return true; } }; } template <typename T> struct QMetaTypeId< QWeakPointer<T> > : QtPrivate::SharedPointerMetaTypeIdHelper< QWeakPointer<T>, QtPrivate::IsPointerToTypeDerivedFromQObject<T*>::Value> { }; namespace QtPrivate { template<typename T> struct SharedPointerMetaTypeIdHelper<QPointer<T>, true> { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const char * const cName = T::staticMetaObject.className(); QByteArray typeName; typeName.reserve(int(sizeof("QPointer") + 1 + strlen(cName) + 1)); typeName.append("QPointer", int(sizeof("QPointer")) - 1) .append('<').append(cName).append('>'); const int newId = qRegisterNormalizedMetaType< QPointer<T> >( typeName, reinterpret_cast< QPointer<T> *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } }; template<typename T> struct MetaTypeSmartPointerHelper<QPointer<T> , typename QEnableIf<IsPointerToTypeDerivedFromQObject<T*>::Value >::Type> { static bool registerConverter(int id) { const int toId = QMetaType::QObjectStar; if (!QMetaType::hasRegisteredConverterFunction(id, toId)) { QtPrivate::QSmartPointerConvertFunctor<QPointer<T> > o; static const QtPrivate::ConverterFunctor<QPointer<T>, QObject*, QSmartPointerConvertFunctor<QPointer<T> > > f(o); return QMetaType::registerConverterFunction(&f, id, toId); } return true; } }; } template <typename T> struct QMetaTypeId< QPointer<T> > : QtPrivate::SharedPointerMetaTypeIdHelper< QPointer<T>, QtPrivate::IsPointerToTypeDerivedFromQObject<T*>::Value> { };
+
+
+
+
+
+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_unused(creator)
+    , m_deleter_unused(deleter)
+    , m_saveOp(saveOp)
+    , m_loadOp(loadOp)
+    , m_constructor(constructor)
+    , m_destructor(destructor)
+    , m_extension(nullptr)
+    , 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
+{
+
+    return createExtended(copy);
+}
+
+inline void QMetaType::destroy(void *data) const
+{
+
+    destroyExtended(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);
+}
+
+inline const QMetaObject *QMetaType::metaObject() const
+{
+    if (__builtin_expect(!!(isExtended(MetaObjectEx)), false))
+        return metaObjectExtended();
+    return m_metaObject;
+}
+
+
+
+
+ template<> struct QMetaTypeId2<void> { enum { Defined = 1, IsBuiltIn = true, MetaType = 43 }; static inline constexpr int qt_metatype_id() { return 43; } }; template<> struct QMetaTypeId2<bool> { enum { Defined = 1, IsBuiltIn = true, MetaType = 1 }; static inline constexpr int qt_metatype_id() { return 1; } }; template<> struct QMetaTypeId2<int> { enum { Defined = 1, IsBuiltIn = true, MetaType = 2 }; static inline constexpr int qt_metatype_id() { return 2; } }; template<> struct QMetaTypeId2<uint> { enum { Defined = 1, IsBuiltIn = true, MetaType = 3 }; static inline constexpr int qt_metatype_id() { return 3; } }; template<> struct QMetaTypeId2<qlonglong> { enum { Defined = 1, IsBuiltIn = true, MetaType = 4 }; static inline constexpr int qt_metatype_id() { return 4; } }; template<> struct QMetaTypeId2<qulonglong> { enum { Defined = 1, IsBuiltIn = true, MetaType = 5 }; static inline constexpr int qt_metatype_id() { return 5; } }; template<> struct QMetaTypeId2<double> { enum { Defined = 1, IsBuiltIn = true, MetaType = 6 }; static inline constexpr int qt_metatype_id() { return 6; } }; template<> struct QMetaTypeId2<long> { enum { Defined = 1, IsBuiltIn = true, MetaType = 32 }; static inline constexpr int qt_metatype_id() { return 32; } }; template<> struct QMetaTypeId2<short> { enum { Defined = 1, IsBuiltIn = true, MetaType = 33 }; static inline constexpr int qt_metatype_id() { return 33; } }; template<> struct QMetaTypeId2<char> { enum { Defined = 1, IsBuiltIn = true, MetaType = 34 }; static inline constexpr int qt_metatype_id() { return 34; } }; template<> struct QMetaTypeId2<ulong> { enum { Defined = 1, IsBuiltIn = true, MetaType = 35 }; static inline constexpr int qt_metatype_id() { return 35; } }; template<> struct QMetaTypeId2<ushort> { enum { Defined = 1, IsBuiltIn = true, MetaType = 36 }; static inline constexpr int qt_metatype_id() { return 36; } }; template<> struct QMetaTypeId2<uchar> { enum { Defined = 1, IsBuiltIn = true, MetaType = 37 }; static inline constexpr int qt_metatype_id() { return 37; } }; template<> struct QMetaTypeId2<float> { enum { Defined = 1, IsBuiltIn = true, MetaType = 38 }; static inline constexpr int qt_metatype_id() { return 38; } }; template<> struct QMetaTypeId2<signed char> { enum { Defined = 1, IsBuiltIn = true, MetaType = 40 }; static inline constexpr int qt_metatype_id() { return 40; } }; template<> struct QMetaTypeId2<void*> { enum { Defined = 1, IsBuiltIn = true, MetaType = 31 }; static inline constexpr int qt_metatype_id() { return 31; } }; template<> struct QMetaTypeId2<QChar> { enum { Defined = 1, IsBuiltIn = true, MetaType = 7 }; static inline constexpr int qt_metatype_id() { return 7; } }; template<> struct QMetaTypeId2<QString> { enum { Defined = 1, IsBuiltIn = true, MetaType = 10 }; static inline constexpr int qt_metatype_id() { return 10; } }; template<> struct QMetaTypeId2<QStringList> { enum { Defined = 1, IsBuiltIn = true, MetaType = 11 }; static inline constexpr int qt_metatype_id() { return 11; } }; template<> struct QMetaTypeId2<QByteArray> { enum { Defined = 1, IsBuiltIn = true, MetaType = 12 }; static inline constexpr int qt_metatype_id() { return 12; } }; template<> struct QMetaTypeId2<QBitArray> { enum { Defined = 1, IsBuiltIn = true, MetaType = 13 }; static inline constexpr int qt_metatype_id() { return 13; } }; template<> struct QMetaTypeId2<QDate> { enum { Defined = 1, IsBuiltIn = true, MetaType = 14 }; static inline constexpr int qt_metatype_id() { return 14; } }; template<> struct QMetaTypeId2<QTime> { enum { Defined = 1, IsBuiltIn = true, MetaType = 15 }; static inline constexpr int qt_metatype_id() { return 15; } }; template<> struct QMetaTypeId2<QDateTime> { enum { Defined = 1, IsBuiltIn = true, MetaType = 16 }; static inline constexpr int qt_metatype_id() { return 16; } }; template<> struct QMetaTypeId2<QUrl> { enum { Defined = 1, IsBuiltIn = true, MetaType = 17 }; static inline constexpr int qt_metatype_id() { return 17; } }; template<> struct QMetaTypeId2<QLocale> { enum { Defined = 1, IsBuiltIn = true, MetaType = 18 }; static inline constexpr int qt_metatype_id() { return 18; } }; template<> struct QMetaTypeId2<QRect> { enum { Defined = 1, IsBuiltIn = true, MetaType = 19 }; static inline constexpr int qt_metatype_id() { return 19; } }; template<> struct QMetaTypeId2<QRectF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 20 }; static inline constexpr int qt_metatype_id() { return 20; } }; template<> struct QMetaTypeId2<QSize> { enum { Defined = 1, IsBuiltIn = true, MetaType = 21 }; static inline constexpr int qt_metatype_id() { return 21; } }; template<> struct QMetaTypeId2<QSizeF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 22 }; static inline constexpr int qt_metatype_id() { return 22; } }; template<> struct QMetaTypeId2<QLine> { enum { Defined = 1, IsBuiltIn = true, MetaType = 23 }; static inline constexpr int qt_metatype_id() { return 23; } }; template<> struct QMetaTypeId2<QLineF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 24 }; static inline constexpr int qt_metatype_id() { return 24; } }; template<> struct QMetaTypeId2<QPoint> { enum { Defined = 1, IsBuiltIn = true, MetaType = 25 }; static inline constexpr int qt_metatype_id() { return 25; } }; template<> struct QMetaTypeId2<QPointF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 26 }; static inline constexpr int qt_metatype_id() { return 26; } }; template<> struct QMetaTypeId2<QRegExp> { enum { Defined = 1, IsBuiltIn = true, MetaType = 27 }; static inline constexpr int qt_metatype_id() { return 27; } }; template<> struct QMetaTypeId2<QEasingCurve> { enum { Defined = 1, IsBuiltIn = true, MetaType = 29 }; static inline constexpr int qt_metatype_id() { return 29; } }; template<> struct QMetaTypeId2<QUuid> { enum { Defined = 1, IsBuiltIn = true, MetaType = 30 }; static inline constexpr int qt_metatype_id() { return 30; } }; template<> struct QMetaTypeId2<QVariant> { enum { Defined = 1, IsBuiltIn = true, MetaType = 41 }; static inline constexpr int qt_metatype_id() { return 41; } }; template<> struct QMetaTypeId2<QModelIndex> { enum { Defined = 1, IsBuiltIn = true, MetaType = 42 }; static inline constexpr int qt_metatype_id() { return 42; } }; template<> struct QMetaTypeId2<QRegularExpression> { enum { Defined = 1, IsBuiltIn = true, MetaType = 44 }; static inline constexpr int qt_metatype_id() { return 44; } }; template<> struct QMetaTypeId2<QJsonValue> { enum { Defined = 1, IsBuiltIn = true, MetaType = 45 }; static inline constexpr int qt_metatype_id() { return 45; } }; template<> struct QMetaTypeId2<QJsonObject> { enum { Defined = 1, IsBuiltIn = true, MetaType = 46 }; static inline constexpr int qt_metatype_id() { return 46; } }; template<> struct QMetaTypeId2<QJsonArray> { enum { Defined = 1, IsBuiltIn = true, MetaType = 47 }; static inline constexpr int qt_metatype_id() { return 47; } }; template<> struct QMetaTypeId2<QJsonDocument> { enum { Defined = 1, IsBuiltIn = true, MetaType = 48 }; static inline constexpr int qt_metatype_id() { return 48; } }; template<> struct QMetaTypeId2<QPersistentModelIndex> { enum { Defined = 1, IsBuiltIn = true, MetaType = 50 }; static inline constexpr int qt_metatype_id() { return 50; } }; template<> struct QMetaTypeId2<QObject*> { enum { Defined = 1, IsBuiltIn = true, MetaType = 39 }; static inline constexpr int qt_metatype_id() { return 39; } }; template<> struct QMetaTypeId2<QVariantMap> { enum { Defined = 1, IsBuiltIn = true, MetaType = 8 }; static inline constexpr int qt_metatype_id() { return 8; } }; template<> struct QMetaTypeId2<QVariantList> { enum { Defined = 1, IsBuiltIn = true, MetaType = 9 }; static inline constexpr int qt_metatype_id() { return 9; } }; template<> struct QMetaTypeId2<QVariantHash> { enum { Defined = 1, IsBuiltIn = true, MetaType = 28 }; static inline constexpr int qt_metatype_id() { return 28; } }; template<> struct QMetaTypeId2<QByteArrayList> { enum { Defined = 1, IsBuiltIn = true, MetaType = 49 }; static inline constexpr int qt_metatype_id() { return 49; } }; template<> struct QMetaTypeId2<QFont> { enum { Defined = 1, IsBuiltIn = true, MetaType = 64 }; static inline constexpr int qt_metatype_id() { return 64; } }; template<> struct QMetaTypeId2<QPixmap> { enum { Defined = 1, IsBuiltIn = true, MetaType = 65 }; static inline constexpr int qt_metatype_id() { return 65; } }; template<> struct QMetaTypeId2<QBrush> { enum { Defined = 1, IsBuiltIn = true, MetaType = 66 }; static inline constexpr int qt_metatype_id() { return 66; } }; template<> struct QMetaTypeId2<QColor> { enum { Defined = 1, IsBuiltIn = true, MetaType = 67 }; static inline constexpr int qt_metatype_id() { return 67; } }; template<> struct QMetaTypeId2<QPalette> { enum { Defined = 1, IsBuiltIn = true, MetaType = 68 }; static inline constexpr int qt_metatype_id() { return 68; } }; template<> struct QMetaTypeId2<QIcon> { enum { Defined = 1, IsBuiltIn = true, MetaType = 69 }; static inline constexpr int qt_metatype_id() { return 69; } }; template<> struct QMetaTypeId2<QImage> { enum { Defined = 1, IsBuiltIn = true, MetaType = 70 }; static inline constexpr int qt_metatype_id() { return 70; } }; template<> struct QMetaTypeId2<QPolygon> { enum { Defined = 1, IsBuiltIn = true, MetaType = 71 }; static inline constexpr int qt_metatype_id() { return 71; } }; template<> struct QMetaTypeId2<QRegion> { enum { Defined = 1, IsBuiltIn = true, MetaType = 72 }; static inline constexpr int qt_metatype_id() { return 72; } }; template<> struct QMetaTypeId2<QBitmap> { enum { Defined = 1, IsBuiltIn = true, MetaType = 73 }; static inline constexpr int qt_metatype_id() { return 73; } }; template<> struct QMetaTypeId2<QCursor> { enum { Defined = 1, IsBuiltIn = true, MetaType = 74 }; static inline constexpr int qt_metatype_id() { return 74; } }; template<> struct QMetaTypeId2<QKeySequence> { enum { Defined = 1, IsBuiltIn = true, MetaType = 75 }; static inline constexpr int qt_metatype_id() { return 75; } }; template<> struct QMetaTypeId2<QPen> { enum { Defined = 1, IsBuiltIn = true, MetaType = 76 }; static inline constexpr int qt_metatype_id() { return 76; } }; template<> struct QMetaTypeId2<QTextLength> { enum { Defined = 1, IsBuiltIn = true, MetaType = 77 }; static inline constexpr int qt_metatype_id() { return 77; } }; template<> struct QMetaTypeId2<QTextFormat> { enum { Defined = 1, IsBuiltIn = true, MetaType = 78 }; static inline constexpr int qt_metatype_id() { return 78; } }; template<> struct QMetaTypeId2<QMatrix> { enum { Defined = 1, IsBuiltIn = true, MetaType = 79 }; static inline constexpr int qt_metatype_id() { return 79; } }; template<> struct QMetaTypeId2<QTransform> { enum { Defined = 1, IsBuiltIn = true, MetaType = 80 }; static inline constexpr int qt_metatype_id() { return 80; } }; template<> struct QMetaTypeId2<QMatrix4x4> { enum { Defined = 1, IsBuiltIn = true, MetaType = 81 }; static inline constexpr int qt_metatype_id() { return 81; } }; template<> struct QMetaTypeId2<QVector2D> { enum { Defined = 1, IsBuiltIn = true, MetaType = 82 }; static inline constexpr int qt_metatype_id() { return 82; } }; template<> struct QMetaTypeId2<QVector3D> { enum { Defined = 1, IsBuiltIn = true, MetaType = 83 }; static inline constexpr int qt_metatype_id() { return 83; } }; template<> struct QMetaTypeId2<QVector4D> { enum { Defined = 1, IsBuiltIn = true, MetaType = 84 }; static inline constexpr int qt_metatype_id() { return 84; } }; template<> struct QMetaTypeId2<QQuaternion> { enum { Defined = 1, IsBuiltIn = true, MetaType = 85 }; static inline constexpr int qt_metatype_id() { return 85; } }; template<> struct QMetaTypeId2<QPolygonF> { enum { Defined = 1, IsBuiltIn = true, MetaType = 86 }; static inline constexpr int qt_metatype_id() { return 86; } }; template<> struct QMetaTypeId2<QSizePolicy> { enum { Defined = 1, IsBuiltIn = true, MetaType = 121 }; static inline constexpr int qt_metatype_id() { return 121; } };
+
+ template <> struct QMetaTypeId< QtMetaTypePrivate::QSequentialIterableImpl > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< QtMetaTypePrivate::QSequentialIterableImpl >("QtMetaTypePrivate::QSequentialIterableImpl", reinterpret_cast< QtMetaTypePrivate::QSequentialIterableImpl *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };
+ template <> struct QMetaTypeId< QtMetaTypePrivate::QAssociativeIterableImpl > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< QtMetaTypePrivate::QAssociativeIterableImpl >("QtMetaTypePrivate::QAssociativeIterableImpl", reinterpret_cast< QtMetaTypePrivate::QAssociativeIterableImpl *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };
+ template <> struct QMetaTypeId< QtMetaTypePrivate::QPairVariantInterfaceImpl > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { 0 }; if (const int id = metatype_id.loadAcquire()) return id; const int newId = qRegisterMetaType< QtMetaTypePrivate::QPairVariantInterfaceImpl >("QtMetaTypePrivate::QPairVariantInterfaceImpl", reinterpret_cast< QtMetaTypePrivate::QPairVariantInterfaceImpl *>(quintptr(-1))); metatype_id.storeRelease(newId); return newId; } };
+
+
+
+template <typename T>
+inline bool QtPrivate::IsMetaTypePair<T, true>::registerConverter(int id)
+{
+    const int toId = qMetaTypeId<QtMetaTypePrivate::QPairVariantInterfaceImpl>();
+    if (!QMetaType::hasRegisteredConverterFunction(id, toId)) {
+        QtMetaTypePrivate::QPairVariantInterfaceConvertFunctor<T> o;
+        static const QtPrivate::ConverterFunctor<T,
+                                    QtMetaTypePrivate::QPairVariantInterfaceImpl,
+                                    QtMetaTypePrivate::QPairVariantInterfaceConvertFunctor<T> > f(o);
+        return QMetaType::registerConverterFunction(&f, id, toId);
+    }
+    return true;
+}
+
+namespace QtPrivate {
+    template<typename T>
+    struct ValueTypeIsMetaType<T, true>
+    {
+        static bool registerConverter(int id)
+        {
+            const int toId = qMetaTypeId<QtMetaTypePrivate::QSequentialIterableImpl>();
+            if (!QMetaType::hasRegisteredConverterFunction(id, toId)) {
+                QtMetaTypePrivate::QSequentialIterableConvertFunctor<T> o;
+                static const QtPrivate::ConverterFunctor<T,
+                        QtMetaTypePrivate::QSequentialIterableImpl,
+                QtMetaTypePrivate::QSequentialIterableConvertFunctor<T> > f(o);
+                return QMetaType::registerConverterFunction(&f, id, toId);
+            }
+            return true;
+        }
+    };
+
+    template<typename T>
+    struct AssociativeValueTypeIsMetaType<T, true>
+    {
+        static bool registerConverter(int id)
+        {
+            const int toId = qMetaTypeId<QtMetaTypePrivate::QAssociativeIterableImpl>();
+            if (!QMetaType::hasRegisteredConverterFunction(id, toId)) {
+                QtMetaTypePrivate::QAssociativeIterableConvertFunctor<T> o;
+                static const QtPrivate::ConverterFunctor<T,
+                                            QtMetaTypePrivate::QAssociativeIterableImpl,
+                                            QtMetaTypePrivate::QAssociativeIterableConvertFunctor<T> > f(o);
+                return QMetaType::registerConverterFunction(&f, id, toId);
+            }
+            return true;
+        }
+    };
+}
+
+
+# 1 "../../include/QtCore/qmetatype.h" 2
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+# 1 "../../include/QtCore/qmap.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h"
+# 1 "../../include/QtCore/qiterator.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h" 2
+# 1 "../../include/QtCore/qlist.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h" 2
+# 1 "../../include/QtCore/qrefcount.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h" 2
+# 1 "../../include/QtCore/qpair.h" 1
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h" 2
+# 1 "../../include/QtCore/qtypetraits.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 1
+# 107 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 108 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qtypetraits.h" 2
+# 1 "../../include/QtCore/qtypetraits.h" 2
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h" 2
+# 60 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h"
+
+# 72 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h"
+template <class Key> inline bool qMapLessThanKey(const Key &key1, const Key &key2)
+{
+    return key1 < key2;
+}
+
+template <class Ptr> inline bool qMapLessThanKey(const Ptr *key1, const Ptr *key2)
+{
+    static_assert(bool(sizeof(quintptr) == sizeof(const Ptr *)), "sizeof(quintptr) == sizeof(const Ptr *)");
+    return quintptr(key1) < quintptr(key2);
+}
+
+struct QMapDataBase;
+template <class Key, class T> struct QMapData;
+
+struct __attribute__((visibility("default"))) QMapNodeBase
+{
+    quintptr p;
+    QMapNodeBase *left;
+    QMapNodeBase *right;
+
+    enum Color { Red = 0, Black = 1 };
+    enum { Mask = 3 };
+
+    const QMapNodeBase *nextNode() const;
+    QMapNodeBase *nextNode() { return const_cast<QMapNodeBase *>(const_cast<const QMapNodeBase *>(this)->nextNode()); }
+    const QMapNodeBase *previousNode() const;
+    QMapNodeBase *previousNode() { return const_cast<QMapNodeBase *>(const_cast<const QMapNodeBase *>(this)->previousNode()); }
+
+    Color color() const { return Color(p & 1); }
+    void setColor(Color c) { if (c == Black) p |= Black; else p &= ~Black; }
+    QMapNodeBase *parent() const { return reinterpret_cast<QMapNodeBase *>(p & ~Mask); }
+    void setParent(QMapNodeBase *pp) { p = (p & Mask) | quintptr(pp); }
+
+    template <typename T>
+    static typename QtPrivate::QEnableIf<QTypeInfo<T>::isComplex>::Type
+    callDestructorIfNecessary(T &t) noexcept { (void)t;; t.~T(); }
+    template <typename T>
+    static typename QtPrivate::QEnableIf<!QTypeInfo<T>::isComplex>::Type
+    callDestructorIfNecessary(T &) noexcept {}
+};
+
+template <class Key, class T>
+struct QMapNode : public QMapNodeBase
+{
+    Key key;
+    T value;
+
+    inline QMapNode *leftNode() const { return static_cast<QMapNode *>(left); }
+    inline QMapNode *rightNode() const { return static_cast<QMapNode *>(right); }
+
+    inline const QMapNode *nextNode() const { return static_cast<const QMapNode *>(QMapNodeBase::nextNode()); }
+    inline const QMapNode *previousNode() const { return static_cast<const QMapNode *>(QMapNodeBase::previousNode()); }
+    inline QMapNode *nextNode() { return static_cast<QMapNode *>(QMapNodeBase::nextNode()); }
+    inline QMapNode *previousNode() { return static_cast<QMapNode *>(QMapNodeBase::previousNode()); }
+
+    QMapNode<Key, T> *copy(QMapData<Key, T> *d) const;
+
+    void destroySubTree()
+    {
+        callDestructorIfNecessary(key);
+        callDestructorIfNecessary(value);
+        doDestroySubTree(QtPrivate::integral_constant<bool, QTypeInfo<T>::isComplex || QTypeInfo<Key>::isComplex>());
+    }
+
+    QMapNode<Key, T> *lowerBound(const Key &key);
+    QMapNode<Key, T> *upperBound(const Key &key);
+
+private:
+    void doDestroySubTree(QtPrivate::false_type) {}
+    void doDestroySubTree(QtPrivate::true_type)
+    {
+        if (left)
+            leftNode()->destroySubTree();
+        if (right)
+            rightNode()->destroySubTree();
+    }
+
+    QMapNode() = delete;
+    QMapNode(const QMapNode &) = delete; QMapNode &operator=(const QMapNode &) = delete;
+};
+
+template <class Key, class T>
+inline QMapNode<Key, T> *QMapNode<Key, T>::lowerBound(const Key &akey)
+{
+    QMapNode<Key, T> *n = this;
+    QMapNode<Key, T> *lastNode = nullptr;
+    while (n) {
+        if (!qMapLessThanKey(n->key, akey)) {
+            lastNode = n;
+            n = n->leftNode();
+        } else {
+            n = n->rightNode();
+        }
+    }
+    return lastNode;
+}
+
+template <class Key, class T>
+inline QMapNode<Key, T> *QMapNode<Key, T>::upperBound(const Key &akey)
+{
+    QMapNode<Key, T> *n = this;
+    QMapNode<Key, T> *lastNode = nullptr;
+    while (n) {
+        if (qMapLessThanKey(akey, n->key)) {
+            lastNode = n;
+            n = n->leftNode();
+        } else {
+            n = n->rightNode();
+        }
+    }
+    return lastNode;
+}
+
+
+
+struct __attribute__((visibility("default"))) QMapDataBase
+{
+    QtPrivate::RefCount ref;
+    int size;
+    QMapNodeBase header;
+    QMapNodeBase *mostLeftNode;
+
+    void rotateLeft(QMapNodeBase *x);
+    void rotateRight(QMapNodeBase *x);
+    void rebalance(QMapNodeBase *x);
+    void freeNodeAndRebalance(QMapNodeBase *z);
+    void recalcMostLeftNode();
+
+    QMapNodeBase *createNode(int size, int alignment, QMapNodeBase *parent, bool left);
+    void freeTree(QMapNodeBase *root, int alignment);
+
+    static const QMapDataBase shared_null;
+
+    static QMapDataBase *createData();
+    static void freeData(QMapDataBase *d);
+};
+
+template <class Key, class T>
+struct QMapData : public QMapDataBase
+{
+    typedef QMapNode<Key, T> Node;
+
+    Node *root() const { return static_cast<Node *>(header.left); }
+
+    const Node *end() const { return static_cast<const Node *>(&header); }
+    Node *end() { return static_cast<Node *>(&header); }
+    const Node *begin() const { if (root()) return static_cast<const Node*>(mostLeftNode); return end(); }
+    Node *begin() { if (root()) return static_cast<Node*>(mostLeftNode); return end(); }
+
+    void deleteNode(Node *z);
+    Node *findNode(const Key &akey) const;
+    void nodeRange(const Key &akey, Node **firstNode, Node **lastNode);
+
+    Node *createNode(const Key &k, const T &v, Node *parent = nullptr, bool left = false)
+    {
+        Node *n = static_cast<Node *>(QMapDataBase::createNode(sizeof(Node), __alignof__(Node),
+                                      parent, left));
+        try {
+            new (&n->key) Key(k);
+            try {
+                new (&n->value) T(v);
+            } catch (...) {
+                n->key.~Key();
+                throw;
+            }
+        } catch (...) {
+            QMapDataBase::freeNodeAndRebalance(n);
+            throw;
+        }
+        return n;
+    }
+
+    static QMapData *create() {
+        return static_cast<QMapData *>(createData());
+    }
+
+    void destroy() {
+        if (root()) {
+            root()->destroySubTree();
+            freeTree(header.left, __alignof__(Node));
+        }
+        freeData(this);
+    }
+};
+
+template <class Key, class T>
+QMapNode<Key, T> *QMapNode<Key, T>::copy(QMapData<Key, T> *d) const
+{
+    QMapNode<Key, T> *n = d->createNode(key, value);
+    n->setColor(color());
+    if (left) {
+        n->left = leftNode()->copy(d);
+        n->left->setParent(n);
+    } else {
+        n->left = nullptr;
+    }
+    if (right) {
+        n->right = rightNode()->copy(d);
+        n->right->setParent(n);
+    } else {
+        n->right = nullptr;
+    }
+    return n;
+}
+
+template <class Key, class T>
+void QMapData<Key, T>::deleteNode(QMapNode<Key, T> *z)
+{
+    QMapNodeBase::callDestructorIfNecessary(z->key);
+    QMapNodeBase::callDestructorIfNecessary(z->value);
+    freeNodeAndRebalance(z);
+}
+
+template <class Key, class T>
+QMapNode<Key, T> *QMapData<Key, T>::findNode(const Key &akey) const
+{
+    if (Node *r = root()) {
+        Node *lb = r->lowerBound(akey);
+        if (lb && !qMapLessThanKey(akey, lb->key))
+            return lb;
+    }
+    return nullptr;
+}
+
+
+template <class Key, class T>
+void QMapData<Key, T>::nodeRange(const Key &akey, QMapNode<Key, T> **firstNode, QMapNode<Key, T> **lastNode)
+{
+    Node *n = root();
+    Node *l = end();
+    while (n) {
+        if (qMapLessThanKey(akey, n->key)) {
+            l = n;
+            n = n->leftNode();
+        } else if (qMapLessThanKey(n->key, akey)) {
+            n = n->rightNode();
+        } else {
+            *firstNode = n->leftNode() ? n->leftNode()->lowerBound(akey) : nullptr;
+            if (!*firstNode)
+                *firstNode = n;
+            *lastNode = n->rightNode() ? n->rightNode()->upperBound(akey) : nullptr;
+            if (!*lastNode)
+                *lastNode = l;
+            return;
+        }
+    }
+    *firstNode = *lastNode = l;
+}
+
+
+template <class Key, class T>
+class QMap
+{
+    typedef QMapNode<Key, T> Node;
+
+    QMapData<Key, T> *d;
+
+public:
+    inline QMap() noexcept : d(static_cast<QMapData<Key, T> *>(const_cast<QMapDataBase *>(&QMapDataBase::shared_null))) { }
+
+    inline QMap(std::initializer_list<std::pair<Key,T> > list)
+        : d(static_cast<QMapData<Key, T> *>(const_cast<QMapDataBase *>(&QMapDataBase::shared_null)))
+    {
+        for (typename std::initializer_list<std::pair<Key,T> >::const_iterator it = list.begin(); it != list.end(); ++it)
+            insert(it->first, it->second);
+    }
+
+    QMap(const QMap<Key, T> &other);
+
+    inline ~QMap() { if (!d->ref.deref()) d->destroy(); }
+
+    QMap<Key, T> &operator=(const QMap<Key, T> &other);
+
+    inline QMap(QMap<Key, T> &&other) noexcept
+        : d(other.d)
+    {
+        other.d = static_cast<QMapData<Key, T> *>(
+                const_cast<QMapDataBase *>(&QMapDataBase::shared_null));
+    }
+
+    inline QMap<Key, T> &operator=(QMap<Key, T> &&other) noexcept
+    { QMap moved(std::move(other)); swap(moved); return *this; }
+
+    inline void swap(QMap<Key, T> &other) noexcept { qSwap(d, other.d); }
+    explicit QMap(const typename std::map<Key, T> &other);
+    std::map<Key, T> toStdMap() const;
+
+    bool operator==(const QMap<Key, T> &other) const;
+    inline bool operator!=(const QMap<Key, T> &other) const { return !(*this == other); }
+
+    inline int size() const { return d->size; }
+
+    inline bool isEmpty() const { return d->size == 0; }
+
+    inline void detach() { if (d->ref.isShared()) detach_helper(); }
+    inline bool isDetached() const { return !d->ref.isShared(); }
+
+    inline void setSharable(bool sharable)
+    {
+        if (sharable == d->ref.isSharable())
+            return;
+        if (!sharable)
+            detach();
+
+        d->ref.setSharable(sharable);
+    }
+
+    inline bool isSharedWith(const QMap<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 Key &defaultKey = Key()) const;
+    const T value(const Key &key, const T &defaultValue = T()) 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;
+
+    inline const Key &firstKey() const { do { } while ((false) && (!isEmpty())); return constBegin().key(); }
+    inline const Key &lastKey() const { do { } while ((false) && (!isEmpty())); return (constEnd() - 1).key(); }
+
+    inline T &first() { do { } while ((false) && (!isEmpty())); return *begin(); }
+    inline const T &first() const { do { } while ((false) && (!isEmpty())); return *constBegin(); }
+    inline T &last() { do { } while ((false) && (!isEmpty())); return *(end() - 1); }
+    inline const T &last() const { do { } while ((false) && (!isEmpty())); return *(constEnd() - 1); }
+
+    class const_iterator;
+
+    class iterator
+    {
+        friend class const_iterator;
+        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(nullptr) { }
+        inline iterator(Node *node) : i(node) { }
+
+        inline const Key &key() const { return i->key; }
+        inline T &value() const { return i->value; }
+        inline T &operator*() const { return i->value; }
+        inline T *operator->() const { return &i->value; }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+
+        inline iterator &operator++() {
+            i = i->nextNode();
+            return *this;
+        }
+        inline iterator operator++(int) {
+            iterator r = *this;
+            i = i->nextNode();
+            return r;
+        }
+        inline iterator &operator--() {
+            i = i->previousNode();
+            return *this;
+        }
+        inline iterator operator--(int) {
+            iterator r = *this;
+            i = i->previousNode();
+            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 QMap<Key, T>;
+    };
+    friend class iterator;
+
+    class const_iterator
+    {
+        friend class iterator;
+        const 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(nullptr) { }
+        inline const_iterator(const Node *node) : i(node) { }
+
+
+
+        inline const_iterator(const iterator &o)
+
+        { i = o.i; }
+
+        inline const Key &key() const { return i->key; }
+        inline const T &value() const { return i->value; }
+        inline const T &operator*() const { return i->value; }
+        inline const T *operator->() const { return &i->value; }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+
+        inline const_iterator &operator++() {
+            i = i->nextNode();
+            return *this;
+        }
+        inline const_iterator operator++(int) {
+            const_iterator r = *this;
+            i = i->nextNode();
+            return r;
+        }
+        inline const_iterator &operator--() {
+            i = i->previousNode();
+            return *this;
+        }
+        inline const_iterator operator--(int) {
+            const_iterator r = *this;
+            i = i->previousNode();
+            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 QMap<Key, T>;
+    };
+    friend class const_iterator;
+
+    class key_iterator
+    {
+        const_iterator i;
+
+    public:
+        typedef typename const_iterator::iterator_category iterator_category;
+        typedef typename const_iterator::difference_type difference_type;
+        typedef Key value_type;
+        typedef const Key *pointer;
+        typedef const Key &reference;
+
+        explicit key_iterator(const_iterator o) : i(o) { }
+
+        const Key &operator*() const { return i.key(); }
+        const Key *operator->() const { return &i.key(); }
+        bool operator==(key_iterator o) const { return i == o.i; }
+        bool operator!=(key_iterator o) const { return i != o.i; }
+
+        inline key_iterator &operator++() { ++i; return *this; }
+        inline key_iterator operator++(int) { return key_iterator(i++);}
+        inline key_iterator &operator--() { --i; return *this; }
+        inline key_iterator operator--(int) { return key_iterator(i--); }
+        const_iterator base() const { return i; }
+    };
+
+
+
+    inline iterator begin() { detach(); return iterator(d->begin()); }
+    inline const_iterator begin() const { return const_iterator(d->begin()); }
+    inline const_iterator constBegin() const { return const_iterator(d->begin()); }
+    inline const_iterator cbegin() const { return const_iterator(d->begin()); }
+    inline iterator end() { detach(); return iterator(d->end()); }
+    inline const_iterator end() const { return const_iterator(d->end()); }
+    inline const_iterator constEnd() const { return const_iterator(d->end()); }
+    inline const_iterator cend() const { return const_iterator(d->end()); }
+    inline key_iterator keyBegin() const { return key_iterator(begin()); }
+    inline key_iterator keyEnd() const { return key_iterator(end()); }
+    iterator erase(iterator it);
+
+
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return d->size; }
+    iterator find(const Key &key);
+    const_iterator find(const Key &key) const;
+    const_iterator constFind(const Key &key) const;
+    iterator lowerBound(const Key &key);
+    const_iterator lowerBound(const Key &key) const;
+    iterator upperBound(const Key &key);
+    const_iterator upperBound(const Key &key) const;
+    iterator insert(const Key &key, const T &value);
+    iterator insert(const_iterator pos, const Key &key, const T &value);
+    iterator insertMulti(const Key &key, const T &value);
+    iterator insertMulti(const_iterator pos, const Key &akey, const T &avalue);
+    QMap<Key, T> &unite(const QMap<Key, T> &other);
+
+
+    typedef Key key_type;
+    typedef T mapped_type;
+    typedef qptrdiff difference_type;
+    typedef int size_type;
+    inline bool empty() const { return isEmpty(); }
+    QPair<iterator, iterator> equal_range(const Key &akey);
+    QPair<const_iterator, const_iterator> equal_range(const Key &akey) const;
+
+
+
+
+
+private:
+    void detach_helper();
+    bool isValidIterator(const const_iterator &ci) const
+    {
+
+
+
+
+
+
+        (void)ci;;
+        return true;
+
+    }
+};
+
+template <class Key, class T>
+inline QMap<Key, T>::QMap(const QMap<Key, T> &other)
+{
+    if (other.d->ref.ref()) {
+        d = other.d;
+    } else {
+        d = QMapData<Key, T>::create();
+        if (other.d->header.left) {
+            d->header.left = static_cast<Node *>(other.d->header.left)->copy(d);
+            d->header.left->setParent(&d->header);
+            d->recalcMostLeftNode();
+        }
+    }
+}
+
+template <class Key, class T>
+inline QMap<Key, T> &QMap<Key, T>::operator=(const QMap<Key, T> &other)
+{
+    if (d != other.d) {
+        QMap<Key, T> tmp(other);
+        tmp.swap(*this);
+    }
+    return *this;
+}
+
+template <class Key, class T>
+inline void QMap<Key, T>::clear()
+{
+    *this = QMap<Key, T>();
+}
+
+
+template <class Key, class T>
+inline const T QMap<Key, T>::value(const Key &akey, const T &adefaultValue) const
+{
+    Node *n = d->findNode(akey);
+    return n ? n->value : adefaultValue;
+}
+
+template <class Key, class T>
+inline const T QMap<Key, T>::operator[](const Key &akey) const
+{
+    return value(akey);
+}
+
+template <class Key, class T>
+inline T &QMap<Key, T>::operator[](const Key &akey)
+{
+    detach();
+    Node *n = d->findNode(akey);
+    if (!n)
+        return *insert(akey, T());
+    return n->value;
+}
+
+template <class Key, class T>
+inline int QMap<Key, T>::count(const Key &akey) const
+{
+    Node *firstNode;
+    Node *lastNode;
+    d->nodeRange(akey, &firstNode, &lastNode);
+
+    const_iterator ci_first(firstNode);
+    const const_iterator ci_last(lastNode);
+    int cnt = 0;
+    while (ci_first != ci_last) {
+        ++cnt;
+        ++ci_first;
+    }
+    return cnt;
+}
+
+template <class Key, class T>
+inline bool QMap<Key, T>::contains(const Key &akey) const
+{
+    return d->findNode(akey) != nullptr;
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::insert(const Key &akey, const T &avalue)
+{
+    detach();
+    Node *n = d->root();
+    Node *y = d->end();
+    Node *lastNode = nullptr;
+    bool left = true;
+    while (n) {
+        y = n;
+        if (!qMapLessThanKey(n->key, akey)) {
+            lastNode = n;
+            left = true;
+            n = n->leftNode();
+        } else {
+            left = false;
+            n = n->rightNode();
+        }
+    }
+    if (lastNode && !qMapLessThanKey(akey, lastNode->key)) {
+        lastNode->value = avalue;
+        return iterator(lastNode);
+    }
+    Node *z = d->createNode(akey, avalue, y, left);
+    return iterator(z);
+}
+
+template <class Key, class T>
+typename QMap<Key, T>::iterator QMap<Key, T>::insert(const_iterator pos, const Key &akey, const T &avalue)
+{
+    if (d->ref.isShared())
+        return this->insert(akey, avalue);
+
+    do { } while ((false) && (isValidIterator(pos)));
+
+    if (pos == constEnd()) {
+
+        Node *n = static_cast<Node *>(pos.i->left);
+        if (n) {
+            while (n->right)
+                n = static_cast<Node *>(n->right);
+
+            if (!qMapLessThanKey(n->key, akey))
+                return this->insert(akey, avalue);
+
+
+
+
+            Node *z = d->createNode(akey, avalue, n, false);
+            return iterator(z);
+        }
+        return this->insert(akey, avalue);
+    } else {
+
+
+        Node *next = const_cast<Node*>(pos.i);
+        if (qMapLessThanKey(next->key, akey))
+            return this->insert(akey, avalue);
+
+        if (pos == constBegin()) {
+
+
+            if (!qMapLessThanKey(akey, next->key)) {
+                next->value = avalue;
+                return iterator(next);
+            }
+
+            Node *z = d->createNode(akey, avalue, begin().i, true);
+            return iterator(z);
+        } else {
+            Node *prev = const_cast<Node*>(pos.i->previousNode());
+            if (!qMapLessThanKey(prev->key, akey)) {
+                return this->insert(akey, avalue);
+            }
+
+            if (!qMapLessThanKey(akey, next->key)) {
+                next->value = avalue;
+                return iterator(next);
+            }
+
+
+            if (prev->right == nullptr) {
+                Node *z = d->createNode(akey, avalue, prev, false);
+                return iterator(z);
+            }
+            if (next->left == nullptr) {
+                Node *z = d->createNode(akey, avalue, next, true);
+                return iterator(z);
+            }
+            do { } while ((false) && (false));
+            return this->insert(akey, avalue);
+        }
+    }
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::insertMulti(const Key &akey,
+                                                                            const T &avalue)
+{
+    detach();
+    Node* y = d->end();
+    Node* x = static_cast<Node *>(d->root());
+    bool left = true;
+    while (x != nullptr) {
+        left = !qMapLessThanKey(x->key, akey);
+        y = x;
+        x = left ? x->leftNode() : x->rightNode();
+    }
+    Node *z = d->createNode(akey, avalue, y, left);
+    return iterator(z);
+}
+
+template <class Key, class T>
+typename QMap<Key, T>::iterator QMap<Key, T>::insertMulti(const_iterator pos, const Key &akey, const T &avalue)
+{
+    if (d->ref.isShared())
+        return this->insertMulti(akey, avalue);
+
+    do { } while ((false) && (isValidIterator(pos)));
+
+    if (pos == constEnd()) {
+
+        Node *n = static_cast<Node *>(pos.i->left);
+        if (n) {
+            while (n->right)
+                n = static_cast<Node *>(n->right);
+
+            if (!qMapLessThanKey(n->key, akey))
+                return this->insertMulti(akey, avalue);
+            Node *z = d->createNode(akey, avalue, n, false);
+            return iterator(z);
+        }
+        return this->insertMulti(akey, avalue);
+    } else {
+
+
+        Node *next = const_cast<Node*>(pos.i);
+        if (qMapLessThanKey(next->key, akey))
+            return this->insertMulti(akey, avalue);
+
+        if (pos == constBegin()) {
+
+            Node *z = d->createNode(akey, avalue, begin().i, true);
+            return iterator(z);
+        } else {
+            Node *prev = const_cast<Node*>(pos.i->previousNode());
+            if (!qMapLessThanKey(prev->key, akey))
+                return this->insertMulti(akey, avalue);
+
+
+            if (prev->right == nullptr) {
+                Node *z = d->createNode(akey, avalue, prev, false);
+                return iterator(z);
+            }
+            if (next->left == nullptr) {
+                Node *z = d->createNode(akey, avalue, next, true);
+                return iterator(z);
+            }
+            do { } while ((false) && (false));
+            return this->insertMulti(akey, avalue);
+        }
+    }
+}
+
+
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator QMap<Key, T>::constFind(const Key &akey) const
+{
+    Node *n = d->findNode(akey);
+    return const_iterator(n ? n : d->end());
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator QMap<Key, T>::find(const Key &akey) const
+{
+    return constFind(akey);
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::find(const Key &akey)
+{
+    detach();
+    Node *n = d->findNode(akey);
+    return iterator(n ? n : d->end());
+}
+
+template <class Key, class T>
+inline QMap<Key, T> &QMap<Key, T>::unite(const QMap<Key, T> &other)
+{
+    QMap<Key, T> copy(other);
+    const_iterator it = copy.constEnd();
+    const const_iterator b = copy.constBegin();
+    while (it != b) {
+        --it;
+        insertMulti(it.key(), it.value());
+    }
+    return *this;
+}
+
+template <class Key, class T>
+QPair<typename QMap<Key, T>::iterator, typename QMap<Key, T>::iterator> QMap<Key, T>::equal_range(const Key &akey)
+{
+    detach();
+    Node *firstNode, *lastNode;
+    d->nodeRange(akey, &firstNode, &lastNode);
+    return QPair<iterator, iterator>(iterator(firstNode), iterator(lastNode));
+}
+
+template <class Key, class T>
+QPair<typename QMap<Key, T>::const_iterator, typename QMap<Key, T>::const_iterator>
+QMap<Key, T>::equal_range(const Key &akey) const
+{
+    Node *firstNode, *lastNode;
+    d->nodeRange(akey, &firstNode, &lastNode);
+    return qMakePair(const_iterator(firstNode), const_iterator(lastNode));
+}
+# 929 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qmap.h"
+template <class Key, class T>
+ int QMap<Key, T>::remove(const Key &akey)
+{
+    detach();
+    int n = 0;
+    while (Node *node = d->findNode(akey)) {
+        d->deleteNode(node);
+        ++n;
+    }
+    return n;
+}
+
+template <class Key, class T>
+ T QMap<Key, T>::take(const Key &akey)
+{
+    detach();
+
+    Node *node = d->findNode(akey);
+    if (node) {
+        T t = node->value;
+        d->deleteNode(node);
+        return t;
+    }
+    return T();
+}
+
+template <class Key, class T>
+ typename QMap<Key, T>::iterator QMap<Key, T>::erase(iterator it)
+{
+    if (it == iterator(d->end()))
+        return it;
+
+    do { } while ((false) && (isValidIterator(const_iterator(it))));
+
+    if (d->ref.isShared()) {
+        const_iterator oldBegin = constBegin();
+        const_iterator old = const_iterator(it);
+        int backStepsWithSameKey = 0;
+
+        while (old != oldBegin) {
+            --old;
+            if (qMapLessThanKey(old.key(), it.key()))
+                break;
+            ++backStepsWithSameKey;
+        }
+
+        it = find(old.key());
+        do { } while ((false) && (it != iterator(d->end())));
+
+        while (backStepsWithSameKey > 0) {
+            ++it;
+            --backStepsWithSameKey;
+        }
+    }
+
+    Node *n = it.i;
+    ++it;
+    d->deleteNode(n);
+    return it;
+}
+
+template <class Key, class T>
+ void QMap<Key, T>::detach_helper()
+{
+    QMapData<Key, T> *x = QMapData<Key, T>::create();
+    if (d->header.left) {
+        x->header.left = static_cast<Node *>(d->header.left)->copy(x);
+        x->header.left->setParent(&x->header);
+    }
+    if (!d->ref.deref())
+        d->destroy();
+    d = x;
+    d->recalcMostLeftNode();
+}
+
+template <class Key, class T>
+ QList<Key> QMap<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 (!qMapLessThanKey(aKey, i.key()));
+        }
+    }
+break_out_of_outer_loop:
+    return res;
+}
+
+template <class Key, class T>
+ QList<Key> QMap<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> QMap<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 QMap<Key, T>::key(const T &avalue, const Key &defaultKey) const
+{
+    const_iterator i = begin();
+    while (i != end()) {
+        if (i.value() == avalue)
+            return i.key();
+        ++i;
+    }
+
+    return defaultKey;
+}
+
+template <class Key, class T>
+ QList<T> QMap<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> QMap<Key, T>::values(const Key &akey) const
+{
+    QList<T> res;
+    Node *n = d->findNode(akey);
+    if (n) {
+        const_iterator it(n);
+        do {
+            res.append(*it);
+            ++it;
+        } while (it != constEnd() && !qMapLessThanKey<Key>(akey, it.key()));
+    }
+    return res;
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator QMap<Key, T>::lowerBound(const Key &akey) const
+{
+    Node *lb = d->root() ? d->root()->lowerBound(akey) : nullptr;
+    if (!lb)
+        lb = d->end();
+    return const_iterator(lb);
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::lowerBound(const Key &akey)
+{
+    detach();
+    Node *lb = d->root() ? d->root()->lowerBound(akey) : nullptr;
+    if (!lb)
+        lb = d->end();
+    return iterator(lb);
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator
+QMap<Key, T>::upperBound(const Key &akey) const
+{
+    Node *ub = d->root() ? d->root()->upperBound(akey) : nullptr;
+    if (!ub)
+        ub = d->end();
+    return const_iterator(ub);
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::upperBound(const Key &akey)
+{
+    detach();
+    Node *ub = d->root() ? d->root()->upperBound(akey) : nullptr;
+    if (!ub)
+        ub = d->end();
+    return iterator(ub);
+}
+
+template <class Key, class T>
+ bool QMap<Key, T>::operator==(const QMap<Key, T> &other) const
+{
+    if (size() != other.size())
+        return false;
+    if (d == other.d)
+        return true;
+
+    const_iterator it1 = begin();
+    const_iterator it2 = other.begin();
+
+    while (it1 != end()) {
+        if (!(it1.value() == it2.value()) || qMapLessThanKey(it1.key(), it2.key()) || qMapLessThanKey(it2.key(), it1.key()))
+            return false;
+        ++it2;
+        ++it1;
+    }
+    return true;
+}
+
+template <class Key, class T>
+ QMap<Key, T>::QMap(const std::map<Key, T> &other)
+{
+    d = QMapData<Key, T>::create();
+    typename std::map<Key,T>::const_iterator it = other.end();
+    while (it != other.begin()) {
+        --it;
+        d->createNode((*it).first, (*it).second, d->begin(), true);
+    }
+}
+
+template <class Key, class T>
+ std::map<Key, T> QMap<Key, T>::toStdMap() const
+{
+    std::map<Key, T> map;
+    const_iterator it = end();
+    while (it != begin()) {
+        --it;
+        map.insert(map.begin(), std::pair<Key, T>(it.key(), it.value()));
+    }
+    return map;
+}
+
+template <class Key, class T>
+class QMultiMap : public QMap<Key, T>
+{
+public:
+    QMultiMap() noexcept {}
+
+    inline QMultiMap(std::initializer_list<std::pair<Key,T> > list)
+    {
+        for (typename std::initializer_list<std::pair<Key,T> >::const_iterator it = list.begin(); it != list.end(); ++it)
+            insert(it->first, it->second);
+    }
+
+    QMultiMap(const QMap<Key, T> &other) : QMap<Key, T>(other) {}
+
+    QMultiMap(QMap<Key, T> &&other) noexcept : QMap<Key, T>(std::move(other)) {}
+
+    void swap(QMultiMap<Key, T> &other) noexcept { QMap<Key, T>::swap(other); }
+
+    inline typename QMap<Key, T>::iterator replace(const Key &key, const T &value)
+    { return QMap<Key, T>::insert(key, value); }
+    inline typename QMap<Key, T>::iterator insert(const Key &key, const T &value)
+    { return QMap<Key, T>::insertMulti(key, value); }
+    inline typename QMap<Key, T>::iterator insert(typename QMap<Key, T>::const_iterator pos, const Key &key, const T &value)
+    { return QMap<Key, T>::insertMulti(pos, key, value); }
+
+    inline QMultiMap &operator+=(const QMultiMap &other)
+    { this->unite(other); return *this; }
+    inline QMultiMap operator+(const QMultiMap &other) const
+    { QMultiMap result = *this; result += other; return result; }
+
+    using QMap<Key, T>::contains;
+    using QMap<Key, T>::remove;
+    using QMap<Key, T>::count;
+    using QMap<Key, T>::find;
+    using QMap<Key, T>::constFind;
+
+    bool contains(const Key &key, const T &value) const;
+
+    int remove(const Key &key, const T &value);
+
+    int count(const Key &key, const T &value) const;
+
+    typename QMap<Key, T>::iterator find(const Key &key, const T &value) {
+        typename QMap<Key, T>::iterator i(find(key));
+        typename QMap<Key, T>::iterator end(this->end());
+        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QMap<Key, T>::const_iterator find(const Key &key, const T &value) const {
+        typename QMap<Key, T>::const_iterator i(constFind(key));
+        typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
+        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QMap<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 QMultiMap<Key, T>::contains(const Key &key, const T &value) const
+{
+    return constFind(key, value) != QMap<Key, T>::constEnd();
+}
+
+template <class Key, class T>
+inline int QMultiMap<Key, T>::remove(const Key &key, const T &value)
+{
+    int n = 0;
+    typename QMap<Key, T>::iterator i(find(key));
+    typename QMap<Key, T>::iterator end(QMap<Key, T>::end());
+    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+        if (i.value() == value) {
+            i = this->erase(i);
+            ++n;
+        } else {
+            ++i;
+        }
+    }
+    return n;
+}
+
+template <class Key, class T>
+inline int QMultiMap<Key, T>::count(const Key &key, const T &value) const
+{
+    int n = 0;
+    typename QMap<Key, T>::const_iterator i(constFind(key));
+    typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
+    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+        if (i.value() == value)
+            ++n;
+        ++i;
+    }
+    return n;
+}
+
+template <class Key, class T> class QMapIterator { typedef typename QMap<Key,T>::const_iterator const_iterator; typedef const_iterator Item; QMap<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QMapIterator(const QMap<Key,T> &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QMapIterator &operator=(const QMap<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 { do { } while ((false) && (item_exists())); return *n; } inline const Key &key() const { do { } while ((false) && (item_exists())); 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 QMutableMapIterator { typedef typename QMap<Key,T>::iterator iterator; typedef typename QMap<Key,T>::const_iterator const_iterator; typedef iterator Item; QMap<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableMapIterator(QMap<Key,T> &container) : c(&container) { i = c->begin(); n = c->end(); } inline QMutableMapIterator &operator=(QMap<Key,T> &container) { c = &container; 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() { do { } while ((false) && (item_exists())); return *n; } inline const T &value() const { do { } while ((false) && (item_exists())); return *n; } inline const Key &key() const { do { } while ((false) && (item_exists())); 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 "../../include/QtCore/qmap.h" 2
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+# 1 "../../include/QtCore/qhash.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhash.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhash.h"
+# 1 "../../include/QtCore/qchar.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhash.h" 2
+# 1 "../../include/QtCore/qiterator.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhash.h" 2
+# 1 "../../include/QtCore/qlist.h" 1
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhash.h" 2
+# 1 "../../include/QtCore/qrefcount.h" 1
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhash.h" 2
+# 1 "../../include/QtCore/qhashfunctions.h" 1
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhash.h" 2
+# 60 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhash.h"
+
+
+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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QHashDummyValue)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QHashDummyValue >::value, 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;
+    const uint h;
+    const 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) const { return h0 == h && key0 == key; }
+
+private:
+    QHashNode(const QHashNode &) = delete; QHashNode &operator=(const QHashNode &) = delete;
+};
+
+
+template <class Key>
+struct QHashNode<Key, QHashDummyValue>
+{
+    union {
+        QHashNode *next;
+        QHashDummyValue value;
+    };
+    const uint h;
+    const Key key;
+
+    inline QHashNode(const Key &key0, const QHashDummyValue &, uint hash, QHashNode *n)
+        : next(n), h(hash), key(key0) {}
+    inline bool same_key(uint h0, const Key &key0) const { return h0 == h && key0 == key; }
+
+private:
+    QHashNode(const QHashNode &) = delete; QHashNode &operator=(const QHashNode &) = delete;
+};
+# 224 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qhash.h"
+template <class Key, class T>
+class QHash
+{
+    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)); }
+
+public:
+    inline QHash() noexcept : d(const_cast<QHashData *>(&QHashData::shared_null)) { }
+
+    inline QHash(std::initializer_list<std::pair<Key,T> > list)
+        : d(const_cast<QHashData *>(&QHashData::shared_null))
+    {
+        reserve(int(list.size()));
+        for (typename std::initializer_list<std::pair<Key,T> >::const_iterator it = list.begin(); it != list.end(); ++it)
+            insert(it->first, it->second);
+    }
+
+    QHash(const QHash &other) : d(other.d) { d->ref.ref(); if (!d->sharable) detach(); }
+    ~QHash() { if (!d->ref.deref()) freeData(d); }
+
+    QHash &operator=(const QHash &other);
+
+    QHash(QHash &&other) noexcept : d(other.d) { other.d = const_cast<QHashData *>(&QHashData::shared_null); }
+    QHash &operator=(QHash &&other) noexcept
+    { QHash moved(std::move(other)); swap(moved); return *this; }
+
+    void swap(QHash &other) noexcept { qSwap(d, other.d); }
+
+    bool operator==(const QHash &other) const;
+    bool operator!=(const QHash &other) const { return !(*this == other); }
+
+    inline int size() const { return d->size; }
+
+    inline bool isEmpty() const { return d->size == 0; }
+
+    inline int capacity() const { return d->numBuckets; }
+    void reserve(int size);
+    inline void squeeze() { reserve(1); }
+
+    inline void detach() { if (d->ref.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; }
+
+    bool isSharedWith(const QHash &other) const { return d == other.d; }
+
+    void clear();
+
+    int remove(const Key &key);
+    T take(const Key &key);
+
+    bool contains(const Key &key) const;
+    const Key key(const T &value) const;
+    const Key key(const T &value, const Key &defaultKey) const;
+    const T value(const Key &key) const;
+    const T value(const Key &key, const T &defaultValue) const;
+    T &operator[](const Key &key);
+    const T operator[](const Key &key) const;
+
+    QList<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>;
+        friend class QSet<Key>;
+        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(nullptr) { }
+        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;
+        friend class QHash<Key, T>;
+        friend class QSet<Key>;
+        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(nullptr) { }
+        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;
+
+    class key_iterator
+    {
+        const_iterator i;
+
+    public:
+        typedef typename const_iterator::iterator_category iterator_category;
+        typedef typename const_iterator::difference_type difference_type;
+        typedef Key value_type;
+        typedef const Key *pointer;
+        typedef const Key &reference;
+
+        explicit key_iterator(const_iterator o) : i(o) { }
+
+        const Key &operator*() const { return i.key(); }
+        const Key *operator->() const { return &i.key(); }
+        bool operator==(key_iterator o) const { return i == o.i; }
+        bool operator!=(key_iterator o) const { return i != o.i; }
+
+        inline key_iterator &operator++() { ++i; return *this; }
+        inline key_iterator operator++(int) { return key_iterator(i++);}
+        inline key_iterator &operator--() { --i; return *this; }
+        inline key_iterator operator--(int) { return key_iterator(i--); }
+        const_iterator base() const { return i; }
+    };
+
+
+    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); }
+    inline key_iterator keyBegin() const { return key_iterator(begin()); }
+    inline key_iterator keyEnd() const { return key_iterator(end()); }
+
+    QPair<iterator, iterator> equal_range(const Key &key);
+    QPair<const_iterator, const_iterator> equal_range(const Key &key) const noexcept;
+    iterator erase(iterator it) { return erase(const_iterator(it.i)); }
+    iterator erase(const_iterator it);
+
+
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return d->size; }
+    iterator find(const Key &key);
+    const_iterator find(const Key &key) const;
+    const_iterator constFind(const Key &key) const;
+    iterator insert(const Key &key, const T &value);
+    iterator insertMulti(const Key &key, const T &value);
+    QHash &unite(const QHash &other);
+
+
+    typedef T mapped_type;
+    typedef Key key_type;
+    typedef qptrdiff difference_type;
+    typedef int size_type;
+
+    inline bool empty() const { return isEmpty(); }
+
+
+
+
+
+
+private:
+    void detach_helper();
+    void freeData(QHashData *d);
+    Node **findNode(const Key &key, uint *hp = nullptr) const;
+    Node **findNode(const Key &key, uint h) 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);
+
+    bool isValidIterator(const iterator &it) const noexcept
+    { return isValidNode(it.i); }
+    bool isValidIterator(const const_iterator &it) const noexcept
+    { return isValidNode(it.i); }
+    bool isValidNode(QHashData::Node *node) const noexcept
+    {
+
+
+
+
+
+        (void)node;;
+        return true;
+
+    }
+    friend class QSet<Key>;
+};
+
+
+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);
+    new (newNode) Node(concreteNode->key, concreteNode->value, concreteNode->h, nullptr);
+}
+
+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 = 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 &other)
+{
+    QHash 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();
+}
+
+template <class Key, class T>
+ void QHash<Key, T>::detach_helper()
+{
+    QHashData *x = d->detach_helper(duplicateNode, deleteNode2, sizeof(Node), alignOfNode());
+    if (!d->ref.deref())
+        freeData(d);
+    d = x;
+}
+
+template <class Key, class T>
+inline QHash<Key, T> &QHash<Key, T>::operator=(const QHash &other)
+{
+    if (d != other.d) {
+        QHashData *o = other.d;
+        o->ref.ref();
+        if (!d->ref.deref())
+            freeData(d);
+        d = o;
+        if (!d->sharable)
+            detach_helper();
+    }
+    return *this;
+}
+
+template <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 (!QtPrivate::is_same<T, QHashDummyValue>::value)
+        (*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(const_iterator it)
+{
+    do { } while ((false) && (isValidIterator(it)));
+
+    if (it == const_iterator(e))
+        return iterator(it.i);
+
+    if (d->ref.isShared()) {
+
+        int bucketNum = (it.i->h % d->numBuckets);
+        const_iterator bucketIterator(*(d->buckets + bucketNum));
+        int stepsFromBucketStartToIte = 0;
+        while (bucketIterator != it) {
+            ++stepsFromBucketStartToIte;
+            ++bucketIterator;
+        }
+        detach();
+        it = const_iterator(*(d->buckets + bucketNum));
+        while (stepsFromBucketStartToIte > 0) {
+            --stepsFromBucketStartToIte;
+            ++it;
+        }
+    }
+
+    iterator ret(it.i);
+    ++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 h) const
+{
+    Node **node;
+
+    if (d->numBuckets) {
+        node = reinterpret_cast<Node **>(&d->buckets[h % d->numBuckets]);
+        do { } while ((false) && (*node == e || (*node)->next));
+        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>
+ typename QHash<Key, T>::Node **QHash<Key, T>::findNode(const Key &akey,
+                                                                            uint *ahp) const
+{
+    uint h = 0;
+
+    if (d->numBuckets || ahp) {
+        h = qHash(akey, d->seed);
+        if (ahp)
+            *ahp = h;
+    }
+    return findNode(akey, h);
+}
+
+template <class Key, class T>
+ bool QHash<Key, T>::operator==(const QHash &other) const
+{
+    if (size() != other.size())
+        return false;
+    if (d == other.d)
+        return true;
+
+    const_iterator it = begin();
+
+    while (it != end()) {
+        const Key &akey = it.key();
+
+        const_iterator it2 = other.find(akey);
+        do {
+            if (it2 == other.end() || !(it2.key() == akey))
+                return false;
+            if (!(it.value() == it2.value()))
+                return false;
+            ++it;
+            ++it2;
+        } while (it != end() && it.key() == akey);
+    }
+    return true;
+}
+
+template <class Key, class T>
+QPair<typename QHash<Key, T>::iterator, typename QHash<Key, T>::iterator> QHash<Key, T>::equal_range(const Key &akey)
+{
+    detach();
+    auto pair = qAsConst(*this).equal_range(akey);
+    return qMakePair(iterator(pair.first.i), iterator(pair.second.i));
+}
+
+template <class Key, class T>
+QPair<typename QHash<Key, T>::const_iterator, typename QHash<Key, T>::const_iterator> QHash<Key, T>::equal_range(const Key &akey) const noexcept
+{
+    uint h;
+    Node *node = *findNode(akey, &h);
+    const_iterator firstIt = const_iterator(node);
+
+    if (node != e) {
+
+
+
+
+        while (node->next != e && node->next->key == akey)
+            node = node->next;
+
+
+
+
+
+        node = concrete(QHashData::nextNode(reinterpret_cast<QHashData::Node *>(node)));
+    }
+
+    return qMakePair(firstIt, const_iterator(node));
+}
+
+template <class Key, class T>
+class QMultiHash : public QHash<Key, T>
+{
+public:
+    QMultiHash() noexcept {}
+
+    inline QMultiHash(std::initializer_list<std::pair<Key,T> > list)
+    {
+        this->reserve(int(list.size()));
+        for (typename std::initializer_list<std::pair<Key,T> >::const_iterator it = list.begin(); it != list.end(); ++it)
+            insert(it->first, it->second);
+    }
+
+
+
+
+    QMultiHash(const QHash<Key, T> &other) : QHash<Key, T>(other) {}
+
+    QMultiHash(QHash<Key, T> &&other) noexcept : QHash<Key, T>(std::move(other)) {}
+
+    void swap(QMultiHash &other) noexcept { 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;
+
+    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;
+}
+
+__attribute__((visibility("default"))) int qGlobalQHashSeed();
+__attribute__((visibility("default"))) void qSetGlobalQHashSeed(int newSeed);
+
+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 { do { } while ((false) && (item_exists())); return *n; } inline const Key &key() const { do { } while ((false) && (item_exists())); 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) { i = c->begin(); n = c->end(); } inline QMutableHashIterator &operator=(QHash<Key,T> &container) { c = &container; 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() { do { } while ((false) && (item_exists())); return *n; } inline const T &value() const { do { } while ((false) && (item_exists())); return *n; } inline const Key &key() const { do { } while ((false) && (item_exists())); 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 "../../include/QtCore/qhash.h" 2
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+# 1 "../../include/QtCore/qstring.h" 1
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+# 1 "../../include/QtCore/qstringlist.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h"
+# 1 "../../include/QtCore/qlist.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 2
+# 1 "../../include/QtCore/qstringlist.h" 2
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+# 1 "../../include/QtCore/qobject.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h"
+# 1 "../../include/QtCore/qobjectdefs.h" 1
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h" 2
+# 1 "../../include/QtCore/qstring.h" 1
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h" 2
+# 1 "../../include/QtCore/qbytearray.h" 1
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h" 2
+# 1 "../../include/QtCore/qlist.h" 1
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h" 2
+
+
+
+# 1 "../../include/QtCore/qscopedpointer.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qscopedpointer.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qscopedpointer.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../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>
+struct QScopedPointerObjectDeleteLater
+{
+    static inline void cleanup(T *pointer) { if (pointer) pointer->deleteLater(); }
+};
+
+class QObject;
+typedef QScopedPointerObjectDeleteLater<QObject> QScopedPointerDeleteLater;
+
+
+template <typename T, typename Cleanup = QScopedPointerDeleter<T> >
+class QScopedPointer
+{
+    typedef T *QScopedPointer:: *RestrictedBool;
+public:
+    explicit inline QScopedPointer(T *p = nullptr) : d(p)
+    {
+    }
+
+    inline ~QScopedPointer()
+    {
+        T *oldD = this->d;
+        Cleanup::cleanup(oldD);
+    }
+
+    inline T &operator*() const
+    {
+        do { } while ((false) && (d));
+        return *d;
+    }
+
+    inline T *operator->() const
+    {
+        do { } while ((false) && (d));
+        return d;
+    }
+
+    inline bool operator!() const
+    {
+        return !d;
+    }
+
+
+
+
+
+
+
+    inline operator RestrictedBool() const
+    {
+        return isNull() ? nullptr : &QScopedPointer::d;
+    }
+
+
+    inline T *data() const
+    {
+        return d;
+    }
+
+    inline bool isNull() const
+    {
+        return !d;
+    }
+
+    inline void reset(T *other = nullptr)
+    {
+        if (d == other)
+            return;
+        T *oldD = d;
+        d = other;
+        Cleanup::cleanup(oldD);
+    }
+
+    inline T *take()
+    {
+        T *oldD = d;
+        d = nullptr;
+        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>(nullptr) {}
+
+    template <typename D>
+    explicit inline QScopedArrayPointer(D *p, typename QtPrivate::QScopedArrayEnsureSameType<T,D>::Type = nullptr)
+        : 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 *) {
+# 243 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qscopedpointer.h"
+    }
+
+    QScopedArrayPointer(const QScopedArrayPointer &) = delete; QScopedArrayPointer &operator=(const QScopedArrayPointer &) = delete;
+};
+
+
+# 1 "../../include/QtCore/qscopedpointer.h" 2
+# 54 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h" 2
+# 1 "../../include/QtCore/qmetatype.h" 1
+# 55 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h" 2
+
+# 1 "../../include/QtCore/qobject_impl.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject_impl.h" 1
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject_impl.h"
+
+
+
+namespace QtPrivate {
+# 93 "../../include/QtCore/../../../../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 nullptr; } };
+    template <> struct ConnectionTypes<List<>, true>
+    { static const int *types() { return nullptr; } };
+    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; } };
+
+
+
+    class QSlotObjectBase {
+        QAtomicInt m_ref;
+
+
+
+        typedef void (*ImplFn)(int which, QSlotObjectBase* this_, QObject *receiver, void **args, bool *ret);
+        const ImplFn m_impl;
+    protected:
+        enum Operation {
+            Destroy,
+            Call,
+            Compare,
+
+            NumOperations
+        };
+    public:
+        explicit QSlotObjectBase(ImplFn fn) : m_ref(1), m_impl(fn) {}
+
+        inline int ref() noexcept { return m_ref.ref(); }
+        inline void destroyIfLastRef() noexcept
+        { if (!m_ref.deref()) m_impl(Destroy, this, nullptr, nullptr, nullptr); }
+
+        inline bool compare(void **a) { bool ret; m_impl(Compare, this, nullptr, a, &ret); return ret; }
+        inline void call(QObject *r, void **a) { m_impl(Call, this, r, a, nullptr); }
+    protected:
+        ~QSlotObjectBase() {}
+    private:
+        QSlotObjectBase(const QSlotObjectBase &) = delete; QSlotObjectBase &operator=(const QSlotObjectBase &) = delete;
+    };
+
+
+    template<typename Func, typename Args, typename R> class QSlotObject : public QSlotObjectBase
+    {
+        typedef QtPrivate::FunctionPointer<Func> FuncType;
+        Func function;
+        static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret)
+        {
+            switch (which) {
+            case Destroy:
+                delete static_cast<QSlotObject*>(this_);
+                break;
+            case Call:
+                FuncType::template call<Args, R>(static_cast<QSlotObject*>(this_)->function, static_cast<typename FuncType::Object *>(r), a);
+                break;
+            case Compare:
+                *ret = *reinterpret_cast<Func *>(a) == static_cast<QSlotObject*>(this_)->function;
+                break;
+            case NumOperations: ;
+            }
+        }
+    public:
+        explicit QSlotObject(Func f) : QSlotObjectBase(&impl), function(f) {}
+    };
+
+
+    template<typename Func, typename Args, typename R> class QStaticSlotObject : public QSlotObjectBase
+    {
+        typedef QtPrivate::FunctionPointer<Func> FuncType;
+        Func function;
+        static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret)
+        {
+            switch (which) {
+            case Destroy:
+                delete static_cast<QStaticSlotObject*>(this_);
+                break;
+            case Call:
+                FuncType::template call<Args, R>(static_cast<QStaticSlotObject*>(this_)->function, r, a);
+                break;
+            case Compare:
+                *ret = false;
+                break;
+            case NumOperations: ;
+            }
+        }
+    public:
+        explicit QStaticSlotObject(Func f) : QSlotObjectBase(&impl), function(f) {}
+    };
+
+
+
+    template<typename Func, int N, typename Args, typename R> class QFunctorSlotObject : public QSlotObjectBase
+    {
+        typedef QtPrivate::Functor<Func, N> FuncType;
+        Func function;
+        static void impl(int which, QSlotObjectBase *this_, QObject *r, void **a, bool *ret)
+        {
+            switch (which) {
+            case Destroy:
+                delete static_cast<QFunctorSlotObject*>(this_);
+                break;
+            case Call:
+                FuncType::template call<Args, R>(static_cast<QFunctorSlotObject*>(this_)->function, r, a);
+                break;
+            case Compare:
+                *ret = false;
+                break;
+            case NumOperations: ;
+            }
+        }
+    public:
+        explicit QFunctorSlotObject(const Func &f) : QSlotObjectBase(&impl), function(f) {}
+    };
+}
+
+
+
+# 1 "../../include/QtCore/qobject_impl.h" 2
+# 57 "../../include/QtCore/../../../../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 ThisObject> inline void qt_check_for_QOBJECT_macro(const ThisObject &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; }
+# 114 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h"
+#pragma GCC diagnostic push
+# 114 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h"
+    static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); virtual int qt_metacall(QMetaObject::Call, int, void **); static inline QString tr(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } __attribute__ ((__deprecated__)) static inline QString trUtf8(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } private: __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+# 114 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h"
+#pragma GCC diagnostic pop
+# 114 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h"
+    struct QPrivateSignal {};
+   
+    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=nullptr);
+    virtual ~QObject();
+
+    virtual bool event(QEvent *event);
+    virtual bool eventFilter(QObject *watched, QEvent *event);
+# 140 "../../include/QtCore/../../../../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 noexcept { return d_ptr->blockSig; }
+    bool blockSignals(bool b) noexcept;
+
+    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
+    {
+        typedef typename QtPrivate::remove_cv<typename QtPrivate::remove_pointer<T>::type>::type ObjType;
+        return static_cast<T>(qt_qFindChild_helper(this, aName, ObjType::staticMetaObject, options));
+    }
+
+    template<typename T>
+    inline QList<T> findChildren(const QString &aName = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
+    {
+        typedef typename QtPrivate::remove_cv<typename QtPrivate::remove_pointer<T>::type>::type ObjType;
+        QList<T> list;
+        qt_qFindChildren_helper(this, aName, ObjType::staticMetaObject,
+                                reinterpret_cast<QList<void *> *>(&list), options);
+        return list;
+    }
+
+
+    template<typename T>
+    inline QList<T> findChildren(const QRegExp &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
+    {
+        typedef typename QtPrivate::remove_cv<typename QtPrivate::remove_pointer<T>::type>::type ObjType;
+        QList<T> list;
+        qt_qFindChildren_helper(this, re, ObjType::staticMetaObject,
+                                reinterpret_cast<QList<void *> *>(&list), options);
+        return list;
+    }
+
+
+
+    template<typename T>
+    inline QList<T> findChildren(const QRegularExpression &re, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const
+    {
+        typedef typename QtPrivate::remove_cv<typename QtPrivate::remove_pointer<T>::type>::type ObjType;
+        QList<T> list;
+        qt_qFindChildren_helper(this, re, ObjType::staticMetaObject,
+                                reinterpret_cast<QList<void *> *>(&list), options);
+        return list;
+    }
+
+
+    inline const QObjectList &children() const { return d_ptr->children; }
+
+    void setParent(QObject *parent);
+    void installEventFilter(QObject *filterObj);
+    void removeEventFilter(QObject *obj);
+
+    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;
+
+        static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value), "No Q_OBJECT in the class with the signal")
+                                                                     ;
+
+
+        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 = nullptr;
+        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 QtPrivate::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)
+    {
+        return connect(sender, signal, sender, slot, Qt::DirectConnection);
+    }
+
+
+    template <typename Func1, typename Func2>
+    static inline typename QtPrivate::QEnableIf<int(QtPrivate::FunctionPointer<Func2>::ArgumentCount) >= 0 &&
+                                                !QtPrivate::FunctionPointer<Func2>::IsPointerToMemberFunction, QMetaObject::Connection>::Type
+            connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, const QObject *context, Func2 slot,
+                    Qt::ConnectionType type = Qt::AutoConnection)
+    {
+        typedef QtPrivate::FunctionPointer<Func1> SignalType;
+        typedef QtPrivate::FunctionPointer<Func2> SlotType;
+
+        static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value), "No Q_OBJECT in the class with the signal")
+                                                                     ;
+
+
+        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 = nullptr;
+        if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
+            types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types();
+
+        return connectImpl(sender, reinterpret_cast<void **>(&signal), context, nullptr,
+                           new QtPrivate::QStaticSlotObject<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<QtPrivate::FunctionPointer<Func2>::ArgumentCount == -1, QMetaObject::Connection>::Type
+            connect(const typename QtPrivate::FunctionPointer<Func1>::Object *sender, Func1 signal, Func2 slot)
+    {
+        return connect(sender, signal, sender, slot, Qt::DirectConnection);
+    }
+
+
+    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, const QObject *context, Func2 slot,
+                    Qt::ConnectionType type = Qt::AutoConnection)
+    {
+
+        typedef QtPrivate::FunctionPointer<Func1> SignalType;
+        const int FunctorArgumentCount = QtPrivate::ComputeFunctorArgumentCount<Func2 , typename SignalType::Arguments>::Value;
+
+        static_assert(bool((FunctorArgumentCount >= 0)), "Signal and slot arguments are not compatible.")
+                                                                          ;
+        const int SlotArgumentCount = (FunctorArgumentCount >= 0) ? FunctorArgumentCount : 0;
+        typedef typename QtPrivate::FunctorReturnType<Func2, typename QtPrivate::List_Left<typename SignalType::Arguments, SlotArgumentCount>::Value>::Value SlotReturnType;
+# 333 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h"
+        static_assert(bool((QtPrivate::AreArgumentsCompatible<SlotReturnType, typename SignalType::ReturnType>::value)), "Return type of the slot is not compatible with the return type of the signal.")
+                                                                                                          ;
+
+        static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value), "No Q_OBJECT in the class with the signal")
+                                                                     ;
+
+        const int *types = nullptr;
+        if (type == Qt::QueuedConnection || type == Qt::BlockingQueuedConnection)
+            types = QtPrivate::ConnectionTypes<typename SignalType::Arguments>::types();
+
+        return connectImpl(sender, reinterpret_cast<void **>(&signal), context, nullptr,
+                           new QtPrivate::QFunctorSlotObject<Func2, SlotArgumentCount,
+                                typename QtPrivate::List_Left<typename SignalType::Arguments, SlotArgumentCount>::Value,
+                                typename SignalType::ReturnType>(slot),
+                           type, types, &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 = nullptr,
+                           const QObject *receiver = nullptr, const char *member = nullptr) const
+        { return disconnect(this, signal, receiver, member); }
+    inline bool disconnect(const QObject *receiver, const char *member = nullptr) const
+        { return disconnect(this, nullptr, 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;
+
+        static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<typename SignalType::Object>::Value), "No Q_OBJECT in the class with the signal")
+                                                                     ;
+
+
+        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)
+    {
+
+
+
+        do { } while ((false) && (!zero));
+        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 * = nullptr);
+    void objectNameChanged(const QString &objectName, QPrivateSignal);
+
+public:
+    inline QObject *parent() const { return d_ptr->parent; }
+
+    inline bool inherits(const char *classname) const
+        { return const_cast<QObject *>(this)->qt_metacast(classname) != nullptr; }
+
+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 *event);
+    virtual void childEvent(QChildEvent *event);
+    virtual void customEvent(QEvent *event);
+
+    virtual void connectNotify(const QMetaMethod &signal);
+    virtual void disconnectNotify(const QMetaMethod &signal);
+
+protected:
+    QObject(QObjectPrivate &dd, QObject *parent = nullptr);
+
+protected:
+    QScopedPointer<QObjectData> d_ptr;
+
+    static const QMetaObject staticQtMetaObject;
+    friend inline const QMetaObject *qt_getQtMetaObject() noexcept
+    { return &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:
+    static QMetaObject::Connection connectImpl(const QObject *sender, void **signal,
+                                               const QObject *receiver, void **slotPtr,
+                                               QtPrivate::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();
+};
+# 510 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h"
+template <class T>
+inline T qobject_cast(QObject *object)
+{
+    typedef typename QtPrivate::remove_cv<typename QtPrivate::remove_pointer<T>::type>::type ObjType;
+    static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<ObjType>::Value), "qobject_cast requires the type to have a Q_OBJECT macro")
+                                                                              ;
+    return static_cast<T>(ObjType::staticMetaObject.cast(object));
+}
+
+template <class T>
+inline T qobject_cast(const QObject *object)
+{
+    typedef typename QtPrivate::remove_cv<typename QtPrivate::remove_pointer<T>::type>::type ObjType;
+    static_assert(bool(QtPrivate::HasQ_OBJECT_Macro<ObjType>::Value), "qobject_cast requires the type to have a Q_OBJECT macro")
+                                                                                ;
+    return static_cast<T>(ObjType::staticMetaObject.cast(object));
+}
+
+
+template <class T> inline const char * qobject_interface_iid()
+{ return nullptr; }
+# 543 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qobject.h"
+__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QObject *);
+
+
+class QSignalBlocker
+{
+public:
+    inline explicit QSignalBlocker(QObject *o) noexcept;
+    inline explicit QSignalBlocker(QObject &o) noexcept;
+    inline ~QSignalBlocker();
+
+
+    inline QSignalBlocker(QSignalBlocker &&other) noexcept;
+    inline QSignalBlocker &operator=(QSignalBlocker &&other) noexcept;
+
+
+    inline void reblock() noexcept;
+    inline void unblock() noexcept;
+private:
+    QSignalBlocker(const QSignalBlocker &) = delete; QSignalBlocker &operator=(const QSignalBlocker &) = delete;
+    QObject * m_o;
+    bool m_blocked;
+    bool m_inhibited;
+};
+
+QSignalBlocker::QSignalBlocker(QObject *o) noexcept
+    : m_o(o),
+      m_blocked(o && o->blockSignals(true)),
+      m_inhibited(false)
+{}
+
+QSignalBlocker::QSignalBlocker(QObject &o) noexcept
+    : m_o(&o),
+      m_blocked(o.blockSignals(true)),
+      m_inhibited(false)
+{}
+
+
+QSignalBlocker::QSignalBlocker(QSignalBlocker &&other) noexcept
+    : m_o(other.m_o),
+      m_blocked(other.m_blocked),
+      m_inhibited(other.m_inhibited)
+{
+    other.m_o = nullptr;
+}
+
+QSignalBlocker &QSignalBlocker::operator=(QSignalBlocker &&other) noexcept
+{
+    if (this != &other) {
+
+
+        if (m_o != other.m_o || (!m_inhibited && other.m_inhibited))
+            unblock();
+        m_o = other.m_o;
+        m_blocked = other.m_blocked;
+        m_inhibited = other.m_inhibited;
+
+        other.m_o = nullptr;
+    }
+    return *this;
+}
+
+
+QSignalBlocker::~QSignalBlocker()
+{
+    if (m_o && !m_inhibited)
+        m_o->blockSignals(m_blocked);
+}
+
+void QSignalBlocker::reblock() noexcept
+{
+    if (m_o) m_o->blockSignals(true);
+    m_inhibited = false;
+}
+
+void QSignalBlocker::unblock() noexcept
+{
+    if (m_o) m_o->blockSignals(m_blocked);
+    m_inhibited = true;
+}
+
+namespace QtPrivate {
+    inline QObject & deref_for_methodcall(QObject &o) { return o; }
+    inline QObject & deref_for_methodcall(QObject *o) { return *o; }
+}
+
+
+
+# 1 "../../include/QtCore/qobject.h" 2
+# 52 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+
+# 1 "../../include/QtCore/qbytearraylist.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearraylist.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearraylist.h"
+# 1 "../../include/QtCore/qlist.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qbytearraylist.h" 2
+# 1 "../../include/QtCore/qbytearraylist.h" 2
+# 54 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h" 2
+
+
+
+
+
+class QBitArray;
+class QDataStream;
+class QDate;
+class QDateTime;
+class QEasingCurve;
+class QLine;
+class QLineF;
+class QLocale;
+class QMatrix;
+class QTransform;
+class QStringList;
+class QTime;
+class QPoint;
+class QPointF;
+class QSize;
+class QSizeF;
+class QRect;
+class QRectF;
+
+class QRegExp;
+
+
+class QRegularExpression;
+
+class QTextFormat;
+class QTextLength;
+class QUrl;
+class QVariant;
+class QVariantComparisonHelper;
+
+template <typename T>
+inline QVariant qVariantFromValue(const T &);
+
+template<typename T>
+inline T qvariant_cast(const QVariant &);
+
+namespace QtPrivate {
+
+    template <typename Derived, typename Argument, typename ReturnType>
+    struct ObjectInvoker
+    {
+        static ReturnType invoke(Argument a)
+        {
+            return Derived::object(a);
+        }
+    };
+
+    template <typename Derived, typename Argument, typename ReturnType>
+    struct MetaTypeInvoker
+    {
+        static ReturnType invoke(Argument a)
+        {
+            return Derived::metaType(a);
+        }
+    };
+
+    template <typename Derived, typename T, typename Argument, typename ReturnType, bool = IsPointerToTypeDerivedFromQObject<T>::Value>
+    struct TreatAsQObjectBeforeMetaType : ObjectInvoker<Derived, Argument, ReturnType>
+    {
+    };
+
+    template <typename Derived, typename T, typename Argument, typename ReturnType>
+    struct TreatAsQObjectBeforeMetaType<Derived, T, Argument, ReturnType, false> : MetaTypeInvoker<Derived, Argument, ReturnType>
+    {
+    };
+
+    template<typename T> struct QVariantValueHelper;
+}
+
+class __attribute__((visibility("default"))) QVariant
+{
+ public:
+    enum Type {
+        Invalid = QMetaType::UnknownType,
+        Bool = QMetaType::Bool,
+        Int = QMetaType::Int,
+        UInt = QMetaType::UInt,
+        LongLong = QMetaType::LongLong,
+        ULongLong = QMetaType::ULongLong,
+        Double = QMetaType::Double,
+        Char = QMetaType::QChar,
+        Map = QMetaType::QVariantMap,
+        List = QMetaType::QVariantList,
+        String = QMetaType::QString,
+        StringList = QMetaType::QStringList,
+        ByteArray = QMetaType::QByteArray,
+        BitArray = QMetaType::QBitArray,
+        Date = QMetaType::QDate,
+        Time = QMetaType::QTime,
+        DateTime = QMetaType::QDateTime,
+        Url = QMetaType::QUrl,
+        Locale = QMetaType::QLocale,
+        Rect = QMetaType::QRect,
+        RectF = QMetaType::QRectF,
+        Size = QMetaType::QSize,
+        SizeF = QMetaType::QSizeF,
+        Line = QMetaType::QLine,
+        LineF = QMetaType::QLineF,
+        Point = QMetaType::QPoint,
+        PointF = QMetaType::QPointF,
+        RegExp = QMetaType::QRegExp,
+        RegularExpression = QMetaType::QRegularExpression,
+        Hash = QMetaType::QVariantHash,
+        EasingCurve = QMetaType::QEasingCurve,
+        Uuid = QMetaType::QUuid,
+        ModelIndex = QMetaType::QModelIndex,
+        PersistentModelIndex = QMetaType::QPersistentModelIndex,
+        LastCoreType = QMetaType::LastCoreType,
+
+        Font = QMetaType::QFont,
+        Pixmap = QMetaType::QPixmap,
+        Brush = QMetaType::QBrush,
+        Color = QMetaType::QColor,
+        Palette = QMetaType::QPalette,
+        Image = QMetaType::QImage,
+        Polygon = QMetaType::QPolygon,
+        Region = QMetaType::QRegion,
+        Bitmap = QMetaType::QBitmap,
+        Cursor = QMetaType::QCursor,
+        KeySequence = QMetaType::QKeySequence,
+        Pen = QMetaType::QPen,
+        TextLength = QMetaType::QTextLength,
+        TextFormat = QMetaType::QTextFormat,
+        Matrix = QMetaType::QMatrix,
+        Transform = QMetaType::QTransform,
+        Matrix4x4 = QMetaType::QMatrix4x4,
+        Vector2D = QMetaType::QVector2D,
+        Vector3D = QMetaType::QVector3D,
+        Vector4D = QMetaType::QVector4D,
+        Quaternion = QMetaType::QQuaternion,
+        PolygonF = QMetaType::QPolygonF,
+        Icon = QMetaType::QIcon,
+        LastGuiType = QMetaType::LastGuiType,
+
+        SizePolicy = QMetaType::QSizePolicy,
+
+        UserType = QMetaType::User,
+        LastType = 0xffffffff
+    };
+
+    QVariant() noexcept : d() {}
+    ~QVariant();
+    QVariant(Type type);
+    QVariant(int typeId, const void *copy);
+    QVariant(int typeId, const void *copy, uint flags);
+    QVariant(const QVariant &other);
+
+
+    QVariant(QDataStream &s);
+
+
+    QVariant(int i);
+    QVariant(uint ui);
+    QVariant(qlonglong ll);
+    QVariant(qulonglong ull);
+    QVariant(bool b);
+    QVariant(double d);
+    QVariant(float f);
+
+    __attribute__ ((__deprecated__)) QVariant(const char *str);
+
+
+    QVariant(const QByteArray &bytearray);
+    QVariant(const QBitArray &bitarray);
+    QVariant(const QString &string);
+    QVariant(QLatin1String string);
+    QVariant(const QStringList &stringlist);
+    QVariant(QChar qchar);
+    QVariant(const QDate &date);
+    QVariant(const QTime &time);
+    QVariant(const QDateTime &datetime);
+    QVariant(const QList<QVariant> &list);
+    QVariant(const QMap<QString,QVariant> &map);
+    QVariant(const QHash<QString,QVariant> &hash);
+
+    QVariant(const QSize &size);
+    QVariant(const QSizeF &size);
+    QVariant(const QPoint &pt);
+    QVariant(const QPointF &pt);
+    QVariant(const QLine &line);
+    QVariant(const QLineF &line);
+    QVariant(const QRect &rect);
+    QVariant(const QRectF &rect);
+
+    QVariant(const QLocale &locale);
+
+    QVariant(const QRegExp &regExp);
+
+
+
+    QVariant(const QRegularExpression &re);
+
+    QVariant(const QUrl &url);
+    QVariant(const QEasingCurve &easing);
+    QVariant(const QUuid &uuid);
+    QVariant(const QModelIndex &modelIndex);
+    QVariant(const QPersistentModelIndex &modelIndex);
+    QVariant(const QJsonValue &jsonValue);
+    QVariant(const QJsonObject &jsonObject);
+    QVariant(const QJsonArray &jsonArray);
+    QVariant(const QJsonDocument &jsonDocument);
+
+
+    QVariant& operator=(const QVariant &other);
+
+    inline QVariant(QVariant &&other) noexcept : d(other.d)
+    { other.d = Private(); }
+    inline QVariant &operator=(QVariant &&other) noexcept
+    { qSwap(d, other.d); return *this; }
+
+
+    inline void swap(QVariant &other) noexcept { qSwap(d, other.d); }
+
+    Type type() const;
+    int userType() const;
+    const char *typeName() const;
+
+    bool canConvert(int targetTypeId) const;
+    bool convert(int targetTypeId);
+
+    inline bool isValid() const;
+    bool isNull() const;
+
+    void clear();
+
+    void detach();
+    inline bool isDetached() const;
+
+    int toInt(bool *ok = nullptr) const;
+    uint toUInt(bool *ok = nullptr) const;
+    qlonglong toLongLong(bool *ok = nullptr) const;
+    qulonglong toULongLong(bool *ok = nullptr) const;
+    bool toBool() const;
+    double toDouble(bool *ok = nullptr) const;
+    float toFloat(bool *ok = nullptr) const;
+    qreal toReal(bool *ok = nullptr) const;
+    QByteArray toByteArray() const;
+    QBitArray toBitArray() const;
+    QString toString() const;
+    QStringList toStringList() const;
+    QChar toChar() const;
+    QDate toDate() const;
+    QTime toTime() const;
+    QDateTime toDateTime() const;
+    QList<QVariant> toList() const;
+    QMap<QString, QVariant> toMap() const;
+    QHash<QString, QVariant> toHash() const;
+
+
+    QPoint toPoint() const;
+    QPointF toPointF() const;
+    QRect toRect() const;
+    QSize toSize() const;
+    QSizeF toSizeF() const;
+    QLine toLine() const;
+    QLineF toLineF() const;
+    QRectF toRectF() const;
+
+    QLocale toLocale() const;
+
+    QRegExp toRegExp() const;
+
+
+
+    QRegularExpression toRegularExpression() const;
+
+    QUrl toUrl() const;
+    QEasingCurve toEasingCurve() const;
+    QUuid toUuid() const;
+    QModelIndex toModelIndex() const;
+    QPersistentModelIndex toPersistentModelIndex() const;
+    QJsonValue toJsonValue() const;
+    QJsonObject toJsonObject() const;
+    QJsonArray toJsonArray() const;
+    QJsonDocument toJsonDocument() const;
+
+
+
+    void load(QDataStream &ds);
+    void save(QDataStream &ds) const;
+
+    static const char *typeToName(int typeId);
+    static Type nameToType(const char *name);
+
+    void *data();
+    const void *constData() const;
+    inline const void *data() const { return constData(); }
+
+    template<typename T>
+    inline void setValue(const T &value);
+
+    template<typename T>
+    inline T value() const
+    { return qvariant_cast<T>(*this); }
+
+    template<typename T>
+    static inline QVariant fromValue(const T &value)
+    { return qVariantFromValue(value); }
+
+    template<typename T>
+    bool canConvert() const
+    { return canConvert(qMetaTypeId<T>()); }
+
+ public:
+
+    struct PrivateShared
+    {
+        inline PrivateShared(void *v) : ptr(v), ref(1) { }
+        void *ptr;
+        QAtomicInt ref;
+    };
+    struct Private
+    {
+        inline Private() noexcept : type(Invalid), is_shared(false), is_null(true)
+        { data.ptr = nullptr; }
+
+
+        explicit inline Private(uint variantType) noexcept
+            : type(variantType), is_shared(false), is_null(false)
+        {}
+
+        inline Private(const Private &other) noexcept
+            : data(other.data), type(other.type),
+              is_shared(other.is_shared), is_null(other.is_null)
+        {}
+        union Data
+        {
+            char c;
+            uchar uc;
+            short s;
+            signed char sc;
+            ushort us;
+            int i;
+            uint u;
+            long l;
+            ulong ul;
+            bool b;
+            double d;
+            float f;
+            qreal real;
+            qlonglong ll;
+            qulonglong ull;
+            QObject *o;
+            void *ptr;
+            PrivateShared *shared;
+        } data;
+        uint type : 30;
+        uint is_shared : 1;
+        uint is_null : 1;
+    };
+ public:
+    typedef void (*f_construct)(Private *, const void *);
+    typedef void (*f_clear)(Private *);
+    typedef bool (*f_null)(const Private *);
+
+    typedef void (*f_load)(Private *, QDataStream &);
+    typedef void (*f_save)(const Private *, QDataStream &);
+
+    typedef bool (*f_compare)(const Private *, const Private *);
+    typedef bool (*f_convert)(const QVariant::Private *d, int t, void *, bool *);
+    typedef bool (*f_canConvert)(const QVariant::Private *d, int t);
+    typedef void (*f_debugStream)(QDebug, const QVariant &);
+    struct Handler {
+        f_construct construct;
+        f_clear clear;
+        f_null isNull;
+
+        f_load load;
+        f_save save;
+
+        f_compare compare;
+        f_convert convert;
+        f_canConvert canConvert;
+        f_debugStream debugStream;
+    };
+
+
+    inline bool operator==(const QVariant &v) const
+    { return cmp(v); }
+    inline bool operator!=(const QVariant &v) const
+    { return !cmp(v); }
+    inline bool operator<(const QVariant &v) const
+    { return compare(v) < 0; }
+    inline bool operator<=(const QVariant &v) const
+    { return compare(v) <= 0; }
+    inline bool operator>(const QVariant &v) const
+    { return compare(v) > 0; }
+    inline bool operator>=(const QVariant &v) const
+    { return compare(v) >= 0; }
+
+protected:
+    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);
+
+    friend __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QVariant &);
+
+
+
+    template<typename T>
+    friend inline T qvariant_cast(const QVariant &);
+    template<typename T> friend struct QtPrivate::QVariantValueHelper;
+protected:
+
+
+
+    Private d;
+    void create(int type, const void *copy);
+    bool cmp(const QVariant &other) const;
+    int compare(const QVariant &other) const;
+    bool convert(const int t, void *ptr) const;
+
+private:
+
+    inline QVariant(void *) = delete;
+
+
+
+
+
+
+    QVariant(QMetaType::Type) = delete;
+
+
+
+
+
+
+    QVariant(Qt::GlobalColor) = delete;
+    QVariant(Qt::BrushStyle) = delete;
+    QVariant(Qt::PenStyle) = delete;
+    QVariant(Qt::CursorShape) = delete;
+
+
+
+
+public:
+    typedef Private DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+    inline const DataPtr &data_ptr() const { return d; }
+};
+
+template <typename T>
+inline QVariant qVariantFromValue(const T &t)
+{
+    return QVariant(qMetaTypeId<T>(), &t, QTypeInfo<T>::isPointer);
+}
+
+template <>
+inline QVariant qVariantFromValue(const QVariant &t) { return t; }
+
+template <typename T>
+inline void qVariantSetValue(QVariant &v, const T &t)
+{
+
+    const uint type = qMetaTypeId<T>();
+    QVariant::Private &d = v.data_ptr();
+    if (v.isDetached() && (type == d.type || (type <= uint(QVariant::Char) && d.type <= uint(QVariant::Char)))) {
+        d.type = type;
+        d.is_null = false;
+        T *old = reinterpret_cast<T*>(d.is_shared ? d.data.shared->ptr : &d.data.ptr);
+        if (QTypeInfo<T>::isComplex)
+            old->~T();
+        new (old) T(t);
+    } else {
+        v = QVariant(type, &t, QTypeInfo<T>::isPointer);
+    }
+}
+
+template <>
+inline void qVariantSetValue<QVariant>(QVariant &v, const QVariant &t)
+{
+    v = t;
+}
+
+inline bool QVariant::isValid() const { return d.type != Invalid; }
+
+template<typename T>
+inline void QVariant::setValue(const T &avalue)
+{ qVariantSetValue(*this, avalue); }
+
+
+__attribute__((visibility("default"))) QDataStream& operator>> (QDataStream& s, QVariant& p);
+__attribute__((visibility("default"))) QDataStream& operator<< (QDataStream& s, const QVariant& p);
+__attribute__((visibility("default"))) QDataStream& operator>> (QDataStream& s, QVariant::Type& p);
+__attribute__((visibility("default"))) QDataStream& operator<< (QDataStream& s, const QVariant::Type p);
+
+
+inline bool QVariant::isDetached() const
+{ return !d.is_shared || d.data.shared->ref.load() == 1; }
+# 557 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h"
+class QVariantComparisonHelper
+{
+public:
+    inline QVariantComparisonHelper(const QVariant &var)
+        : v(&var) {}
+private:
+    friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &);
+    const QVariant *v;
+};
+
+inline bool operator==(const QVariant &v1, const QVariantComparisonHelper &v2)
+{
+    return v1.cmp(*v2.v);
+}
+
+inline bool operator!=(const QVariant &v1, const QVariantComparisonHelper &v2)
+{
+    return !operator==(v1, v2);
+}
+
+template<> class QTypeInfo<QVariant > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QVariant)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QVariant >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QVariant) }; static inline const char *name() { return "QVariant"; } }; inline void swap(QVariant &value1, QVariant &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }
+
+class __attribute__((visibility("default"))) QSequentialIterable
+{
+    QtMetaTypePrivate::QSequentialIterableImpl m_impl;
+public:
+    struct __attribute__((visibility("default"))) const_iterator
+    {
+    private:
+        QtMetaTypePrivate::QSequentialIterableImpl m_impl;
+        QAtomicInt *ref;
+        friend class QSequentialIterable;
+        explicit const_iterator(const QSequentialIterable &iter, QAtomicInt *ref_);
+
+        explicit const_iterator(const QtMetaTypePrivate::QSequentialIterableImpl &impl, QAtomicInt *ref_);
+
+        void begin();
+        void end();
+    public:
+        ~const_iterator();
+
+        const_iterator(const const_iterator &other);
+
+        const_iterator& operator=(const const_iterator &other);
+
+        const QVariant operator*() const;
+        bool operator==(const const_iterator &o) const;
+        bool operator!=(const const_iterator &o) const;
+        const_iterator &operator++();
+        const_iterator operator++(int);
+        const_iterator &operator--();
+        const_iterator operator--(int);
+        const_iterator &operator+=(int j);
+        const_iterator &operator-=(int j);
+        const_iterator operator+(int j) const;
+        const_iterator operator-(int j) const;
+    };
+
+    friend struct const_iterator;
+
+
+    explicit QSequentialIterable(QtMetaTypePrivate::QSequentialIterableImpl impl);
+
+
+
+
+    const_iterator begin() const;
+    const_iterator end() const;
+
+    QVariant at(int idx) const;
+    int size() const;
+
+    bool canReverseIterate() const;
+};
+
+class __attribute__((visibility("default"))) QAssociativeIterable
+{
+    QtMetaTypePrivate::QAssociativeIterableImpl m_impl;
+public:
+    struct __attribute__((visibility("default"))) const_iterator
+    {
+    private:
+        QtMetaTypePrivate::QAssociativeIterableImpl m_impl;
+        QAtomicInt *ref;
+        friend class QAssociativeIterable;
+        explicit const_iterator(const QAssociativeIterable &iter, QAtomicInt *ref_);
+
+        explicit const_iterator(const QtMetaTypePrivate::QAssociativeIterableImpl &impl, QAtomicInt *ref_);
+
+        void begin();
+        void end();
+        void find(const QVariant &key);
+    public:
+        ~const_iterator();
+        const_iterator(const const_iterator &other);
+
+        const_iterator& operator=(const const_iterator &other);
+
+        const QVariant key() const;
+
+        const QVariant value() const;
+
+        const QVariant operator*() const;
+        bool operator==(const const_iterator &o) const;
+        bool operator!=(const const_iterator &o) const;
+        const_iterator &operator++();
+        const_iterator operator++(int);
+        const_iterator &operator--();
+        const_iterator operator--(int);
+        const_iterator &operator+=(int j);
+        const_iterator &operator-=(int j);
+        const_iterator operator+(int j) const;
+        const_iterator operator-(int j) const;
+    };
+
+    friend struct const_iterator;
+
+
+    explicit QAssociativeIterable(QtMetaTypePrivate::QAssociativeIterableImpl impl);
+
+
+
+
+    const_iterator begin() const;
+    const_iterator end() const;
+    const_iterator find(const QVariant &key) const;
+
+    QVariant value(const QVariant &key) const;
+
+    int size() const;
+};
+
+
+namespace QtPrivate {
+    template<typename T>
+    struct QVariantValueHelper : TreatAsQObjectBeforeMetaType<QVariantValueHelper<T>, T, const QVariant &, T>
+    {
+        static T metaType(const QVariant &v)
+        {
+            const int vid = qMetaTypeId<T>();
+            if (vid == v.userType())
+                return *reinterpret_cast<const T *>(v.constData());
+            T t;
+            if (v.convert(vid, &t))
+                return t;
+            return T();
+        }
+
+        static T object(const QVariant &v)
+        {
+            return qobject_cast<T>(QMetaType::typeFlags(v.userType()) & QMetaType::PointerToQObject
+                ? v.d.data.o
+                : QVariantValueHelper::metaType(v));
+        }
+
+    };
+
+    template<typename T>
+    struct QVariantValueHelperInterface : QVariantValueHelper<T>
+    {
+    };
+
+    template<>
+    struct QVariantValueHelperInterface<QSequentialIterable>
+    {
+        static QSequentialIterable invoke(const QVariant &v)
+        {
+            const int typeId = v.userType();
+            if (typeId == qMetaTypeId<QVariantList>()) {
+                return QSequentialIterable(QtMetaTypePrivate::QSequentialIterableImpl(reinterpret_cast<const QVariantList*>(v.constData())));
+            }
+            if (typeId == qMetaTypeId<QStringList>()) {
+                return QSequentialIterable(QtMetaTypePrivate::QSequentialIterableImpl(reinterpret_cast<const QStringList*>(v.constData())));
+            }
+
+            if (typeId == qMetaTypeId<QByteArrayList>()) {
+                return QSequentialIterable(QtMetaTypePrivate::QSequentialIterableImpl(reinterpret_cast<const QByteArrayList*>(v.constData())));
+            }
+
+            return QSequentialIterable(v.value<QtMetaTypePrivate::QSequentialIterableImpl>());
+        }
+    };
+    template<>
+    struct QVariantValueHelperInterface<QAssociativeIterable>
+    {
+        static QAssociativeIterable invoke(const QVariant &v)
+        {
+            const int typeId = v.userType();
+            if (typeId == qMetaTypeId<QVariantMap>()) {
+                return QAssociativeIterable(QtMetaTypePrivate::QAssociativeIterableImpl(reinterpret_cast<const QVariantMap*>(v.constData())));
+            }
+            if (typeId == qMetaTypeId<QVariantHash>()) {
+                return QAssociativeIterable(QtMetaTypePrivate::QAssociativeIterableImpl(reinterpret_cast<const QVariantHash*>(v.constData())));
+            }
+            return QAssociativeIterable(v.value<QtMetaTypePrivate::QAssociativeIterableImpl>());
+        }
+    };
+    template<>
+    struct QVariantValueHelperInterface<QVariantList>
+    {
+        static QVariantList invoke(const QVariant &v)
+        {
+            const int typeId = v.userType();
+            if (typeId == qMetaTypeId<QStringList>() || typeId == qMetaTypeId<QByteArrayList>() || QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QtMetaTypePrivate::QSequentialIterableImpl>())) {
+                QSequentialIterable iter = QVariantValueHelperInterface<QSequentialIterable>::invoke(v);
+                QVariantList l;
+                l.reserve(iter.size());
+                for (QSequentialIterable::const_iterator it = iter.begin(), end = iter.end(); it != end; ++it)
+                    l << *it;
+                return l;
+            }
+            return QVariantValueHelper<QVariantList>::invoke(v);
+        }
+    };
+    template<>
+    struct QVariantValueHelperInterface<QVariantHash>
+    {
+        static QVariantHash invoke(const QVariant &v)
+        {
+            const int typeId = v.userType();
+            if (typeId == qMetaTypeId<QVariantMap>() || QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QtMetaTypePrivate::QAssociativeIterableImpl>())) {
+                QAssociativeIterable iter = QVariantValueHelperInterface<QAssociativeIterable>::invoke(v);
+                QVariantHash l;
+                l.reserve(iter.size());
+                for (QAssociativeIterable::const_iterator it = iter.begin(), end = iter.end(); it != end; ++it)
+                    l.insertMulti(it.key().toString(), it.value());
+                return l;
+            }
+            return QVariantValueHelper<QVariantHash>::invoke(v);
+        }
+    };
+    template<>
+    struct QVariantValueHelperInterface<QVariantMap>
+    {
+        static QVariantMap invoke(const QVariant &v)
+        {
+            const int typeId = v.userType();
+            if (typeId == qMetaTypeId<QVariantHash>() || QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QtMetaTypePrivate::QAssociativeIterableImpl>())) {
+                QAssociativeIterable iter = QVariantValueHelperInterface<QAssociativeIterable>::invoke(v);
+                QVariantMap l;
+                for (QAssociativeIterable::const_iterator it = iter.begin(), end = iter.end(); it != end; ++it)
+                    l.insertMulti(it.key().toString(), it.value());
+                return l;
+            }
+            return QVariantValueHelper<QVariantMap>::invoke(v);
+        }
+    };
+    template<>
+    struct QVariantValueHelperInterface<QPair<QVariant, QVariant> >
+    {
+        static QPair<QVariant, QVariant> invoke(const QVariant &v)
+        {
+            const int typeId = v.userType();
+            if (typeId == qMetaTypeId<QPair<QVariant, QVariant> >())
+                return QVariantValueHelper<QPair<QVariant, QVariant> >::invoke(v);
+
+            if (QMetaType::hasRegisteredConverterFunction(typeId, qMetaTypeId<QtMetaTypePrivate::QPairVariantInterfaceImpl>())) {
+                QtMetaTypePrivate::QPairVariantInterfaceImpl pi = v.value<QtMetaTypePrivate::QPairVariantInterfaceImpl>();
+
+                const QtMetaTypePrivate::VariantData d1 = pi.first();
+                QVariant v1(d1.metaTypeId, d1.data, d1.flags);
+                if (d1.metaTypeId == qMetaTypeId<QVariant>())
+                    v1 = *reinterpret_cast<const QVariant*>(d1.data);
+
+                const QtMetaTypePrivate::VariantData d2 = pi.second();
+                QVariant v2(d2.metaTypeId, d2.data, d2.flags);
+                if (d2.metaTypeId == qMetaTypeId<QVariant>())
+                    v2 = *reinterpret_cast<const QVariant*>(d2.data);
+
+                return QPair<QVariant, QVariant>(v1, v2);
+            }
+            return QVariantValueHelper<QPair<QVariant, QVariant> >::invoke(v);
+        }
+    };
+}
+
+template<typename T> inline T qvariant_cast(const QVariant &v)
+{
+    return QtPrivate::QVariantValueHelperInterface<T>::invoke(v);
+}
+
+template<> inline QVariant qvariant_cast<QVariant>(const QVariant &v)
+{
+    if (v.userType() == QMetaType::QVariant)
+        return *reinterpret_cast<const QVariant *>(v.constData());
+    return v;
+}
+# 858 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/kernel/qvariant.h"
+__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QVariant &);
+__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QVariant::Type);
+
+
+
+# 1 "../../include/QtCore/qvariant.h" 2
+# 44 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp" 2
+# 1 "../../include/QtCore/qstringlist.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h"
+# 1 "../../include/QtCore/qlist.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qstringlist.h" 2
+# 1 "../../include/QtCore/qstringlist.h" 2
+# 45 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp" 2
+# 1 "../../include/QtCore/qdebug.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h"
+# 1 "../../include/QtCore/qalgorithms.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+# 1 "../../include/QtCore/qhash.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+# 1 "../../include/QtCore/qlist.h" 1
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+# 1 "../../include/QtCore/qmap.h" 1
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+# 1 "../../include/QtCore/qpair.h" 1
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+# 1 "../../include/QtCore/qtextstream.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qtextstream.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qtextstream.h"
+# 1 "../../include/QtCore/qiodevice.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qiodevice.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qiodevice.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qiodevice.h" 2
+
+# 1 "../../include/QtCore/qobject.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qiodevice.h" 2
+
+
+
+
+# 1 "../../include/QtCore/qstring.h" 1
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qiodevice.h" 2
+
+
+
+
+
+
+
+
+class QByteArray;
+class QIODevicePrivate;
+
+class __attribute__((visibility("default"))) QIODevice
+
+    : public QObject
+
+{
+
+    public: template <typename ThisObject> inline void qt_check_for_QOBJECT_macro(const ThisObject &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i + 1; }
+# 68 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qiodevice.h"
+#pragma GCC diagnostic push
+# 68 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qiodevice.h"
+    static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); virtual int qt_metacall(QMetaObject::Call, int, void **); static inline QString tr(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } __attribute__ ((__deprecated__)) static inline QString trUtf8(const char *s, const char *c = nullptr, int n = -1) { return staticMetaObject.tr(s, c, n); } private: __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+# 68 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qiodevice.h"
+#pragma GCC diagnostic pop
+# 68 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qiodevice.h"
+    struct QPrivateSignal {};
+
+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;
+
+    int readChannelCount() const;
+    int writeChannelCount() const;
+    int currentReadChannel() const;
+    void setCurrentReadChannel(int channel);
+    int currentWriteChannel() const;
+    void setCurrentWriteChannel(int channel);
+
+    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;
+
+    void startTransaction();
+    void commitTransaction();
+    void rollbackTransaction();
+    bool isTransactionStarted() 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 channelReadyRead(int channel);
+    void bytesWritten(qint64 bytes);
+    void channelBytesWritten(int channel, qint64 bytes);
+    void aboutToClose();
+    void readChannelFinished();
+
+
+protected:
+
+
+
+    QIODevice(QIODevicePrivate &dd, QObject *parent = nullptr);
+
+    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) noexcept { 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) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QIODevice::OpenMode::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+
+
+class QDebug;
+__attribute__((visibility("default"))) QDebug operator<<(QDebug debug, QIODevice::OpenMode modes);
+
+
+
+# 1 "../../include/QtCore/qiodevice.h" 2
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qtextstream.h" 2
+# 1 "../../include/QtCore/qstring.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qtextstream.h" 2
+# 1 "../../include/QtCore/qchar.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qtextstream.h" 2
+# 1 "../../include/QtCore/qlocale.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h"
+# 1 "../../include/QtCore/qvariant.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h" 2
+# 1 "../../include/QtCore/qstring.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h" 2
+# 1 "../../include/QtCore/qobjectdefs.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h" 2
+# 1 "../../include/QtCore/qshareddata.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qshareddata.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qshareddata.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qshareddata.h" 2
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+# 1 "../../include/QtCore/qatomic.h" 2
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qshareddata.h" 2
+
+# 1 "../../include/QtCore/qhash.h" 1
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qshareddata.h" 2
+
+# 1 "../../include/QtCore/qhashfunctions.h" 1
+# 49 "../../include/QtCore/../../../../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 = nullptr; }
+    inline ~QSharedDataPointer() { if (d && !d->ref.deref()) delete d; }
+
+    explicit QSharedDataPointer(T *data) noexcept;
+    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) noexcept : d(o.d) { o.d = nullptr; }
+    inline QSharedDataPointer<T> &operator=(QSharedDataPointer<T> &&other) noexcept
+    { qSwap(d, other.d); return *this; }
+
+
+    inline bool operator!() const { return !d; }
+
+    inline void swap(QSharedDataPointer &other) noexcept
+    { 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 = nullptr;
+    }
+
+    inline operator bool () const { return d != nullptr; }
+
+    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 = nullptr; }
+    inline ~QExplicitlySharedDataPointer() { if (d && !d->ref.deref()) delete d; }
+
+    explicit QExplicitlySharedDataPointer(T *data) noexcept;
+    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }
+
+    template<class X>
+    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o)
+
+
+
+        : d(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) noexcept : d(o.d) { o.d = nullptr; }
+    inline QExplicitlySharedDataPointer<T> &operator=(QExplicitlySharedDataPointer<T> &&other) noexcept
+    { qSwap(d, other.d); return *this; }
+
+
+    inline bool operator!() const { return !d; }
+
+    inline void swap(QExplicitlySharedDataPointer &other) noexcept
+    { qSwap(d, other.d); }
+
+protected:
+    T *clone();
+
+private:
+    void detach_helper();
+
+    T *d;
+};
+
+template <class T>
+inline QSharedDataPointer<T>::QSharedDataPointer(T *adata) noexcept
+    : 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) noexcept
+    : 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 <class T>
+inline uint qHash(const QSharedDataPointer<T> &ptr, uint seed = 0) noexcept
+{
+    return qHash(ptr.data(), seed);
+}
+template <class T>
+inline uint qHash(const QExplicitlySharedDataPointer<T> &ptr, uint seed = 0) noexcept
+{
+    return qHash(ptr.data(), seed);
+}
+
+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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QSharedDataPointer<T>)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QSharedDataPointer<T> >::value, 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), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QExplicitlySharedDataPointer<T>)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QExplicitlySharedDataPointer<T> >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QExplicitlySharedDataPointer<T>) }; static inline const char *name() { return "QExplicitlySharedDataPointer<T>"; } };
+
+
+# 1 "../../include/QtCore/qshareddata.h" 2
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h" 2
+
+
+
+
+class QDataStream;
+class QDate;
+class QDateTime;
+class QLocale;
+class QTime;
+class QVariant;
+class QTextStream;
+class QTextStreamPrivate;
+
+class QLocalePrivate;
+
+__attribute__((visibility("default"))) uint qHash(const QLocale &key, uint seed = 0) noexcept;
+
+class __attribute__((visibility("default"))) QLocale
+{
+    public: static const QMetaObject staticMetaObject; void qt_check_for_QGADGET_macro(); typedef void QtGadgetHelper; private:
+# 66 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h"
+#pragma GCC diagnostic push
+# 66 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h"
+    __attribute__((visibility("hidden"))) static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+# 66 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h"
+#pragma GCC diagnostic pop
+# 66 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qlocale.h"
+   
+    friend class QString;
+    friend class QStringRef;
+    friend class QByteArray;
+    friend class QIntValidator;
+    friend class QDoubleValidatorPrivate;
+    friend class QTextStream;
+    friend class QTextStreamPrivate;
+
+public:
+
+
+    enum Language {
+        AnyLanguage = 0,
+        C = 1,
+        Abkhazian = 2,
+        Oromo = 3,
+        Afar = 4,
+        Afrikaans = 5,
+        Albanian = 6,
+        Amharic = 7,
+        Arabic = 8,
+        Armenian = 9,
+        Assamese = 10,
+        Aymara = 11,
+        Azerbaijani = 12,
+        Bashkir = 13,
+        Basque = 14,
+        Bengali = 15,
+        Dzongkha = 16,
+        Bihari = 17,
+        Bislama = 18,
+        Breton = 19,
+        Bulgarian = 20,
+        Burmese = 21,
+        Belarusian = 22,
+        Khmer = 23,
+        Catalan = 24,
+        Chinese = 25,
+        Corsican = 26,
+        Croatian = 27,
+        Czech = 28,
+        Danish = 29,
+        Dutch = 30,
+        English = 31,
+        Esperanto = 32,
+        Estonian = 33,
+        Faroese = 34,
+        Fijian = 35,
+        Finnish = 36,
+        French = 37,
+        WesternFrisian = 38,
+        Gaelic = 39,
+        Galician = 40,
+        Georgian = 41,
+        German = 42,
+        Greek = 43,
+        Greenlandic = 44,
+        Guarani = 45,
+        Gujarati = 46,
+        Hausa = 47,
+        Hebrew = 48,
+        Hindi = 49,
+        Hungarian = 50,
+        Icelandic = 51,
+        Indonesian = 52,
+        Interlingua = 53,
+        Interlingue = 54,
+        Inuktitut = 55,
+        Inupiak = 56,
+        Irish = 57,
+        Italian = 58,
+        Japanese = 59,
+        Javanese = 60,
+        Kannada = 61,
+        Kashmiri = 62,
+        Kazakh = 63,
+        Kinyarwanda = 64,
+        Kirghiz = 65,
+        Korean = 66,
+        Kurdish = 67,
+        Rundi = 68,
+        Lao = 69,
+        Latin = 70,
+        Latvian = 71,
+        Lingala = 72,
+        Lithuanian = 73,
+        Macedonian = 74,
+        Malagasy = 75,
+        Malay = 76,
+        Malayalam = 77,
+        Maltese = 78,
+        Maori = 79,
+        Marathi = 80,
+        Marshallese = 81,
+        Mongolian = 82,
+        NauruLanguage = 83,
+        Nepali = 84,
+        NorwegianBokmal = 85,
+        Occitan = 86,
+        Oriya = 87,
+        Pashto = 88,
+        Persian = 89,
+        Polish = 90,
+        Portuguese = 91,
+        Punjabi = 92,
+        Quechua = 93,
+        Romansh = 94,
+        Romanian = 95,
+        Russian = 96,
+        Samoan = 97,
+        Sango = 98,
+        Sanskrit = 99,
+        Serbian = 100,
+        Ossetic = 101,
+        SouthernSotho = 102,
+        Tswana = 103,
+        Shona = 104,
+        Sindhi = 105,
+        Sinhala = 106,
+        Swati = 107,
+        Slovak = 108,
+        Slovenian = 109,
+        Somali = 110,
+        Spanish = 111,
+        Sundanese = 112,
+        Swahili = 113,
+        Swedish = 114,
+        Sardinian = 115,
+        Tajik = 116,
+        Tamil = 117,
+        Tatar = 118,
+        Telugu = 119,
+        Thai = 120,
+        Tibetan = 121,
+        Tigrinya = 122,
+        Tongan = 123,
+        Tsonga = 124,
+        Turkish = 125,
+        Turkmen = 126,
+        Tahitian = 127,
+        Uighur = 128,
+        Ukrainian = 129,
+        Urdu = 130,
+        Uzbek = 131,
+        Vietnamese = 132,
+        Volapuk = 133,
+        Welsh = 134,
+        Wolof = 135,
+        Xhosa = 136,
+        Yiddish = 137,
+        Yoruba = 138,
+        Zhuang = 139,
+        Zulu = 140,
+        NorwegianNynorsk = 141,
+        Bosnian = 142,
+        Divehi = 143,
+        Manx = 144,
+        Cornish = 145,
+        Akan = 146,
+        Konkani = 147,
+        Ga = 148,
+        Igbo = 149,
+        Kamba = 150,
+        Syriac = 151,
+        Blin = 152,
+        Geez = 153,
+        Koro = 154,
+        Sidamo = 155,
+        Atsam = 156,
+        Tigre = 157,
+        Jju = 158,
+        Friulian = 159,
+        Venda = 160,
+        Ewe = 161,
+        Walamo = 162,
+        Hawaiian = 163,
+        Tyap = 164,
+        Nyanja = 165,
+        Filipino = 166,
+        SwissGerman = 167,
+        SichuanYi = 168,
+        Kpelle = 169,
+        LowGerman = 170,
+        SouthNdebele = 171,
+        NorthernSotho = 172,
+        NorthernSami = 173,
+        Taroko = 174,
+        Gusii = 175,
+        Taita = 176,
+        Fulah = 177,
+        Kikuyu = 178,
+        Samburu = 179,
+        Sena = 180,
+        NorthNdebele = 181,
+        Rombo = 182,
+        Tachelhit = 183,
+        Kabyle = 184,
+        Nyankole = 185,
+        Bena = 186,
+        Vunjo = 187,
+        Bambara = 188,
+        Embu = 189,
+        Cherokee = 190,
+        Morisyen = 191,
+        Makonde = 192,
+        Langi = 193,
+        Ganda = 194,
+        Bemba = 195,
+        Kabuverdianu = 196,
+        Meru = 197,
+        Kalenjin = 198,
+        Nama = 199,
+        Machame = 200,
+        Colognian = 201,
+        Masai = 202,
+        Soga = 203,
+        Luyia = 204,
+        Asu = 205,
+        Teso = 206,
+        Saho = 207,
+        KoyraChiini = 208,
+        Rwa = 209,
+        Luo = 210,
+        Chiga = 211,
+        CentralMoroccoTamazight = 212,
+        KoyraboroSenni = 213,
+        Shambala = 214,
+        Bodo = 215,
+        Avaric = 216,
+        Chamorro = 217,
+        Chechen = 218,
+        Church = 219,
+        Chuvash = 220,
+        Cree = 221,
+        Haitian = 222,
+        Herero = 223,
+        HiriMotu = 224,
+        Kanuri = 225,
+        Komi = 226,
+        Kongo = 227,
+        Kwanyama = 228,
+        Limburgish = 229,
+        LubaKatanga = 230,
+        Luxembourgish = 231,
+        Navaho = 232,
+        Ndonga = 233,
+        Ojibwa = 234,
+        Pali = 235,
+        Walloon = 236,
+        Aghem = 237,
+        Basaa = 238,
+        Zarma = 239,
+        Duala = 240,
+        JolaFonyi = 241,
+        Ewondo = 242,
+        Bafia = 243,
+        MakhuwaMeetto = 244,
+        Mundang = 245,
+        Kwasio = 246,
+        Nuer = 247,
+        Sakha = 248,
+        Sangu = 249,
+        CongoSwahili = 250,
+        Tasawaq = 251,
+        Vai = 252,
+        Walser = 253,
+        Yangben = 254,
+        Avestan = 255,
+        Asturian = 256,
+        Ngomba = 257,
+        Kako = 258,
+        Meta = 259,
+        Ngiemboon = 260,
+        Aragonese = 261,
+        Akkadian = 262,
+        AncientEgyptian = 263,
+        AncientGreek = 264,
+        Aramaic = 265,
+        Balinese = 266,
+        Bamun = 267,
+        BatakToba = 268,
+        Buginese = 269,
+        Buhid = 270,
+        Carian = 271,
+        Chakma = 272,
+        ClassicalMandaic = 273,
+        Coptic = 274,
+        Dogri = 275,
+        EasternCham = 276,
+        EasternKayah = 277,
+        Etruscan = 278,
+        Gothic = 279,
+        Hanunoo = 280,
+        Ingush = 281,
+        LargeFloweryMiao = 282,
+        Lepcha = 283,
+        Limbu = 284,
+        Lisu = 285,
+        Lu = 286,
+        Lycian = 287,
+        Lydian = 288,
+        Mandingo = 289,
+        Manipuri = 290,
+        Meroitic = 291,
+        NorthernThai = 292,
+        OldIrish = 293,
+        OldNorse = 294,
+        OldPersian = 295,
+        OldTurkish = 296,
+        Pahlavi = 297,
+        Parthian = 298,
+        Phoenician = 299,
+        PrakritLanguage = 300,
+        Rejang = 301,
+        Sabaean = 302,
+        Samaritan = 303,
+        Santali = 304,
+        Saurashtra = 305,
+        Sora = 306,
+        Sylheti = 307,
+        Tagbanwa = 308,
+        TaiDam = 309,
+        TaiNua = 310,
+        Ugaritic = 311,
+        Akoose = 312,
+        Lakota = 313,
+        StandardMoroccanTamazight = 314,
+        Mapuche = 315,
+        CentralKurdish = 316,
+        LowerSorbian = 317,
+        UpperSorbian = 318,
+        Kenyang = 319,
+        Mohawk = 320,
+        Nko = 321,
+        Prussian = 322,
+        Kiche = 323,
+        SouthernSami = 324,
+        LuleSami = 325,
+        InariSami = 326,
+        SkoltSami = 327,
+        Warlpiri = 328,
+        ManichaeanMiddlePersian = 329,
+        Mende = 330,
+        AncientNorthArabian = 331,
+        LinearA = 332,
+        HmongNjua = 333,
+        Ho = 334,
+        Lezghian = 335,
+        Bassa = 336,
+        Mono = 337,
+        TedimChin = 338,
+        Maithili = 339,
+        Ahom = 340,
+        AmericanSignLanguage = 341,
+        ArdhamagadhiPrakrit = 342,
+        Bhojpuri = 343,
+        HieroglyphicLuwian = 344,
+        LiteraryChinese = 345,
+        Mazanderani = 346,
+        Mru = 347,
+        Newari = 348,
+        NorthernLuri = 349,
+        Palauan = 350,
+        Papiamento = 351,
+        Saraiki = 352,
+        TokelauLanguage = 353,
+        TokPisin = 354,
+        TuvaluLanguage = 355,
+        UncodedLanguages = 356,
+        Cantonese = 357,
+        Osage = 358,
+        Tangut = 359,
+
+        Norwegian = NorwegianBokmal,
+        Moldavian = Romanian,
+        SerboCroatian = Serbian,
+        Tagalog = Filipino,
+        Twi = Akan,
+        Afan = Oromo,
+        Byelorussian = Belarusian,
+        Bhutani = Dzongkha,
+        Cambodian = Khmer,
+        Kurundi = Rundi,
+        RhaetoRomance = Romansh,
+        Chewa = Nyanja,
+        Frisian = WesternFrisian,
+        Uigur = Uighur,
+
+        LastLanguage = Tangut
+    };
+
+    enum Script {
+        AnyScript = 0,
+        ArabicScript = 1,
+        CyrillicScript = 2,
+        DeseretScript = 3,
+        GurmukhiScript = 4,
+        SimplifiedHanScript = 5,
+        TraditionalHanScript = 6,
+        LatinScript = 7,
+        MongolianScript = 8,
+        TifinaghScript = 9,
+        ArmenianScript = 10,
+        BengaliScript = 11,
+        CherokeeScript = 12,
+        DevanagariScript = 13,
+        EthiopicScript = 14,
+        GeorgianScript = 15,
+        GreekScript = 16,
+        GujaratiScript = 17,
+        HebrewScript = 18,
+        JapaneseScript = 19,
+        KhmerScript = 20,
+        KannadaScript = 21,
+        KoreanScript = 22,
+        LaoScript = 23,
+        MalayalamScript = 24,
+        MyanmarScript = 25,
+        OriyaScript = 26,
+        TamilScript = 27,
+        TeluguScript = 28,
+        ThaanaScript = 29,
+        ThaiScript = 30,
+        TibetanScript = 31,
+        SinhalaScript = 32,
+        SyriacScript = 33,
+        YiScript = 34,
+        VaiScript = 35,
+        AvestanScript = 36,
+        BalineseScript = 37,
+        BamumScript = 38,
+        BatakScript = 39,
+        BopomofoScript = 40,
+        BrahmiScript = 41,
+        BugineseScript = 42,
+        BuhidScript = 43,
+        CanadianAboriginalScript = 44,
+        CarianScript = 45,
+        ChakmaScript = 46,
+        ChamScript = 47,
+        CopticScript = 48,
+        CypriotScript = 49,
+        EgyptianHieroglyphsScript = 50,
+        FraserScript = 51,
+        GlagoliticScript = 52,
+        GothicScript = 53,
+        HanScript = 54,
+        HangulScript = 55,
+        HanunooScript = 56,
+        ImperialAramaicScript = 57,
+        InscriptionalPahlaviScript = 58,
+        InscriptionalParthianScript = 59,
+        JavaneseScript = 60,
+        KaithiScript = 61,
+        KatakanaScript = 62,
+        KayahLiScript = 63,
+        KharoshthiScript = 64,
+        LannaScript = 65,
+        LepchaScript = 66,
+        LimbuScript = 67,
+        LinearBScript = 68,
+        LycianScript = 69,
+        LydianScript = 70,
+        MandaeanScript = 71,
+        MeiteiMayekScript = 72,
+        MeroiticScript = 73,
+        MeroiticCursiveScript = 74,
+        NkoScript = 75,
+        NewTaiLueScript = 76,
+        OghamScript = 77,
+        OlChikiScript = 78,
+        OldItalicScript = 79,
+        OldPersianScript = 80,
+        OldSouthArabianScript = 81,
+        OrkhonScript = 82,
+        OsmanyaScript = 83,
+        PhagsPaScript = 84,
+        PhoenicianScript = 85,
+        PollardPhoneticScript = 86,
+        RejangScript = 87,
+        RunicScript = 88,
+        SamaritanScript = 89,
+        SaurashtraScript = 90,
+        SharadaScript = 91,
+        ShavianScript = 92,
+        SoraSompengScript = 93,
+        CuneiformScript = 94,
+        SundaneseScript = 95,
+        SylotiNagriScript = 96,
+        TagalogScript = 97,
+        TagbanwaScript = 98,
+        TaiLeScript = 99,
+        TaiVietScript = 100,
+        TakriScript = 101,
+        UgariticScript = 102,
+        BrailleScript = 103,
+        HiraganaScript = 104,
+        CaucasianAlbanianScript = 105,
+        BassaVahScript = 106,
+        DuployanScript = 107,
+        ElbasanScript = 108,
+        GranthaScript = 109,
+        PahawhHmongScript = 110,
+        KhojkiScript = 111,
+        LinearAScript = 112,
+        MahajaniScript = 113,
+        ManichaeanScript = 114,
+        MendeKikakuiScript = 115,
+        ModiScript = 116,
+        MroScript = 117,
+        OldNorthArabianScript = 118,
+        NabataeanScript = 119,
+        PalmyreneScript = 120,
+        PauCinHauScript = 121,
+        OldPermicScript = 122,
+        PsalterPahlaviScript = 123,
+        SiddhamScript = 124,
+        KhudawadiScript = 125,
+        TirhutaScript = 126,
+        VarangKshitiScript = 127,
+        AhomScript = 128,
+        AnatolianHieroglyphsScript = 129,
+        HatranScript = 130,
+        MultaniScript = 131,
+        OldHungarianScript = 132,
+        SignWritingScript = 133,
+        AdlamScript = 134,
+        BhaiksukiScript = 135,
+        MarchenScript = 136,
+        NewaScript = 137,
+        OsageScript = 138,
+        TangutScript = 139,
+        HanWithBopomofoScript = 140,
+        JamoScript = 141,
+
+        SimplifiedChineseScript = SimplifiedHanScript,
+        TraditionalChineseScript = TraditionalHanScript,
+
+        LastScript = JamoScript
+    };
+    enum Country {
+        AnyCountry = 0,
+        Afghanistan = 1,
+        Albania = 2,
+        Algeria = 3,
+        AmericanSamoa = 4,
+        Andorra = 5,
+        Angola = 6,
+        Anguilla = 7,
+        Antarctica = 8,
+        AntiguaAndBarbuda = 9,
+        Argentina = 10,
+        Armenia = 11,
+        Aruba = 12,
+        Australia = 13,
+        Austria = 14,
+        Azerbaijan = 15,
+        Bahamas = 16,
+        Bahrain = 17,
+        Bangladesh = 18,
+        Barbados = 19,
+        Belarus = 20,
+        Belgium = 21,
+        Belize = 22,
+        Benin = 23,
+        Bermuda = 24,
+        Bhutan = 25,
+        Bolivia = 26,
+        BosniaAndHerzegowina = 27,
+        Botswana = 28,
+        BouvetIsland = 29,
+        Brazil = 30,
+        BritishIndianOceanTerritory = 31,
+        Brunei = 32,
+        Bulgaria = 33,
+        BurkinaFaso = 34,
+        Burundi = 35,
+        Cambodia = 36,
+        Cameroon = 37,
+        Canada = 38,
+        CapeVerde = 39,
+        CaymanIslands = 40,
+        CentralAfricanRepublic = 41,
+        Chad = 42,
+        Chile = 43,
+        China = 44,
+        ChristmasIsland = 45,
+        CocosIslands = 46,
+        Colombia = 47,
+        Comoros = 48,
+        CongoKinshasa = 49,
+        CongoBrazzaville = 50,
+        CookIslands = 51,
+        CostaRica = 52,
+        IvoryCoast = 53,
+        Croatia = 54,
+        Cuba = 55,
+        Cyprus = 56,
+        CzechRepublic = 57,
+        Denmark = 58,
+        Djibouti = 59,
+        Dominica = 60,
+        DominicanRepublic = 61,
+        EastTimor = 62,
+        Ecuador = 63,
+        Egypt = 64,
+        ElSalvador = 65,
+        EquatorialGuinea = 66,
+        Eritrea = 67,
+        Estonia = 68,
+        Ethiopia = 69,
+        FalklandIslands = 70,
+        FaroeIslands = 71,
+        Fiji = 72,
+        Finland = 73,
+        France = 74,
+        Guernsey = 75,
+        FrenchGuiana = 76,
+        FrenchPolynesia = 77,
+        FrenchSouthernTerritories = 78,
+        Gabon = 79,
+        Gambia = 80,
+        Georgia = 81,
+        Germany = 82,
+        Ghana = 83,
+        Gibraltar = 84,
+        Greece = 85,
+        Greenland = 86,
+        Grenada = 87,
+        Guadeloupe = 88,
+        Guam = 89,
+        Guatemala = 90,
+        Guinea = 91,
+        GuineaBissau = 92,
+        Guyana = 93,
+        Haiti = 94,
+        HeardAndMcDonaldIslands = 95,
+        Honduras = 96,
+        HongKong = 97,
+        Hungary = 98,
+        Iceland = 99,
+        India = 100,
+        Indonesia = 101,
+        Iran = 102,
+        Iraq = 103,
+        Ireland = 104,
+        Israel = 105,
+        Italy = 106,
+        Jamaica = 107,
+        Japan = 108,
+        Jordan = 109,
+        Kazakhstan = 110,
+        Kenya = 111,
+        Kiribati = 112,
+        NorthKorea = 113,
+        SouthKorea = 114,
+        Kuwait = 115,
+        Kyrgyzstan = 116,
+        Laos = 117,
+        Latvia = 118,
+        Lebanon = 119,
+        Lesotho = 120,
+        Liberia = 121,
+        Libya = 122,
+        Liechtenstein = 123,
+        Lithuania = 124,
+        Luxembourg = 125,
+        Macau = 126,
+        Macedonia = 127,
+        Madagascar = 128,
+        Malawi = 129,
+        Malaysia = 130,
+        Maldives = 131,
+        Mali = 132,
+        Malta = 133,
+        MarshallIslands = 134,
+        Martinique = 135,
+        Mauritania = 136,
+        Mauritius = 137,
+        Mayotte = 138,
+        Mexico = 139,
+        Micronesia = 140,
+        Moldova = 141,
+        Monaco = 142,
+        Mongolia = 143,
+        Montserrat = 144,
+        Morocco = 145,
+        Mozambique = 146,
+        Myanmar = 147,
+        Namibia = 148,
+        NauruCountry = 149,
+        Nepal = 150,
+        Netherlands = 151,
+        CuraSao = 152,
+        NewCaledonia = 153,
+        NewZealand = 154,
+        Nicaragua = 155,
+        Niger = 156,
+        Nigeria = 157,
+        Niue = 158,
+        NorfolkIsland = 159,
+        NorthernMarianaIslands = 160,
+        Norway = 161,
+        Oman = 162,
+        Pakistan = 163,
+        Palau = 164,
+        PalestinianTerritories = 165,
+        Panama = 166,
+        PapuaNewGuinea = 167,
+        Paraguay = 168,
+        Peru = 169,
+        Philippines = 170,
+        Pitcairn = 171,
+        Poland = 172,
+        Portugal = 173,
+        PuertoRico = 174,
+        Qatar = 175,
+        Reunion = 176,
+        Romania = 177,
+        Russia = 178,
+        Rwanda = 179,
+        SaintKittsAndNevis = 180,
+        SaintLucia = 181,
+        SaintVincentAndTheGrenadines = 182,
+        Samoa = 183,
+        SanMarino = 184,
+        SaoTomeAndPrincipe = 185,
+        SaudiArabia = 186,
+        Senegal = 187,
+        Seychelles = 188,
+        SierraLeone = 189,
+        Singapore = 190,
+        Slovakia = 191,
+        Slovenia = 192,
+        SolomonIslands = 193,
+        Somalia = 194,
+        SouthAfrica = 195,
+        SouthGeorgiaAndTheSouthSandwichIslands = 196,
+        Spain = 197,
+        SriLanka = 198,
+        SaintHelena = 199,
+        SaintPierreAndMiquelon = 200,
+        Sudan = 201,
+        Suriname = 202,
+        SvalbardAndJanMayenIslands = 203,
+        Swaziland = 204,
+        Sweden = 205,
+        Switzerland = 206,
+        Syria = 207,
+        Taiwan = 208,
+        Tajikistan = 209,
+        Tanzania = 210,
+        Thailand = 211,
+        Togo = 212,
+        TokelauCountry = 213,
+        Tonga = 214,
+        TrinidadAndTobago = 215,
+        Tunisia = 216,
+        Turkey = 217,
+        Turkmenistan = 218,
+        TurksAndCaicosIslands = 219,
+        TuvaluCountry = 220,
+        Uganda = 221,
+        Ukraine = 222,
+        UnitedArabEmirates = 223,
+        UnitedKingdom = 224,
+        UnitedStates = 225,
+        UnitedStatesMinorOutlyingIslands = 226,
+        Uruguay = 227,
+        Uzbekistan = 228,
+        Vanuatu = 229,
+        VaticanCityState = 230,
+        Venezuela = 231,
+        Vietnam = 232,
+        BritishVirginIslands = 233,
+        UnitedStatesVirginIslands = 234,
+        WallisAndFutunaIslands = 235,
+        WesternSahara = 236,
+        Yemen = 237,
+        CanaryIslands = 238,
+        Zambia = 239,
+        Zimbabwe = 240,
+        ClippertonIsland = 241,
+        Montenegro = 242,
+        Serbia = 243,
+        SaintBarthelemy = 244,
+        SaintMartin = 245,
+        LatinAmericaAndTheCaribbean = 246,
+        AscensionIsland = 247,
+        AlandIslands = 248,
+        DiegoGarcia = 249,
+        CeutaAndMelilla = 250,
+        IsleOfMan = 251,
+        Jersey = 252,
+        TristanDaCunha = 253,
+        SouthSudan = 254,
+        Bonaire = 255,
+        SintMaarten = 256,
+        Kosovo = 257,
+        EuropeanUnion = 258,
+        OutlyingOceania = 259,
+
+        Tokelau = TokelauCountry,
+        Tuvalu = TuvaluCountry,
+        DemocraticRepublicOfCongo = CongoKinshasa,
+        PeoplesRepublicOfCongo = CongoBrazzaville,
+        DemocraticRepublicOfKorea = NorthKorea,
+        RepublicOfKorea = SouthKorea,
+        RussianFederation = Russia,
+        SyrianArabRepublic = Syria,
+
+        LastCountry = OutlyingOceania
+    };
+
+
+    friend constexpr const QMetaObject *qt_getEnumMetaObject(Language) noexcept { return &staticMetaObject; } friend constexpr const char *qt_getEnumName(Language) noexcept { return "Language"; }
+    friend constexpr const QMetaObject *qt_getEnumMetaObject(Country) noexcept { return &staticMetaObject; } friend constexpr const char *qt_getEnumName(Country) noexcept { return "Country"; }
+    friend constexpr const QMetaObject *qt_getEnumMetaObject(Script) noexcept { return &staticMetaObject; } friend constexpr const char *qt_getEnumName(Script) noexcept { return "Script"; }
+
+    enum MeasurementSystem {
+        MetricSystem,
+        ImperialUSSystem,
+        ImperialUKSystem,
+        ImperialSystem = ImperialUSSystem
+    };
+    friend constexpr const QMetaObject *qt_getEnumMetaObject(MeasurementSystem) noexcept { return &staticMetaObject; } friend constexpr const char *qt_getEnumName(MeasurementSystem) noexcept { return "MeasurementSystem"; }
+
+    enum FormatType { LongFormat, ShortFormat, NarrowFormat };
+    enum NumberOption {
+        DefaultNumberOptions = 0x0,
+        OmitGroupSeparator = 0x01,
+        RejectGroupSeparator = 0x02,
+        OmitLeadingZeroInExponent = 0x04,
+        RejectLeadingZeroInExponent = 0x08
+    };
+    typedef QFlags<NumberOption> NumberOptions;
+
+    enum FloatingPointPrecisionOption {
+        FloatingPointShortest = -128
+    };
+
+    enum CurrencySymbolFormat {
+        CurrencyIsoCode,
+        CurrencySymbol,
+        CurrencyDisplayName
+    };
+
+    QLocale();
+    QLocale(const QString &name);
+    QLocale(Language language, Country country = AnyCountry);
+    QLocale(Language language, Script script, Country country);
+    QLocale(const QLocale &other);
+
+    QLocale &operator=(QLocale &&other) noexcept { swap(other); return *this; }
+
+    QLocale &operator=(const QLocale &other);
+    ~QLocale();
+
+    void swap(QLocale &other) noexcept { qSwap(d, other.d); }
+
+    Language language() const;
+    Script script() const;
+    Country country() const;
+    QString name() const;
+
+    QString bcp47Name() const;
+    QString nativeLanguageName() const;
+    QString nativeCountryName() const;
+
+    short toShort(const QString &s, bool *ok = nullptr) const;
+    ushort toUShort(const QString &s, bool *ok = nullptr) const;
+    int toInt(const QString &s, bool *ok = nullptr) const;
+    uint toUInt(const QString &s, bool *ok = nullptr) const;
+    qlonglong toLongLong(const QString &s, bool *ok = nullptr) const;
+    qulonglong toULongLong(const QString &s, bool *ok = nullptr) const;
+    float toFloat(const QString &s, bool *ok = nullptr) const;
+    double toDouble(const QString &s, bool *ok = nullptr) const;
+
+    short toShort(const QStringRef &s, bool *ok = nullptr) const;
+    ushort toUShort(const QStringRef &s, bool *ok = nullptr) const;
+    int toInt(const QStringRef &s, bool *ok = nullptr) const;
+    uint toUInt(const QStringRef &s, bool *ok = nullptr) const;
+    qlonglong toLongLong(const QStringRef &s, bool *ok = nullptr) const;
+    qulonglong toULongLong(const QStringRef &s, bool *ok = nullptr) const;
+    float toFloat(const QStringRef &s, bool *ok = nullptr) const;
+    double toDouble(const QStringRef &s, bool *ok = nullptr) const;
+
+    QString toString(qlonglong i) const;
+    QString toString(qulonglong i) const;
+    inline QString toString(short i) const;
+    inline QString toString(ushort i) const;
+    inline QString toString(int i) const;
+    inline QString toString(uint i) const;
+    QString toString(double i, char f = 'g', int prec = 6) const;
+    inline QString toString(float i, char f = 'g', int prec = 6) const;
+    QString toString(const QDate &date, const QString &formatStr) const;
+    QString toString(const QDate &date, FormatType format = LongFormat) const;
+    QString toString(const QTime &time, const QString &formatStr) const;
+    QString toString(const QTime &time, FormatType format = LongFormat) const;
+    QString toString(const QDateTime &dateTime, FormatType format = LongFormat) const;
+    QString toString(const QDateTime &dateTime, const QString &format) const;
+
+    QString dateFormat(FormatType format = LongFormat) const;
+    QString timeFormat(FormatType format = LongFormat) const;
+    QString dateTimeFormat(FormatType format = LongFormat) const;
+
+    QDate toDate(const QString &string, FormatType = LongFormat) const;
+    QTime toTime(const QString &string, FormatType = LongFormat) const;
+    QDateTime toDateTime(const QString &string, FormatType format = LongFormat) const;
+    QDate toDate(const QString &string, const QString &format) const;
+    QTime toTime(const QString &string, const QString &format) const;
+    QDateTime toDateTime(const QString &string, const QString &format) const;
+
+
+
+
+    QChar decimalPoint() const;
+    QChar groupSeparator() const;
+    QChar percent() const;
+    QChar zeroDigit() const;
+    QChar negativeSign() const;
+    QChar positiveSign() const;
+    QChar exponential() const;
+
+    QString monthName(int, FormatType format = LongFormat) const;
+    QString standaloneMonthName(int, FormatType format = LongFormat) const;
+    QString dayName(int, FormatType format = LongFormat) const;
+    QString standaloneDayName(int, FormatType format = LongFormat) const;
+
+    Qt::DayOfWeek firstDayOfWeek() const;
+    QList<Qt::DayOfWeek> weekdays() const;
+
+    QString amText() const;
+    QString pmText() const;
+
+    MeasurementSystem measurementSystem() const;
+
+    Qt::LayoutDirection textDirection() const;
+
+    QString toUpper(const QString &str) const;
+    QString toLower(const QString &str) const;
+
+    QString currencySymbol(CurrencySymbolFormat = CurrencySymbol) const;
+    QString toCurrencyString(qlonglong, const QString &symbol = QString()) const;
+    QString toCurrencyString(qulonglong, const QString &symbol = QString()) const;
+    inline QString toCurrencyString(short, const QString &symbol = QString()) const;
+    inline QString toCurrencyString(ushort, const QString &symbol = QString()) const;
+    inline QString toCurrencyString(int, const QString &symbol = QString()) const;
+    inline QString toCurrencyString(uint, const QString &symbol = QString()) const;
+
+
+
+
+
+    QString toCurrencyString(double, const QString &symbol = QString()) const;
+    QString toCurrencyString(double, const QString &symbol, int precision) const;
+    inline QString toCurrencyString(float i, const QString &symbol = QString()) const
+    { return toCurrencyString(double(i), symbol); }
+    inline QString toCurrencyString(float i, const QString &symbol, int precision) const
+    { return toCurrencyString(double(i), symbol, precision); }
+
+
+    QStringList uiLanguages() const;
+
+    bool operator==(const QLocale &other) const;
+    bool operator!=(const QLocale &other) const;
+
+    static QString languageToString(Language language);
+    static QString countryToString(Country country);
+    static QString scriptToString(Script script);
+    static void setDefault(const QLocale &locale);
+
+    static QLocale c() { return QLocale(C); }
+    static QLocale system();
+
+    static QList<QLocale> matchingLocales(QLocale::Language language, QLocale::Script script, QLocale::Country country);
+    static QList<Country> countriesForLanguage(Language lang);
+
+    void setNumberOptions(NumberOptions options);
+    NumberOptions numberOptions() const;
+
+    enum QuotationStyle { StandardQuotation, AlternateQuotation };
+    QString quoteString(const QString &str, QuotationStyle style = StandardQuotation) const;
+    QString quoteString(const QStringRef &str, QuotationStyle style = StandardQuotation) const;
+
+    QString createSeparatedList(const QStringList &strl) const;
+
+private:
+    QLocale(QLocalePrivate &dd);
+    friend class QLocalePrivate;
+    friend __attribute__((visibility("default"))) uint qHash(const QLocale &key, uint seed) noexcept;
+
+    QSharedDataPointer<QLocalePrivate> d;
+};
+template<> class QTypeInfo<QLocale > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QLocale)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QLocale >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QLocale) }; static inline const char *name() { return "QLocale"; } }; inline void swap(QLocale &value1, QLocale &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }
+constexpr inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QLocale::NumberOptions::enum_type f2) noexcept { return QFlags<QLocale::NumberOptions::enum_type>(f1) | f2; } constexpr inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QFlags<QLocale::NumberOptions::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QLocale::NumberOptions::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+
+inline QString QLocale::toString(short i) const
+    { return toString(qlonglong(i)); }
+inline QString QLocale::toString(ushort i) const
+    { return toString(qulonglong(i)); }
+inline QString QLocale::toString(int i) const
+    { return toString(qlonglong(i)); }
+inline QString QLocale::toString(uint i) const
+    { return toString(qulonglong(i)); }
+inline QString QLocale::toString(float i, char f, int prec) const
+    { return toString(double(i), f, prec); }
+
+inline QString QLocale::toCurrencyString(short i, const QString &symbol) const
+    { return toCurrencyString(qlonglong(i), symbol); }
+inline QString QLocale::toCurrencyString(ushort i, const QString &symbol) const
+    { return toCurrencyString(qulonglong(i), symbol); }
+inline QString QLocale::toCurrencyString(int i, const QString &symbol) const
+{ return toCurrencyString(qlonglong(i), symbol); }
+inline QString QLocale::toCurrencyString(uint i, const QString &symbol) const
+{ return toCurrencyString(qulonglong(i), symbol); }
+
+
+__attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QLocale &);
+__attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QLocale &);
+
+
+
+__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QLocale &);
+
+
+
+# 1 "../../include/QtCore/qlocale.h" 2
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qtextstream.h" 2
+# 1 "../../include/QtCore/qscopedpointer.h" 1
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qtextstream.h" 2
+
+
+
+
+
+
+
+
+
+
+class QTextCodec;
+class QTextDecoder;
+
+class QTextStreamPrivate;
+class __attribute__((visibility("default"))) QTextStream
+{
+    inline QTextStreamPrivate* d_func() { return reinterpret_cast<QTextStreamPrivate *>(qGetPtrHelper(d_ptr)); } inline const QTextStreamPrivate* d_func() const { return reinterpret_cast<const QTextStreamPrivate *>(qGetPtrHelper(d_ptr)); } friend class QTextStreamPrivate;
+
+public:
+    enum RealNumberNotation {
+        SmartNotation,
+        FixedNotation,
+        ScientificNotation
+    };
+    enum FieldAlignment {
+        AlignLeft,
+        AlignRight,
+        AlignCenter,
+        AlignAccountingStyle
+    };
+    enum Status {
+        Ok,
+        ReadPastEnd,
+        ReadCorruptData,
+        WriteFailed
+    };
+    enum NumberFlag {
+        ShowBase = 0x1,
+        ForcePoint = 0x2,
+        ForceSign = 0x4,
+        UppercaseBase = 0x8,
+        UppercaseDigits = 0x10
+    };
+    typedef QFlags<NumberFlag> NumberFlags;
+
+    QTextStream();
+    explicit QTextStream(QIODevice *device);
+    explicit QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly);
+    virtual ~QTextStream();
+
+
+    void setCodec(QTextCodec *codec);
+    void setCodec(const char *codecName);
+    QTextCodec *codec() const;
+    void setAutoDetectUnicode(bool enabled);
+    bool autoDetectUnicode() const;
+    void setGenerateByteOrderMark(bool generate);
+    bool generateByteOrderMark() const;
+
+
+    void setLocale(const QLocale &locale);
+    QLocale locale() const;
+
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+
+    void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    QString *string() const;
+
+    Status status() const;
+    void setStatus(Status status);
+    void resetStatus();
+
+    bool atEnd() const;
+    void reset();
+    void flush();
+    bool seek(qint64 pos);
+    qint64 pos() const;
+
+    void skipWhiteSpace();
+
+    QString readLine(qint64 maxlen = 0);
+    bool readLineInto(QString *line, qint64 maxlen = 0);
+    QString readAll();
+    QString read(qint64 maxlen);
+
+    void setFieldAlignment(FieldAlignment alignment);
+    FieldAlignment fieldAlignment() const;
+
+    void setPadChar(QChar ch);
+    QChar padChar() const;
+
+    void setFieldWidth(int width);
+    int fieldWidth() const;
+
+    void setNumberFlags(NumberFlags flags);
+    NumberFlags numberFlags() const;
+
+    void setIntegerBase(int base);
+    int integerBase() const;
+
+    void setRealNumberNotation(RealNumberNotation notation);
+    RealNumberNotation realNumberNotation() const;
+
+    void setRealNumberPrecision(int precision);
+    int realNumberPrecision() const;
+
+    QTextStream &operator>>(QChar &ch);
+    QTextStream &operator>>(char &ch);
+    QTextStream &operator>>(signed short &i);
+    QTextStream &operator>>(unsigned short &i);
+    QTextStream &operator>>(signed int &i);
+    QTextStream &operator>>(unsigned int &i);
+    QTextStream &operator>>(signed long &i);
+    QTextStream &operator>>(unsigned long &i);
+    QTextStream &operator>>(qlonglong &i);
+    QTextStream &operator>>(qulonglong &i);
+    QTextStream &operator>>(float &f);
+    QTextStream &operator>>(double &f);
+    QTextStream &operator>>(QString &s);
+    QTextStream &operator>>(QByteArray &array);
+    QTextStream &operator>>(char *c);
+
+    QTextStream &operator<<(QChar ch);
+    QTextStream &operator<<(char ch);
+    QTextStream &operator<<(signed short i);
+    QTextStream &operator<<(unsigned short i);
+    QTextStream &operator<<(signed int i);
+    QTextStream &operator<<(unsigned int i);
+    QTextStream &operator<<(signed long i);
+    QTextStream &operator<<(unsigned long i);
+    QTextStream &operator<<(qlonglong i);
+    QTextStream &operator<<(qulonglong i);
+    QTextStream &operator<<(float f);
+    QTextStream &operator<<(double f);
+    QTextStream &operator<<(const QString &s);
+    QTextStream &operator<<(QLatin1String s);
+    QTextStream &operator<<(const QStringRef &s);
+    QTextStream &operator<<(const QByteArray &array);
+    QTextStream &operator<<(const char *c);
+    QTextStream &operator<<(const void *ptr);
+
+private:
+    QTextStream(const QTextStream &) = delete; QTextStream &operator=(const QTextStream &) = delete;
+    friend class QDebugStateSaverPrivate;
+    friend class QDebug;
+
+    QScopedPointer<QTextStreamPrivate> d_ptr;
+};
+
+constexpr inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QTextStream::NumberFlags::enum_type f2) noexcept { return QFlags<QTextStream::NumberFlags::enum_type>(f1) | f2; } constexpr inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QFlags<QTextStream::NumberFlags::enum_type> f2) noexcept { return f2 | f1; } constexpr inline QIncompatibleFlag operator|(QTextStream::NumberFlags::enum_type f1, int f2) noexcept { return QIncompatibleFlag(int(f1) | f2); }
+
+
+
+
+
+typedef QTextStream & (*QTextStreamFunction)(QTextStream &);
+typedef void (QTextStream::*QTSMFI)(int);
+typedef void (QTextStream::*QTSMFC)(QChar);
+
+
+class __attribute__((visibility("default"))) QTextStreamManipulator
+{
+public:
+    constexpr QTextStreamManipulator(QTSMFI m, int a) noexcept : mf(m), mc(nullptr), arg(a), ch() {}
+    constexpr QTextStreamManipulator(QTSMFC m, QChar c) noexcept : mf(nullptr), mc(m), arg(-1), ch(c) {}
+    void exec(QTextStream &s) { if (mf) { (s.*mf)(arg); } else { (s.*mc)(ch); } }
+
+private:
+    QTSMFI mf;
+    QTSMFC mc;
+    int arg;
+    QChar ch;
+};
+
+inline QTextStream &operator>>(QTextStream &s, QTextStreamFunction f)
+{ return (*f)(s); }
+
+inline QTextStream &operator<<(QTextStream &s, QTextStreamFunction f)
+{ return (*f)(s); }
+
+inline QTextStream &operator<<(QTextStream &s, QTextStreamManipulator m)
+{ m.exec(s); return s; }
+
+__attribute__((visibility("default"))) QTextStream &bin(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &oct(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &dec(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &hex(QTextStream &s);
+
+__attribute__((visibility("default"))) QTextStream &showbase(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &forcesign(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &forcepoint(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &noshowbase(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &noforcesign(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &noforcepoint(QTextStream &s);
+
+__attribute__((visibility("default"))) QTextStream &uppercasebase(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &uppercasedigits(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &lowercasebase(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &lowercasedigits(QTextStream &s);
+
+__attribute__((visibility("default"))) QTextStream &fixed(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &scientific(QTextStream &s);
+
+__attribute__((visibility("default"))) QTextStream &left(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &right(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &center(QTextStream &s);
+
+__attribute__((visibility("default"))) QTextStream &endl(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &flush(QTextStream &s);
+__attribute__((visibility("default"))) QTextStream &reset(QTextStream &s);
+
+__attribute__((visibility("default"))) QTextStream &bom(QTextStream &s);
+
+__attribute__((visibility("default"))) QTextStream &ws(QTextStream &s);
+
+inline QTextStreamManipulator qSetFieldWidth(int width)
+{
+    QTSMFI func = &QTextStream::setFieldWidth;
+    return QTextStreamManipulator(func,width);
+}
+
+inline QTextStreamManipulator qSetPadChar(QChar ch)
+{
+    QTSMFC func = &QTextStream::setPadChar;
+    return QTextStreamManipulator(func, ch);
+}
+
+inline QTextStreamManipulator qSetRealNumberPrecision(int precision)
+{
+    QTSMFI func = &QTextStream::setRealNumberPrecision;
+    return QTextStreamManipulator(func, precision);
+}
+
+
+# 1 "../../include/QtCore/qtextstream.h" 2
+# 50 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+# 1 "../../include/QtCore/qstring.h" 1
+# 51 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+# 1 "../../include/QtCore/qvector.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h"
+# 1 "../../include/QtCore/qalgorithms.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h" 2
+# 1 "../../include/QtCore/qiterator.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h" 2
+# 1 "../../include/QtCore/qlist.h" 1
+# 46 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h" 2
+# 1 "../../include/QtCore/qrefcount.h" 1
+# 47 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h" 2
+# 1 "../../include/QtCore/qarraydata.h" 1
+# 48 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h" 2
+# 1 "../../include/QtCore/qhashfunctions.h" 1
+# 49 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h" 2
+# 60 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h"
+
+
+class QRegion;
+
+template <typename T>
+class QVector
+{
+    typedef QTypedArrayData<T> Data;
+    Data *d;
+
+public:
+    inline QVector() noexcept : d(Data::sharedNull()) { }
+    explicit QVector(int size);
+    QVector(int size, const T &t);
+    inline QVector(const QVector<T> &v);
+    inline ~QVector() { if (!d->ref.deref()) freeData(d); }
+    QVector<T> &operator=(const QVector<T> &v);
+
+    QVector(QVector<T> &&other) noexcept : d(other.d) { other.d = Data::sharedNull(); }
+    QVector<T> &operator=(QVector<T> &&other) noexcept
+    { QVector moved(std::move(other)); swap(moved); return *this; }
+
+    void swap(QVector<T> &other) noexcept { qSwap(d, other.d); }
+
+    inline QVector(std::initializer_list<T> args);
+
+    bool operator==(const QVector<T> &v) const;
+    inline bool operator!=(const QVector<T> &v) const { return !(*this == v); }
+
+    inline int size() const { return d->size; }
+
+    inline bool isEmpty() const { return d->size == 0; }
+
+    void resize(int size);
+
+    inline int capacity() const { return int(d->alloc); }
+    void reserve(int size);
+    inline void squeeze()
+    {
+        reallocData(d->size, d->size);
+        if (d->capacityReserved) {
+
+
+            d->capacityReserved = 0;
+        }
+    }
+
+    inline void detach();
+    inline bool isDetached() const { return !d->ref.isShared(); }
+
+    inline void setSharable(bool sharable)
+    {
+        if (sharable == d->ref.isSharable())
+            return;
+        if (!sharable)
+            detach();
+
+        if (d == Data::unsharableEmpty()) {
+            if (sharable)
+                d = Data::sharedNull();
+        } else {
+            d->ref.setSharable(sharable);
+        }
+        do { } while ((false) && (d->ref.isSharable() == sharable));
+    }
+
+
+    inline bool isSharedWith(const QVector<T> &other) const { return d == other.d; }
+
+    inline T *data() { detach(); return d->begin(); }
+    inline const T *data() const { return d->begin(); }
+    inline const T *constData() const { return d->begin(); }
+    void clear();
+
+    const T &at(int i) const;
+    T &operator[](int i);
+    const T &operator[](int i) const;
+    void append(const T &t);
+
+    void append(T &&t);
+
+    inline void append(const QVector<T> &l) { *this += l; }
+    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 void removeFirst() { do { } while ((false) && (!isEmpty())); erase(d->begin()); }
+    inline void removeLast();
+    inline T takeFirst() { do { } while ((false) && (!isEmpty())); T r = first(); removeFirst(); return r; }
+    inline T takeLast() { do { } while ((false) && (!isEmpty())); T r = last(); removeLast(); return r; }
+
+    QVector<T> &fill(const T &t, int size = -1);
+
+    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;
+
+
+    void removeAt(int i) { remove(i); }
+    int removeAll(const T &t)
+    {
+        const const_iterator ce = this->cend(), cit = std::find(this->cbegin(), ce, t);
+        if (cit == ce)
+            return 0;
+
+        const int firstFoundIdx = std::distance(this->cbegin(), cit);
+        const iterator e = end(), it = std::remove(begin() + firstFoundIdx, e, t);
+        const int result = std::distance(it, e);
+        erase(it, e);
+        return result;
+    }
+    bool removeOne(const T &t)
+    {
+        const int i = indexOf(t);
+        if (i < 0)
+            return false;
+        remove(i);
+        return true;
+    }
+    int length() const { return size(); }
+    T takeAt(int i) { T t = at(i); remove(i); return t; }
+    void move(int from, int to)
+    {
+        do { } while ((false) && (from >= 0 && from < size()));
+        do { } while ((false) && (to >= 0 && to < size()));
+        if (from == to)
+            return;
+        detach();
+        T * const b = d->begin();
+        if (from < to)
+            std::rotate(b + from, b + from + 1, b + to + 1);
+        else
+            std::rotate(b + to, b + from, b + from + 1);
+    }
+
+
+    typedef typename Data::iterator iterator;
+    typedef typename Data::const_iterator const_iterator;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+    inline iterator begin() { detach(); return d->begin(); }
+    inline const_iterator begin() const noexcept { return d->constBegin(); }
+    inline const_iterator cbegin() const noexcept { return d->constBegin(); }
+    inline const_iterator constBegin() const noexcept { return d->constBegin(); }
+    inline iterator end() { detach(); return d->end(); }
+    inline const_iterator end() const noexcept { return d->constEnd(); }
+    inline const_iterator cend() const noexcept { return d->constEnd(); }
+    inline const_iterator constEnd() const noexcept { return d->constEnd(); }
+# 222 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h"
+    reverse_iterator rbegin() { return reverse_iterator(end()); }
+    reverse_iterator rend() { return reverse_iterator(begin()); }
+    const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
+    const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
+    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
+    const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
+    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); }
+
+
+    inline int count() const { return d->size; }
+    inline T& first() { do { } while ((false) && (!isEmpty())); return *begin(); }
+    inline const T &first() const { do { } while ((false) && (!isEmpty())); return *begin(); }
+    inline const T &constFirst() const { do { } while ((false) && (!isEmpty())); return *begin(); }
+    inline T& last() { do { } while ((false) && (!isEmpty())); return *(end()-1); }
+    inline const T &last() const { do { } while ((false) && (!isEmpty())); return *(end()-1); }
+    inline const T &constLast() const { do { } while ((false) && (!isEmpty())); return *(end()-1); }
+    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
+    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
+    QVector<T> mid(int pos, int len = -1) const;
+
+    T value(int i) const;
+    T value(int i, const T &defaultValue) const;
+
+
+    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 iterator Iterator;
+    typedef const_iterator ConstIterator;
+    typedef int size_type;
+    inline void push_back(const T &t) { append(t); }
+
+    void push_back(T &&t) { append(std::move(t)); }
+
+    inline void push_front(const T &t) { prepend(t); }
+    void pop_back() { removeLast(); }
+    void pop_front() { removeFirst(); }
+    inline bool empty() const
+    { return d->size == 0; }
+    inline T& front() { return first(); }
+    inline const_reference front() const { return first(); }
+    inline reference back() { return last(); }
+    inline const_reference back() const { return last(); }
+
+
+    QVector<T> &operator+=(const QVector<T> &l);
+    inline QVector<T> operator+(const QVector<T> &l) const
+    { QVector n = *this; n += l; return n; }
+    inline QVector<T> &operator+=(const T &t)
+    { append(t); return *this; }
+    inline QVector<T> &operator<< (const T &t)
+    { append(t); return *this; }
+    inline QVector<T> &operator<<(const QVector<T> &l)
+    { *this += l; return *this; }
+
+    QList<T> toList() const;
+
+    static QVector<T> fromList(const QList<T> &list);
+
+    static inline QVector<T> fromStdVector(const std::vector<T> &vector)
+    { QVector<T> tmp; tmp.reserve(int(vector.size())); std::copy(vector.begin(), vector.end(), std::back_inserter(tmp)); return tmp; }
+    inline std::vector<T> toStdVector() const
+    { return std::vector<T>(d->begin(), d->end()); }
+private:
+    friend class QRegion;
+
+    void reallocData(const int size, const int alloc, QArrayData::AllocationOptions options = QArrayData::Default);
+    void reallocData(const int sz) { reallocData(sz, d->alloc); }
+    void freeData(Data *d);
+    void defaultConstruct(T *from, T *to);
+    void copyConstruct(const T *srcFrom, const T *srcTo, T *dstFrom);
+    void destruct(T *from, T *to);
+    bool isValidIterator(const iterator &i) const
+    {
+        return (i <= d->end()) && (d->begin() <= i);
+    }
+    class AlignmentDummy { Data header; T array[1]; };
+};
+# 314 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h"
+template <typename T>
+void QVector<T>::defaultConstruct(T *from, T *to)
+{
+    if (QTypeInfo<T>::isComplex) {
+        while (from != to) {
+            new (from++) T();
+        }
+    } else {
+        ::memset(static_cast<void *>(from), 0, (to - from) * sizeof(T));
+    }
+}
+
+
+
+
+
+template <typename T>
+void QVector<T>::copyConstruct(const T *srcFrom, const T *srcTo, T *dstFrom)
+{
+    if (QTypeInfo<T>::isComplex) {
+        while (srcFrom != srcTo)
+            new (dstFrom++) T(*srcFrom++);
+    } else {
+        ::memcpy(static_cast<void *>(dstFrom), static_cast<const void *>(srcFrom), (srcTo - srcFrom) * sizeof(T));
+    }
+}
+
+
+
+
+
+
+template <typename T>
+void QVector<T>::destruct(T *from, T *to)
+{
+    if (QTypeInfo<T>::isComplex) {
+        while (from != to) {
+            from++->~T();
+        }
+    }
+}
+
+
+
+
+
+template <typename T>
+inline QVector<T>::QVector(const QVector<T> &v)
+{
+    if (v.d->ref.ref()) {
+        d = v.d;
+    } else {
+        if (v.d->capacityReserved) {
+            d = Data::allocate(v.d->alloc);
+            do { if (!(d)) qBadAlloc(); } while (0);
+            d->capacityReserved = true;
+        } else {
+            d = Data::allocate(v.d->size);
+            do { if (!(d)) qBadAlloc(); } while (0);
+        }
+        if (d->alloc) {
+            copyConstruct(v.d->begin(), v.d->end(), d->begin());
+            d->size = v.d->size;
+        }
+    }
+}
+
+template <typename T>
+void QVector<T>::detach()
+{
+    if (!isDetached()) {
+
+        if (!d->alloc)
+            d = Data::unsharableEmpty();
+        else
+
+            reallocData(d->size, int(d->alloc));
+    }
+    do { } while ((false) && (isDetached()));
+}
+
+template <typename T>
+void QVector<T>::reserve(int asize)
+{
+    if (asize > int(d->alloc))
+        reallocData(d->size, asize);
+    if (isDetached())
+        d->capacityReserved = 1;
+    do { } while ((false) && (capacity() >= asize));
+}
+
+template <typename T>
+void QVector<T>::resize(int asize)
+{
+    int newAlloc;
+    const int oldAlloc = int(d->alloc);
+    QArrayData::AllocationOptions opt;
+
+    if (asize > oldAlloc) {
+        newAlloc = asize;
+        opt = QArrayData::Grow;
+    } else {
+        newAlloc = oldAlloc;
+    }
+    reallocData(asize, newAlloc, opt);
+}
+template <typename T>
+inline void QVector<T>::clear()
+{ resize(0); }
+template <typename T>
+inline const T &QVector<T>::at(int i) const
+{ do { } while ((false) && (i >= 0 && i < d->size));
+  return d->begin()[i]; }
+template <typename T>
+inline const T &QVector<T>::operator[](int i) const
+{ do { } while ((false) && (i >= 0 && i < d->size));
+  return d->begin()[i]; }
+template <typename T>
+inline T &QVector<T>::operator[](int i)
+{ do { } while ((false) && (i >= 0 && i < d->size));
+  return data()[i]; }
+template <typename T>
+inline void QVector<T>::insert(int i, const T &t)
+{ do { } while ((false) && (i >= 0 && i <= d->size));
+  insert(begin() + i, 1, t); }
+template <typename T>
+inline void QVector<T>::insert(int i, int n, const T &t)
+{ do { } while ((false) && (i >= 0 && i <= d->size));
+  insert(begin() + i, n, t); }
+template <typename T>
+inline void QVector<T>::remove(int i, int n)
+{ do { } while ((false) && (i >= 0 && n >= 0 && i + n <= d->size));
+  erase(d->begin() + i, d->begin() + i + n); }
+template <typename T>
+inline void QVector<T>::remove(int i)
+{ do { } while ((false) && (i >= 0 && i < d->size));
+  erase(d->begin() + i, d->begin() + i + 1); }
+template <typename T>
+inline void QVector<T>::prepend(const T &t)
+{ insert(begin(), 1, t); }
+
+template <typename T>
+inline void QVector<T>::replace(int i, const T &t)
+{
+    do { } while ((false) && (i >= 0 && i < d->size));
+    const T copy(t);
+    data()[i] = copy;
+}
+
+template <typename T>
+QVector<T> &QVector<T>::operator=(const QVector<T> &v)
+{
+    if (v.d != d) {
+        QVector<T> tmp(v);
+        tmp.swap(*this);
+    }
+    return *this;
+}
+
+template <typename T>
+QVector<T>::QVector(int asize)
+{
+    do { } while ((false) && (asize >= 0));
+    if (__builtin_expect(!!(asize > 0), true)) {
+        d = Data::allocate(asize);
+        do { if (!(d)) qBadAlloc(); } while (0);
+        d->size = asize;
+        defaultConstruct(d->begin(), d->end());
+    } else {
+        d = Data::sharedNull();
+    }
+}
+
+template <typename T>
+QVector<T>::QVector(int asize, const T &t)
+{
+    do { } while ((false) && (asize >= 0));
+    if (asize > 0) {
+        d = Data::allocate(asize);
+        do { if (!(d)) qBadAlloc(); } while (0);
+        d->size = asize;
+        T* i = d->end();
+        while (i != d->begin())
+            new (--i) T(t);
+    } else {
+        d = Data::sharedNull();
+    }
+}
+
+
+template <typename T>
+QVector<T>::QVector(std::initializer_list<T> args)
+{
+    if (args.size() > 0) {
+        d = Data::allocate(args.size());
+        do { if (!(d)) qBadAlloc(); } while (0);
+
+
+        copyConstruct(args.begin(), args.end(), d->begin());
+        d->size = int(args.size());
+    } else {
+        d = Data::sharedNull();
+    }
+}
+
+
+template <typename T>
+void QVector<T>::freeData(Data *x)
+{
+    destruct(x->begin(), x->end());
+    Data::deallocate(x);
+}
+
+template <typename T>
+void QVector<T>::reallocData(const int asize, const int aalloc, QArrayData::AllocationOptions options)
+{
+    do { } while ((false) && (asize >= 0 && asize <= aalloc));
+    Data *x = d;
+
+    const bool isShared = d->ref.isShared();
+
+    if (aalloc != 0) {
+        if (aalloc != int(d->alloc) || isShared) {
+            try {
+
+                x = Data::allocate(aalloc, options);
+                do { if (!(x)) qBadAlloc(); } while (0);
+
+
+                do { } while ((false) && (x->ref.isSharable() || options.testFlag(QArrayData::Unsharable)));
+
+                do { } while ((false) && (!x->ref.isStatic()));
+                x->size = asize;
+
+                T *srcBegin = d->begin();
+                T *srcEnd = asize > d->size ? d->end() : d->begin() + asize;
+                T *dst = x->begin();
+
+                if (QTypeInfo<T>::isStatic || (isShared && QTypeInfo<T>::isComplex)) {
+
+                    while (srcBegin != srcEnd) {
+                        new (dst++) T(*srcBegin++);
+                    }
+                } else {
+                    ::memcpy(static_cast<void *>(dst), static_cast<void *>(srcBegin), (srcEnd - srcBegin) * sizeof(T));
+                    dst += srcEnd - srcBegin;
+
+
+                    if (asize < d->size)
+                        destruct(d->begin() + asize, d->end());
+                }
+
+                if (asize > d->size) {
+
+                    try {
+                        defaultConstruct(dst, x->end());
+                    } catch (...) {
+
+                        destruct(x->begin(), dst);
+                        throw;
+                    }
+                }
+            } catch (...) {
+                Data::deallocate(x);
+                throw;
+            }
+            x->capacityReserved = d->capacityReserved;
+        } else {
+            do { } while ((false) && (int(d->alloc) == aalloc));
+            do { } while ((false) && (isDetached()));
+            do { } while ((false) && (x == d));
+            if (asize <= d->size) {
+                destruct(x->begin() + asize, x->end());
+            } else {
+                defaultConstruct(x->end(), x->begin() + asize);
+            }
+            x->size = asize;
+        }
+    } else {
+        x = Data::sharedNull();
+    }
+    if (d != x) {
+        if (!d->ref.deref()) {
+            if (QTypeInfo<T>::isStatic || !aalloc || (isShared && QTypeInfo<T>::isComplex)) {
+
+
+                freeData(d);
+            } else {
+                Data::deallocate(d);
+            }
+        }
+        d = x;
+    }
+
+    do { } while ((false) && (d->data()));
+    do { } while ((false) && (uint(d->size) <= d->alloc));
+
+    do { } while ((false) && (d != Data::unsharableEmpty()));
+
+    do { } while ((false) && (aalloc ? d != Data::sharedNull() : d == Data::sharedNull()));
+    do { } while ((false) && (d->alloc >= uint(aalloc)));
+    do { } while ((false) && (d->size == asize));
+}
+
+template<typename T>
+ T QVector<T>::value(int i) const
+{
+    if (uint(i) >= uint(d->size)) {
+        return T();
+    }
+    return d->begin()[i];
+}
+template<typename T>
+ T QVector<T>::value(int i, const T &defaultValue) const
+{
+    return uint(i) >= uint(d->size) ? defaultValue : d->begin()[i];
+}
+
+template <typename T>
+void QVector<T>::append(const T &t)
+{
+    const bool isTooSmall = uint(d->size + 1) > d->alloc;
+    if (!isDetached() || isTooSmall) {
+        T copy(t);
+        QArrayData::AllocationOptions opt(isTooSmall ? QArrayData::Grow : QArrayData::Default);
+        reallocData(d->size, isTooSmall ? d->size + 1 : d->alloc, opt);
+
+        if (QTypeInfo<T>::isComplex)
+            new (d->end()) T(std::move(copy));
+        else
+            *d->end() = std::move(copy);
+
+    } else {
+        if (QTypeInfo<T>::isComplex)
+            new (d->end()) T(t);
+        else
+            *d->end() = t;
+    }
+    ++d->size;
+}
+
+
+template <typename T>
+void QVector<T>::append(T &&t)
+{
+    const bool isTooSmall = uint(d->size + 1) > d->alloc;
+    if (!isDetached() || isTooSmall) {
+        QArrayData::AllocationOptions opt(isTooSmall ? QArrayData::Grow : QArrayData::Default);
+        reallocData(d->size, isTooSmall ? d->size + 1 : d->alloc, opt);
+    }
+
+    new (d->end()) T(std::move(t));
+
+    ++d->size;
+}
+
+
+template <typename T>
+void QVector<T>::removeLast()
+{
+    do { } while ((false) && (!isEmpty()));
+    do { } while ((false) && (d->alloc));
+
+    if (!d->ref.isShared()) {
+        --d->size;
+        if (QTypeInfo<T>::isComplex)
+            (d->data() + d->size)->~T();
+    } else {
+        reallocData(d->size - 1);
+    }
+}
+
+template <typename T>
+typename QVector<T>::iterator QVector<T>::insert(iterator before, size_type n, const T &t)
+{
+    do { } while ((false) && (isValidIterator(before)));
+
+    int offset = std::distance(d->begin(), before);
+    if (n != 0) {
+        const T copy(t);
+        if (!isDetached() || d->size + n > int(d->alloc))
+            reallocData(d->size, d->size + n, QArrayData::Grow);
+        if (QTypeInfo<T>::isStatic) {
+            T *b = d->end();
+            T *i = d->end() + n;
+            while (i != b)
+                new (--i) T;
+            i = d->end();
+            T *j = i + n;
+            b = d->begin() + offset;
+            while (i != b)
+                *--j = *--i;
+            i = b+n;
+            while (i != b)
+                *--i = copy;
+        } else {
+            T *b = d->begin() + offset;
+            T *i = b + n;
+            memmove(i, b, (d->size - offset) * sizeof(T));
+            while (i != b)
+                new (--i) T(copy);
+        }
+        d->size += n;
+    }
+    return d->begin() + offset;
+}
+
+template <typename T>
+typename QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend)
+{
+    do { } while ((false) && (isValidIterator(abegin)));
+    do { } while ((false) && (isValidIterator(aend)));
+
+    const int itemsToErase = aend - abegin;
+
+    if (!itemsToErase)
+        return abegin;
+
+    do { } while ((false) && (abegin >= d->begin()));
+    do { } while ((false) && (aend <= d->end()));
+    do { } while ((false) && (abegin <= aend));
+
+    const int itemsUntouched = abegin - d->begin();
+
+
+
+
+    if (d->alloc) {
+        detach();
+        abegin = d->begin() + itemsUntouched;
+        aend = abegin + itemsToErase;
+        if (QTypeInfo<T>::isStatic) {
+            iterator moveBegin = abegin + itemsToErase;
+            iterator moveEnd = d->end();
+            while (moveBegin != moveEnd) {
+                if (QTypeInfo<T>::isComplex)
+                    static_cast<T *>(abegin)->~T();
+                new (abegin++) T(*moveBegin++);
+            }
+            if (abegin < d->end()) {
+
+                destruct(abegin, d->end());
+            }
+        } else {
+            destruct(abegin, aend);
+            memmove(abegin, aend, (d->size - itemsToErase - itemsUntouched) * sizeof(T));
+        }
+        d->size -= itemsToErase;
+    }
+    return d->begin() + itemsUntouched;
+}
+
+template <typename T>
+bool QVector<T>::operator==(const QVector<T> &v) const
+{
+    if (d == v.d)
+        return true;
+    if (d->size != v.d->size)
+        return false;
+    const T *vb = v.d->begin();
+    const T *b = d->begin();
+    const T *e = d->end();
+    return std::equal(b, e, vb);
+}
+
+template <typename T>
+QVector<T> &QVector<T>::fill(const T &from, int asize)
+{
+    const T copy(from);
+    resize(asize < 0 ? d->size : asize);
+    if (d->size) {
+        T *i = d->end();
+        T *b = d->begin();
+        while (i != b)
+            *--i = copy;
+    }
+    return *this;
+}
+
+template <typename T>
+QVector<T> &QVector<T>::operator+=(const QVector &l)
+{
+    uint newSize = d->size + l.d->size;
+    const bool isTooSmall = newSize > d->alloc;
+    if (!isDetached() || isTooSmall) {
+        QArrayData::AllocationOptions opt(isTooSmall ? QArrayData::Grow : QArrayData::Default);
+        reallocData(d->size, isTooSmall ? newSize : d->alloc, opt);
+    }
+
+    if (d->alloc) {
+        T *w = d->begin() + newSize;
+        T *i = l.d->end();
+        T *b = l.d->begin();
+        while (i != b) {
+            if (QTypeInfo<T>::isComplex)
+                new (--w) T(*--i);
+            else
+                *--w = *--i;
+        }
+        d->size = newSize;
+    }
+    return *this;
+}
+
+template <typename T>
+int QVector<T>::indexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from = qMax(from + d->size, 0);
+    if (from < d->size) {
+        T* n = d->begin() + from - 1;
+        T* e = d->end();
+        while (++n != e)
+            if (*n == t)
+                return n - d->begin();
+    }
+    return -1;
+}
+
+template <typename T>
+int QVector<T>::lastIndexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from += d->size;
+    else if (from >= d->size)
+        from = d->size-1;
+    if (from >= 0) {
+        T* b = d->begin();
+        T* n = d->begin() + from + 1;
+        while (n != b) {
+            if (*--n == t)
+                return n - b;
+        }
+    }
+    return -1;
+}
+
+template <typename T>
+bool QVector<T>::contains(const T &t) const
+{
+    const T *b = d->begin();
+    const T *e = d->end();
+    return std::find(b, e, t) != e;
+}
+
+template <typename T>
+int QVector<T>::count(const T &t) const
+{
+    const T *b = d->begin();
+    const T *e = d->end();
+    return int(std::count(b, e, t));
+}
+
+template <typename T>
+ QVector<T> QVector<T>::mid(int pos, int len) const
+{
+    using namespace QtPrivate;
+    switch (QContainerImplHelper::mid(d->size, &pos, &len)) {
+    case QContainerImplHelper::Null:
+    case QContainerImplHelper::Empty:
+        return QVector<T>();
+    case QContainerImplHelper::Full:
+        return *this;
+    case QContainerImplHelper::Subset:
+        break;
+    }
+
+    QVector<T> midResult;
+    midResult.reallocData(0, len);
+    T *srcFrom = d->begin() + pos;
+    T *srcTo = d->begin() + pos + len;
+    midResult.copyConstruct(srcFrom, srcTo, midResult.data());
+    midResult.d->size = len;
+    return midResult;
+}
+
+template <typename T>
+ QList<T> QVector<T>::toList() const
+{
+    QList<T> result;
+    result.reserve(size());
+    for (int i = 0; i < size(); ++i)
+        result.append(at(i));
+    return result;
+}
+
+template <typename T>
+ QVector<T> QList<T>::toVector() const
+{
+    QVector<T> result(size());
+    for (int i = 0; i < size(); ++i)
+        result[i] = at(i);
+    return result;
+}
+
+template <typename T>
+QVector<T> QVector<T>::fromList(const QList<T> &list)
+{
+    return list.toVector();
+}
+
+template <typename T>
+QList<T> QList<T>::fromVector(const QVector<T> &vector)
+{
+    return vector.toList();
+}
+
+template <class T> class QVectorIterator { typedef typename QVector<T>::const_iterator const_iterator; QVector<T> c; const_iterator i; public: inline QVectorIterator(const QVector<T> &container) : c(container), i(c.constBegin()) {} inline QVectorIterator &operator=(const QVector<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 QMutableVectorIterator { typedef typename QVector<T>::iterator iterator; typedef typename QVector<T>::const_iterator const_iterator; QVector<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableVectorIterator(QVector<T> &container) : c(&container) { i = c->begin(); n = c->end(); } inline QMutableVectorIterator &operator=(QVector<T> &container) { c = &container; 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() { do { } while ((false) && (item_exists())); return *n; } inline const T &value() const { do { } while ((false) && (item_exists())); 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; } };
+
+template <typename T>
+uint qHash(const QVector<T> &key, uint seed = 0)
+    noexcept(noexcept(qHashRange(key.cbegin(), key.cend(), seed)))
+{
+    return qHashRange(key.cbegin(), key.cend(), seed);
+}
+
+template <typename T>
+bool operator<(const QVector<T> &lhs, const QVector<T> &rhs)
+    noexcept(noexcept(std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end())))
+
+{
+    return std::lexicographical_compare(lhs.begin(), lhs.end(),
+                                        rhs.begin(), rhs.end());
+}
+
+template <typename T>
+inline bool operator>(const QVector<T> &lhs, const QVector<T> &rhs)
+    noexcept(noexcept(lhs < rhs))
+{
+    return rhs < lhs;
+}
+
+template <typename T>
+inline bool operator<=(const QVector<T> &lhs, const QVector<T> &rhs)
+    noexcept(noexcept(lhs < rhs))
+{
+    return !(lhs > rhs);
+}
+
+template <typename T>
+inline bool operator>=(const QVector<T> &lhs, const QVector<T> &rhs)
+    noexcept(noexcept(lhs < rhs))
+{
+    return !(lhs < rhs);
+}
+# 982 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qvector.h"
+
+# 1 "../../include/QtCore/qvector.h" 2
+# 52 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+# 1 "../../include/QtCore/qset.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qset.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qset.h"
+# 1 "../../include/QtCore/qhash.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qset.h" 2
+
+
+
+
+
+
+
+
+
+template <class T>
+class QSet
+{
+    typedef QHash<T, QHashDummyValue> Hash;
+
+public:
+    inline QSet() noexcept {}
+
+    inline QSet(std::initializer_list<T> list)
+    {
+        reserve(int(list.size()));
+        for (typename std::initializer_list<T>::const_iterator it = list.begin(); it != list.end(); ++it)
+            insert(*it);
+    }
+
+
+
+
+    inline void swap(QSet<T> &other) noexcept { q_hash.swap(other.q_hash); }
+
+    inline bool operator==(const QSet<T> &other) const
+        { return q_hash == other.q_hash; }
+    inline bool operator!=(const QSet<T> &other) const
+        { return q_hash != other.q_hash; }
+
+    inline int size() const { return q_hash.size(); }
+
+    inline bool isEmpty() const { return q_hash.isEmpty(); }
+
+    inline int capacity() const { return q_hash.capacity(); }
+    inline void reserve(int size);
+    inline void squeeze() { q_hash.squeeze(); }
+
+    inline void detach() { q_hash.detach(); }
+    inline bool isDetached() const { return q_hash.isDetached(); }
+
+    inline void setSharable(bool sharable) { q_hash.setSharable(sharable); }
+
+
+    inline void clear() { q_hash.clear(); }
+
+    inline bool remove(const T &value) { return q_hash.remove(value) != 0; }
+
+    inline bool contains(const T &value) const { return q_hash.contains(value); }
+
+    bool contains(const QSet<T> &set) const;
+
+    class const_iterator;
+
+    class iterator
+    {
+        typedef QHash<T, QHashDummyValue> Hash;
+        typename Hash::iterator i;
+        friend class const_iterator;
+        friend class QSet<T>;
+
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+
+        inline iterator() {}
+        inline iterator(typename Hash::iterator o) : i(o) {}
+        inline iterator(const iterator &o) : i(o.i) {}
+        inline iterator &operator=(const iterator &o) { i = o.i; return *this; }
+        inline const T &operator*() const { return i.key(); }
+        inline const T *operator->() const { return &i.key(); }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+        inline iterator &operator++() { ++i; return *this; }
+        inline iterator operator++(int) { iterator r = *this; ++i; return r; }
+        inline iterator &operator--() { --i; return *this; }
+        inline iterator operator--(int) { iterator r = *this; --i; return r; }
+        inline iterator operator+(int j) const { return i + j; }
+        inline iterator operator-(int j) const { return i - j; }
+        inline iterator &operator+=(int j) { i += j; return *this; }
+        inline iterator &operator-=(int j) { i -= j; return *this; }
+    };
+
+    class const_iterator
+    {
+        typedef QHash<T, QHashDummyValue> Hash;
+        typename Hash::const_iterator i;
+        friend class iterator;
+        friend class QSet<T>;
+
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef qptrdiff difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+
+        inline const_iterator() {}
+        inline const_iterator(typename Hash::const_iterator o) : i(o) {}
+        inline const_iterator(const const_iterator &o) : i(o.i) {}
+        inline const_iterator(const iterator &o)
+            : i(o.i) {}
+        inline const_iterator &operator=(const const_iterator &o) { i = o.i; return *this; }
+        inline const T &operator*() const { return i.key(); }
+        inline const T *operator->() const { return &i.key(); }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+        inline const_iterator &operator++() { ++i; return *this; }
+        inline const_iterator operator++(int) { const_iterator r = *this; ++i; return r; }
+        inline const_iterator &operator--() { --i; return *this; }
+        inline const_iterator operator--(int) { const_iterator r = *this; --i; return r; }
+        inline const_iterator operator+(int j) const { return i + j; }
+        inline const_iterator operator-(int j) const { return i - j; }
+        inline const_iterator &operator+=(int j) { i += j; return *this; }
+        inline const_iterator &operator-=(int j) { i -= j; return *this; }
+    };
+
+
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+    inline iterator begin() { return q_hash.begin(); }
+    inline const_iterator begin() const noexcept { return q_hash.begin(); }
+    inline const_iterator cbegin() const noexcept { return q_hash.begin(); }
+    inline const_iterator constBegin() const noexcept { return q_hash.constBegin(); }
+    inline iterator end() { return q_hash.end(); }
+    inline const_iterator end() const noexcept { return q_hash.end(); }
+    inline const_iterator cend() const noexcept { return q_hash.end(); }
+    inline const_iterator constEnd() const noexcept { return q_hash.constEnd(); }
+
+    reverse_iterator rbegin() { return reverse_iterator(end()); }
+    reverse_iterator rend() { return reverse_iterator(begin()); }
+    const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
+    const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
+    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
+    const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
+
+    iterator erase(iterator i)
+    { return erase(m2c(i)); }
+    iterator erase(const_iterator i)
+    {
+        do { } while ((false) && (isValidIterator(i)));
+        return q_hash.erase(reinterpret_cast<typename Hash::const_iterator &>(i));
+    }
+
+
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return q_hash.count(); }
+    inline iterator insert(const T &value)
+        { return static_cast<typename Hash::iterator>(q_hash.insert(value, QHashDummyValue())); }
+    iterator find(const T &value) { return q_hash.find(value); }
+    const_iterator find(const T &value) const { return q_hash.find(value); }
+    inline const_iterator constFind(const T &value) const { return find(value); }
+    QSet<T> &unite(const QSet<T> &other);
+    QSet<T> &intersect(const QSet<T> &other);
+    bool intersects(const QSet<T> &other) const;
+    QSet<T> &subtract(const QSet<T> &other);
+
+
+    typedef T key_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef qptrdiff difference_type;
+    typedef int size_type;
+
+    inline bool empty() const { return isEmpty(); }
+
+    inline QSet<T> &operator<<(const T &value) { insert(value); return *this; }
+    inline QSet<T> &operator|=(const QSet<T> &other) { unite(other); return *this; }
+    inline QSet<T> &operator|=(const T &value) { insert(value); return *this; }
+    inline QSet<T> &operator&=(const QSet<T> &other) { intersect(other); return *this; }
+    inline QSet<T> &operator&=(const T &value)
+        { QSet<T> result; if (contains(value)) result.insert(value); return (*this = result); }
+    inline QSet<T> &operator+=(const QSet<T> &other) { unite(other); return *this; }
+    inline QSet<T> &operator+=(const T &value) { insert(value); return *this; }
+    inline QSet<T> &operator-=(const QSet<T> &other) { subtract(other); return *this; }
+    inline QSet<T> &operator-=(const T &value) { remove(value); return *this; }
+    inline QSet<T> operator|(const QSet<T> &other) const
+        { QSet<T> result = *this; result |= other; return result; }
+    inline QSet<T> operator&(const QSet<T> &other) const
+        { QSet<T> result = *this; result &= other; return result; }
+    inline QSet<T> operator+(const QSet<T> &other) const
+        { QSet<T> result = *this; result += other; return result; }
+    inline QSet<T> operator-(const QSet<T> &other) const
+        { QSet<T> result = *this; result -= other; return result; }
+
+    QList<T> toList() const;
+    inline QList<T> values() const { return toList(); }
+
+    static QSet<T> fromList(const QList<T> &list);
+
+private:
+    Hash q_hash;
+
+    static const_iterator m2c(iterator it) noexcept
+    { return const_iterator(typename Hash::const_iterator(it.i.i)); }
+
+    bool isValidIterator(const iterator &i) const
+    {
+        return q_hash.isValidIterator(reinterpret_cast<const typename Hash::iterator&>(i));
+    }
+    bool isValidIterator(const const_iterator &i) const noexcept
+    {
+        return q_hash.isValidIterator(reinterpret_cast<const typename Hash::const_iterator&>(i));
+    }
+};
+
+template <typename T>
+uint qHash(const QSet<T> &key, uint seed = 0)
+noexcept(noexcept(qHashRangeCommutative(key.begin(), key.end(), seed)))
+{
+    return qHashRangeCommutative(key.begin(), key.end(), seed);
+}
+
+
+
+template <class T>
+inline void QSet<T>::reserve(int asize) { q_hash.reserve(asize); }
+
+template <class T>
+inline QSet<T> &QSet<T>::unite(const QSet<T> &other)
+{
+    QSet<T> copy(other);
+    typename QSet<T>::const_iterator i = copy.constEnd();
+    while (i != copy.constBegin()) {
+        --i;
+        insert(*i);
+    }
+    return *this;
+}
+
+template <class T>
+inline QSet<T> &QSet<T>::intersect(const QSet<T> &other)
+{
+    QSet<T> copy1;
+    QSet<T> copy2;
+    if (size() <= other.size()) {
+        copy1 = *this;
+        copy2 = other;
+    } else {
+        copy1 = other;
+        copy2 = *this;
+        *this = copy1;
+    }
+    typename QSet<T>::const_iterator i = copy1.constEnd();
+    while (i != copy1.constBegin()) {
+        --i;
+        if (!copy2.contains(*i))
+            remove(*i);
+    }
+    return *this;
+}
+
+template <class T>
+inline bool QSet<T>::intersects(const QSet<T> &other) const
+{
+    const bool otherIsBigger = other.size() > size();
+    const QSet &smallestSet = otherIsBigger ? *this : other;
+    const QSet &biggestSet = otherIsBigger ? other : *this;
+    const bool equalSeeds = q_hash.d->seed == other.q_hash.d->seed;
+    typename QSet::const_iterator i = smallestSet.cbegin();
+    typename QSet::const_iterator e = smallestSet.cend();
+
+    if (__builtin_expect(!!(equalSeeds), true)) {
+
+        while (i != e) {
+            if (*biggestSet.q_hash.findNode(*i, i.i.i->h) != biggestSet.q_hash.e)
+                return true;
+            ++i;
+        }
+    } else {
+        while (i != e) {
+            if (biggestSet.contains(*i))
+                return true;
+            ++i;
+        }
+     }
+
+    return false;
+}
+
+template <class T>
+inline QSet<T> &QSet<T>::subtract(const QSet<T> &other)
+{
+    QSet<T> copy1(*this);
+    QSet<T> copy2(other);
+    typename QSet<T>::const_iterator i = copy1.constEnd();
+    while (i != copy1.constBegin()) {
+        --i;
+        if (copy2.contains(*i))
+            remove(*i);
+    }
+    return *this;
+}
+
+template <class T>
+inline bool QSet<T>::contains(const QSet<T> &other) const
+{
+    typename QSet<T>::const_iterator i = other.constBegin();
+    while (i != other.constEnd()) {
+        if (!contains(*i))
+            return false;
+        ++i;
+    }
+    return true;
+}
+
+template <typename T>
+ QList<T> QSet<T>::toList() const
+{
+    QList<T> result;
+    result.reserve(size());
+    typename QSet<T>::const_iterator i = constBegin();
+    while (i != constEnd()) {
+        result.append(*i);
+        ++i;
+    }
+    return result;
+}
+
+template <typename T>
+ QSet<T> QList<T>::toSet() const
+{
+    QSet<T> result;
+    result.reserve(size());
+    for (int i = 0; i < size(); ++i)
+        result.insert(at(i));
+    return result;
+}
+
+template <typename T>
+QSet<T> QSet<T>::fromList(const QList<T> &list)
+{
+    return list.toSet();
+}
+
+template <typename T>
+QList<T> QList<T>::fromSet(const QSet<T> &set)
+{
+    return set.toList();
+}
+
+template <class T> class QSetIterator { typedef typename QSet<T>::const_iterator const_iterator; QSet<T> c; const_iterator i; public: inline QSetIterator(const QSet<T> &container) : c(container), i(c.constBegin()) {} inline QSetIterator &operator=(const QSet<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 <typename T>
+class QMutableSetIterator
+{
+    typedef typename QSet<T>::iterator iterator;
+    QSet<T> *c;
+    iterator i, n;
+    inline bool item_exists() const { return c->constEnd() != n; }
+
+public:
+    inline QMutableSetIterator(QSet<T> &container)
+        : c(&container)
+    { i = c->begin(); n = c->end(); }
+    inline QMutableSetIterator &operator=(QSet<T> &container)
+    { c = &container; i = c->begin(); n = c->end(); return *this; }
+    inline void toFront() { i = c->begin(); n = c->end(); }
+    inline void toBack() { i = c->end(); n = i; }
+    inline bool hasNext() const { return c->constEnd() != i; }
+    inline const T &next() { n = i++; return *n; }
+    inline const T &peekNext() const { return *i; }
+    inline bool hasPrevious() const { return c->constBegin() != i; }
+    inline const T &previous() { n = --i; return *n; }
+    inline const T &peekPrevious() const { iterator p = i; return *--p; }
+    inline void remove()
+    { if (c->constEnd() != n) { i = c->erase(n); n = c->end(); } }
+    inline const T &value() const { do { } while ((false) && (item_exists())); return *n; }
+    inline bool findNext(const T &t)
+    { while (c->constEnd() != (n = i)) if (*i++ == t) return true; return false; }
+    inline bool findPrevious(const T &t)
+    { while (c->constBegin() != i) if (*(n = --i) == t) return true;
+      n = c->end(); return false; }
+};
+
+
+# 1 "../../include/QtCore/qset.h" 2
+# 53 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+# 1 "../../include/QtCore/qcontiguouscache.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qcontiguouscache.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qcontiguouscache.h"
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+# 1 "../../include/QtCore/qatomic.h" 2
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qcontiguouscache.h" 2
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/limits.h" 1 3 4
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/tools/qcontiguouscache.h" 2
+
+
+
+
+
+
+
+struct __attribute__((visibility("default"))) QContiguousCacheData
+{
+    QBasicAtomicInt ref;
+    int alloc;
+    int count;
+    int start;
+    int offset;
+    uint sharable : 1;
+    uint reserved : 31;
+
+
+
+
+
+
+    static QContiguousCacheData *allocateData(int size, int alignment);
+    static void freeData(QContiguousCacheData *data);
+
+
+
+
+};
+
+template <typename T>
+struct QContiguousCacheTypedData: private QContiguousCacheData
+{
+
+    T array[1];
+
+    static inline void freeData(QContiguousCacheTypedData *data) { QContiguousCacheData::freeData(data); }
+};
+
+template<typename T>
+class QContiguousCache {
+    typedef QContiguousCacheTypedData<T> Data;
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; };
+public:
+
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef qptrdiff difference_type;
+    typedef int size_type;
+
+    explicit QContiguousCache(int capacity = 0);
+    QContiguousCache(const QContiguousCache<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
+
+    inline ~QContiguousCache() { if (!d) return; if (!d->ref.deref()) freeData(p); }
+
+    inline void detach() { if (d->ref.load() != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref.load() == 1; }
+
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+
+
+    QContiguousCache<T> &operator=(const QContiguousCache<T> &other);
+
+    inline QContiguousCache<T> &operator=(QContiguousCache<T> &&other)
+    { qSwap(d, other.d); return *this; }
+
+    inline void swap(QContiguousCache<T> &other) { qSwap(d, other.d); }
+    bool operator==(const QContiguousCache<T> &other) const;
+    inline bool operator!=(const QContiguousCache<T> &other) const { return !(*this == other); }
+
+    inline int capacity() const {return d->alloc; }
+    inline int count() const { return d->count; }
+    inline int size() const { return d->count; }
+
+    inline bool isEmpty() const { return d->count == 0; }
+    inline bool isFull() const { return d->count == d->alloc; }
+    inline int available() const { return d->alloc - d->count; }
+
+    void clear();
+    void setCapacity(int size);
+
+    const T &at(int pos) const;
+    T &operator[](int i);
+    const T &operator[](int i) const;
+
+    void append(const T &value);
+    void prepend(const T &value);
+    void insert(int pos, const T &value);
+
+    inline bool containsIndex(int pos) const { return pos >= d->offset && pos - d->offset < d->count; }
+    inline int firstIndex() const { return d->offset; }
+    inline int lastIndex() const { return d->offset + d->count - 1; }
+
+    inline const T &first() const { do { } while ((false) && (!isEmpty())); return p->array[d->start]; }
+    inline const T &last() const { do { } while ((false) && (!isEmpty())); return p->array[(d->start + d->count -1) % d->alloc]; }
+    inline T &first() { do { } while ((false) && (!isEmpty())); detach(); return p->array[d->start]; }
+    inline T &last() { do { } while ((false) && (!isEmpty())); detach(); return p->array[(d->start + d->count -1) % d->alloc]; }
+
+    void removeFirst();
+    T takeFirst();
+    void removeLast();
+    T takeLast();
+
+    inline bool areIndexesValid() const
+    { return d->offset >= 0 && d->offset < 0x7fffffff - d->count && (d->offset % d->alloc) == d->start; }
+
+    inline void normalizeIndexes() { d->offset = d->start; }
+
+
+
+
+private:
+    void detach_helper();
+
+    QContiguousCacheData *allocateData(int aalloc);
+    void freeData(Data *x);
+    int sizeOfTypedData() {
+
+
+        return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
+    }
+    int alignOfTypedData() const
+    {
+        return qMax<int>(sizeof(void*), __alignof__(Data));
+    }
+};
+
+template <typename T>
+void QContiguousCache<T>::detach_helper()
+{
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+
+    x.d = allocateData(d->alloc);
+    x.d->ref.store(1);
+    x.d->count = d->count;
+    x.d->start = d->start;
+    x.d->offset = d->offset;
+    x.d->alloc = d->alloc;
+    x.d->sharable = true;
+    x.d->reserved = 0;
+
+    T *dest = x.p->array + x.d->start;
+    T *src = p->array + d->start;
+    int oldcount = x.d->count;
+    while (oldcount--) {
+        if (QTypeInfo<T>::isComplex) {
+            new (dest) T(*src);
+        } else {
+            *dest = *src;
+        }
+        dest++;
+        if (dest == x.p->array + x.d->alloc)
+            dest = x.p->array;
+        src++;
+        if (src == p->array + d->alloc)
+            src = p->array;
+    }
+
+    if (!d->ref.deref())
+        freeData(p);
+    d = x.d;
+}
+
+template <typename T>
+void QContiguousCache<T>::setCapacity(int asize)
+{
+    if (asize == d->alloc)
+        return;
+    detach();
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+    x.d = allocateData(asize);
+    x.d->alloc = asize;
+    x.d->count = qMin(d->count, asize);
+    x.d->offset = d->offset + d->count - x.d->count;
+    if(asize)
+        x.d->start = x.d->offset % x.d->alloc;
+    else
+        x.d->start = 0;
+
+    int oldcount = x.d->count;
+    if(oldcount)
+    {
+        T *dest = x.p->array + (x.d->start + x.d->count-1) % x.d->alloc;
+        T *src = p->array + (d->start + d->count-1) % d->alloc;
+        while (oldcount--) {
+            if (QTypeInfo<T>::isComplex) {
+                new (dest) T(*src);
+            } else {
+                *dest = *src;
+            }
+            if (dest == x.p->array)
+                dest = x.p->array + x.d->alloc;
+            dest--;
+            if (src == p->array)
+                src = p->array + d->alloc;
+            src--;
+        }
+    }
+
+    freeData(p);
+    d = x.d;
+}
+
+template <typename T>
+void QContiguousCache<T>::clear()
+{
+    if (d->ref.load() == 1) {
+        if (QTypeInfo<T>::isComplex) {
+            int oldcount = d->count;
+            T * i = p->array + d->start;
+            T * e = p->array + d->alloc;
+            while (oldcount--) {
+                i->~T();
+                i++;
+                if (i == e)
+                    i = p->array;
+            }
+        }
+        d->count = d->start = d->offset = 0;
+    } else {
+        union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+        x.d = allocateData(d->alloc);
+        x.d->ref.store(1);
+        x.d->alloc = d->alloc;
+        x.d->count = x.d->start = x.d->offset = 0;
+        x.d->sharable = true;
+        if (!d->ref.deref()) freeData(p);
+        d = x.d;
+    }
+}
+
+template <typename T>
+inline QContiguousCacheData *QContiguousCache<T>::allocateData(int aalloc)
+{
+    return QContiguousCacheData::allocateData(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
+}
+
+template <typename T>
+QContiguousCache<T>::QContiguousCache(int cap)
+{
+    d = allocateData(cap);
+    d->ref.store(1);
+    d->alloc = cap;
+    d->count = d->start = d->offset = 0;
+    d->sharable = true;
+}
+
+template <typename T>
+QContiguousCache<T> &QContiguousCache<T>::operator=(const QContiguousCache<T> &other)
+{
+    other.d->ref.ref();
+    if (!d->ref.deref())
+        freeData(p);
+    d = other.d;
+    if (!d->sharable)
+        detach_helper();
+    return *this;
+}
+
+template <typename T>
+bool QContiguousCache<T>::operator==(const QContiguousCache<T> &other) const
+{
+    if (other.d == d)
+        return true;
+    if (other.d->start != d->start
+            || other.d->count != d->count
+            || other.d->offset != d->offset
+            || other.d->alloc != d->alloc)
+        return false;
+    for (int i = firstIndex(); i <= lastIndex(); ++i)
+        if (!(at(i) == other.at(i)))
+            return false;
+    return true;
+}
+
+template <typename T>
+void QContiguousCache<T>::freeData(Data *x)
+{
+    if (QTypeInfo<T>::isComplex) {
+        int oldcount = d->count;
+        T * i = p->array + d->start;
+        T * e = p->array + d->alloc;
+        while (oldcount--) {
+            i->~T();
+            i++;
+            if (i == e)
+                i = p->array;
+        }
+    }
+    x->freeData(x);
+}
+template <typename T>
+void QContiguousCache<T>::append(const T &value)
+{
+    if (!d->alloc)
+        return;
+    detach();
+    if (QTypeInfo<T>::isComplex) {
+        if (d->count == d->alloc)
+            (p->array + (d->start+d->count) % d->alloc)->~T();
+        new (p->array + (d->start+d->count) % d->alloc) T(value);
+    } else {
+        p->array[(d->start+d->count) % d->alloc] = value;
+    }
+
+    if (d->count == d->alloc) {
+        d->start++;
+        d->start %= d->alloc;
+        d->offset++;
+    } else {
+        d->count++;
+    }
+}
+
+template<typename T>
+void QContiguousCache<T>::prepend(const T &value)
+{
+    if (!d->alloc)
+        return;
+    detach();
+    if (d->start)
+        d->start--;
+    else
+        d->start = d->alloc-1;
+    d->offset--;
+
+    if (d->count != d->alloc)
+        d->count++;
+    else
+        if (d->count == d->alloc)
+            (p->array + d->start)->~T();
+
+    if (QTypeInfo<T>::isComplex)
+        new (p->array + d->start) T(value);
+    else
+        p->array[d->start] = value;
+}
+
+template<typename T>
+void QContiguousCache<T>::insert(int pos, const T &value)
+{
+    do { } while ((false) && (pos >= 0 && pos < 0x7fffffff));
+    if (!d->alloc)
+        return;
+    detach();
+    if (containsIndex(pos)) {
+        if (QTypeInfo<T>::isComplex) {
+            (p->array + pos % d->alloc)->~T();
+            new (p->array + pos % d->alloc) T(value);
+        } else {
+            p->array[pos % d->alloc] = value;
+        }
+    } else if (pos == d->offset-1)
+        prepend(value);
+    else if (pos == d->offset+d->count)
+        append(value);
+    else {
+
+        clear();
+        d->offset = pos;
+        d->start = pos % d->alloc;
+        d->count = 1;
+        if (QTypeInfo<T>::isComplex)
+            new (p->array + d->start) T(value);
+        else
+            p->array[d->start] = value;
+    }
+}
+
+template <typename T>
+inline const T &QContiguousCache<T>::at(int pos) const
+{ do { } while ((false) && (pos >= d->offset && pos - d->offset < d->count)); return p->array[pos % d->alloc]; }
+template <typename T>
+inline const T &QContiguousCache<T>::operator[](int pos) const
+{ do { } while ((false) && (pos >= d->offset && pos - d->offset < d->count)); return p->array[pos % d->alloc]; }
+
+template <typename T>
+inline T &QContiguousCache<T>::operator[](int pos)
+{
+    detach();
+    if (!containsIndex(pos))
+        insert(pos, T());
+    return p->array[pos % d->alloc];
+}
+
+template <typename T>
+inline void QContiguousCache<T>::removeFirst()
+{
+    do { } while ((false) && (d->count > 0));
+    detach();
+    d->count--;
+    if (QTypeInfo<T>::isComplex)
+        (p->array + d->start)->~T();
+    d->start = (d->start + 1) % d->alloc;
+    d->offset++;
+}
+
+template <typename T>
+inline void QContiguousCache<T>::removeLast()
+{
+    do { } while ((false) && (d->count > 0));
+    detach();
+    d->count--;
+    if (QTypeInfo<T>::isComplex)
+        (p->array + (d->start + d->count) % d->alloc)->~T();
+}
+
+template <typename T>
+inline T QContiguousCache<T>::takeFirst()
+{ T t = first(); removeFirst(); return t; }
+
+template <typename T>
+inline T QContiguousCache<T>::takeLast()
+{ T t = last(); removeLast(); return t; }
+
+
+# 1 "../../include/QtCore/qcontiguouscache.h" 2
+# 54 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h" 2
+
+
+
+
+
+
+
+
+
+
+class __attribute__((visibility("default"))) QDebug
+{
+    friend class QMessageLogger;
+    friend class QDebugStateSaverPrivate;
+    struct Stream {
+        enum { DefaultVerbosity = 2, VerbosityShift = 29, VerbosityMask = 0x7 };
+
+        Stream(QIODevice *device) : ts(device), ref(1), type(QtDebugMsg),
+            space(true), message_output(false), flags(DefaultVerbosity << VerbosityShift) {}
+        Stream(QString *string) : ts(string, QIODevice::WriteOnly), ref(1), type(QtDebugMsg),
+            space(true), message_output(false), flags(DefaultVerbosity << VerbosityShift) {}
+        Stream(QtMsgType t) : ts(&buffer, QIODevice::WriteOnly), ref(1), type(t),
+            space(true), message_output(true), flags(DefaultVerbosity << VerbosityShift) {}
+        QTextStream ts;
+        QString buffer;
+        int ref;
+        QtMsgType type;
+        bool space;
+        bool message_output;
+        QMessageLogContext context;
+
+        enum FormatFlag {
+            NoQuotes = 0x1
+        };
+
+
+        bool testFlag(FormatFlag flag) const { return (context.version > 1) ? (flags & flag) : false; }
+        void setFlag(FormatFlag flag) { if (context.version > 1) { flags |= flag; } }
+        void unsetFlag(FormatFlag flag) { if (context.version > 1) { flags &= ~flag; } }
+        int verbosity() const
+        { return context.version > 1 ? (flags >> VerbosityShift) & VerbosityMask : int(Stream::DefaultVerbosity); }
+        void setVerbosity(int v)
+        {
+            if (context.version > 1) {
+                flags &= ~(VerbosityMask << VerbosityShift);
+                flags |= (v & VerbosityMask) << VerbosityShift;
+            }
+        }
+
+        int flags;
+    } *stream;
+
+    enum Latin1Content { ContainsBinary = 0, ContainsLatin1 };
+
+    void putUcs4(uint ucs4);
+    void putString(const QChar *begin, size_t length);
+    void putByteArray(const char *begin, size_t length, Latin1Content content);
+public:
+    inline QDebug(QIODevice *device) : stream(new Stream(device)) {}
+    inline QDebug(QString *string) : stream(new Stream(string)) {}
+    inline QDebug(QtMsgType t) : stream(new Stream(t)) {}
+    inline QDebug(const QDebug &o):stream(o.stream) { ++stream->ref; }
+    inline QDebug &operator=(const QDebug &other);
+    ~QDebug();
+    inline void swap(QDebug &other) noexcept { qSwap(stream, other.stream); }
+
+    QDebug &resetFormat();
+
+    inline QDebug &space() { stream->space = true; stream->ts << ' '; return *this; }
+    inline QDebug &nospace() { stream->space = false; return *this; }
+    inline QDebug &maybeSpace() { if (stream->space) stream->ts << ' '; return *this; }
+    int verbosity() const { return stream->verbosity(); }
+    void setVerbosity(int verbosityLevel) { stream->setVerbosity(verbosityLevel); }
+
+    bool autoInsertSpaces() const { return stream->space; }
+    void setAutoInsertSpaces(bool b) { stream->space = b; }
+
+    inline QDebug &quote() { stream->unsetFlag(Stream::NoQuotes); return *this; }
+    inline QDebug &noquote() { stream->setFlag(Stream::NoQuotes); return *this; }
+    inline QDebug &maybeQuote(char c = '"') { if (!(stream->testFlag(Stream::NoQuotes))) stream->ts << c; return *this; }
+
+    inline QDebug &operator<<(QChar t) { putUcs4(t.unicode()); return maybeSpace(); }
+    inline QDebug &operator<<(bool t) { stream->ts << (t ? "true" : "false"); return maybeSpace(); }
+    inline QDebug &operator<<(char t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed short t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned short t) { stream->ts << t; return maybeSpace(); }
+
+    inline QDebug &operator<<(char16_t t) { return *this << QChar(t); }
+    inline QDebug &operator<<(char32_t t) { putUcs4(t); return maybeSpace(); }
+
+    inline QDebug &operator<<(signed int t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned int t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed long t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned long t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(qint64 t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(quint64 t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(float t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(double t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(const char* t) { stream->ts << QString::fromUtf8(t); return maybeSpace(); }
+    inline QDebug &operator<<(const QString & t) { putString(t.constData(), uint(t.length())); return maybeSpace(); }
+    inline QDebug &operator<<(const QStringRef & t) { putString(t.constData(), uint(t.length())); return maybeSpace(); }
+    inline QDebug &operator<<(QLatin1String t) { putByteArray(t.latin1(), t.size(), ContainsLatin1); return maybeSpace(); }
+    inline QDebug &operator<<(const QByteArray & t) { putByteArray(t.constData(), t.size(), ContainsBinary); return maybeSpace(); }
+    inline QDebug &operator<<(const void * t) { stream->ts << t; return maybeSpace(); }
+
+    inline QDebug &operator<<(std::nullptr_t) { stream->ts << "(nullptr)"; return maybeSpace(); }
+
+    inline QDebug &operator<<(QTextStreamFunction f) {
+        stream->ts << f;
+        return *this;
+    }
+
+    inline QDebug &operator<<(QTextStreamManipulator m)
+    { stream->ts << m; return *this; }
+};
+
+template<> class QTypeInfo<QDebug > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isRelocatable = !isStatic || ((Q_MOVABLE_TYPE) & Q_RELOCATABLE_TYPE), isLarge = (sizeof(QDebug)>sizeof(void*)), isPointer = false, isIntegral = QtPrivate::is_integral< QDebug >::value, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0), sizeOf = sizeof(QDebug) }; static inline const char *name() { return "QDebug"; } }; inline void swap(QDebug &value1, QDebug &value2) noexcept(noexcept(value1.swap(value2))) { value1.swap(value2); }
+
+class QDebugStateSaverPrivate;
+class __attribute__((visibility("default"))) QDebugStateSaver
+{
+public:
+    QDebugStateSaver(QDebug &dbg);
+    ~QDebugStateSaver();
+private:
+    QDebugStateSaver(const QDebugStateSaver &) = delete; QDebugStateSaver &operator=(const QDebugStateSaver &) = delete;
+    QScopedPointer<QDebugStateSaverPrivate> d;
+};
+
+class QNoDebug
+{
+public:
+    inline QNoDebug &operator<<(QTextStreamFunction) { return *this; }
+    inline QNoDebug &operator<<(QTextStreamManipulator) { return *this; }
+    inline QNoDebug &space() { return *this; }
+    inline QNoDebug &nospace() { return *this; }
+    inline QNoDebug &maybeSpace() { return *this; }
+    inline QNoDebug &quote() { return *this; }
+    inline QNoDebug &noquote() { return *this; }
+    inline QNoDebug &maybeQuote(const char = '"') { return *this; }
+
+    template<typename T>
+    inline QNoDebug &operator<<(const T &) { return *this; }
+};
+
+inline QDebug &QDebug::operator=(const QDebug &other)
+{
+    if (this != &other) {
+        QDebug copy(other);
+        qSwap(stream, copy.stream);
+    }
+    return *this;
+}
+
+namespace QtPrivate {
+
+template <typename SequentialContainer>
+inline QDebug printSequentialContainer(QDebug debug, const char *which, const SequentialContainer &c)
+{
+    const bool oldSetting = debug.autoInsertSpaces();
+    debug.nospace() << which << '(';
+    typename SequentialContainer::const_iterator it = c.begin(), end = c.end();
+    if (it != end) {
+        debug << *it;
+        ++it;
+    }
+    while (it != end) {
+        debug << ", " << *it;
+        ++it;
+    }
+    debug << ')';
+    debug.setAutoInsertSpaces(oldSetting);
+    return debug.maybeSpace();
+}
+
+}
+
+template <class T>
+inline QDebug operator<<(QDebug debug, const QList<T> &list)
+{
+    return QtPrivate::printSequentialContainer(debug, "" , list);
+}
+
+template <typename T>
+inline QDebug operator<<(QDebug debug, const QVector<T> &vec)
+{
+    return QtPrivate::printSequentialContainer(debug, "QVector", vec);
+}
+
+template <typename T, typename Alloc>
+inline QDebug operator<<(QDebug debug, const std::vector<T, Alloc> &vec)
+{
+    return QtPrivate::printSequentialContainer(debug, "std::vector", vec);
+}
+
+template <typename T, typename Alloc>
+inline QDebug operator<<(QDebug debug, const std::list<T, Alloc> &vec)
+{
+    return QtPrivate::printSequentialContainer(debug, "std::list", vec);
+}
+
+template <typename Key, typename T, typename Compare, typename Alloc>
+inline QDebug operator<<(QDebug debug, const std::map<Key, T, Compare, Alloc> &map)
+{
+    return QtPrivate::printSequentialContainer(debug, "std::map", map);
+}
+
+template <typename Key, typename T, typename Compare, typename Alloc>
+inline QDebug operator<<(QDebug debug, const std::multimap<Key, T, Compare, Alloc> &map)
+{
+    return QtPrivate::printSequentialContainer(debug, "std::multimap", map);
+}
+
+template <class Key, class T>
+inline QDebug operator<<(QDebug debug, const QMap<Key, T> &map)
+{
+    const bool oldSetting = debug.autoInsertSpaces();
+    debug.nospace() << "QMap(";
+    for (typename QMap<Key, T>::const_iterator it = map.constBegin();
+         it != map.constEnd(); ++it) {
+        debug << '(' << it.key() << ", " << it.value() << ')';
+    }
+    debug << ')';
+    debug.setAutoInsertSpaces(oldSetting);
+    return debug.maybeSpace();
+}
+
+template <class Key, class T>
+inline QDebug operator<<(QDebug debug, const QHash<Key, T> &hash)
+{
+    const bool oldSetting = debug.autoInsertSpaces();
+    debug.nospace() << "QHash(";
+    for (typename QHash<Key, T>::const_iterator it = hash.constBegin();
+            it != hash.constEnd(); ++it)
+        debug << '(' << it.key() << ", " << it.value() << ')';
+    debug << ')';
+    debug.setAutoInsertSpaces(oldSetting);
+    return debug.maybeSpace();
+}
+
+template <class T1, class T2>
+inline QDebug operator<<(QDebug debug, const QPair<T1, T2> &pair)
+{
+    const bool oldSetting = debug.autoInsertSpaces();
+    debug.nospace() << "QPair(" << pair.first << ',' << pair.second << ')';
+    debug.setAutoInsertSpaces(oldSetting);
+    return debug.maybeSpace();
+}
+
+template <class T1, class T2>
+inline QDebug operator<<(QDebug debug, const std::pair<T1, T2> &pair)
+{
+    const bool oldSetting = debug.autoInsertSpaces();
+    debug.nospace() << "std::pair(" << pair.first << ',' << pair.second << ')';
+    debug.setAutoInsertSpaces(oldSetting);
+    return debug.maybeSpace();
+}
+
+template <typename T>
+inline QDebug operator<<(QDebug debug, const QSet<T> &set)
+{
+    return QtPrivate::printSequentialContainer(debug, "QSet", set);
+}
+
+template <class T>
+inline QDebug operator<<(QDebug debug, const QContiguousCache<T> &cache)
+{
+    const bool oldSetting = debug.autoInsertSpaces();
+    debug.nospace() << "QContiguousCache(";
+    for (int i = cache.firstIndex(); i <= cache.lastIndex(); ++i) {
+        debug << cache[i];
+        if (i != cache.lastIndex())
+            debug << ", ";
+    }
+    debug << ')';
+    debug.setAutoInsertSpaces(oldSetting);
+    return debug.maybeSpace();
+}
+
+__attribute__((visibility("default"))) void qt_QMetaEnum_flagDebugOperator(QDebug &debug, size_t sizeofT, int value);
+
+template <typename Int>
+void qt_QMetaEnum_flagDebugOperator(QDebug &debug, size_t sizeofT, Int value)
+{
+    const QDebugStateSaver saver(debug);
+    debug.resetFormat();
+    debug.nospace() << "QFlags(" << hex << showbase;
+    bool needSeparator = false;
+    for (uint i = 0; i < sizeofT * 8; ++i) {
+        if (value & (Int(1) << i)) {
+            if (needSeparator)
+                debug << '|';
+            else
+                needSeparator = true;
+            debug << (Int(1) << i);
+        }
+    }
+    debug << ')';
+}
+
+
+__attribute__((visibility("default"))) QDebug qt_QMetaEnum_debugOperator(QDebug&, int value, const QMetaObject *meta, const char *name);
+__attribute__((visibility("default"))) QDebug qt_QMetaEnum_flagDebugOperator(QDebug &dbg, quint64 value, const QMetaObject *meta, const char *name);
+
+template<typename T>
+typename QtPrivate::QEnableIf<QtPrivate::IsQEnumHelper<T>::Value, QDebug>::Type
+operator<<(QDebug dbg, T value)
+{
+    const QMetaObject *obj = qt_getEnumMetaObject(value);
+    const char *name = qt_getEnumName(value);
+    return qt_QMetaEnum_debugOperator(dbg, typename QFlags<T>::Int(value), obj, name);
+}
+
+template <class T>
+inline typename QtPrivate::QEnableIf<
+    QtPrivate::IsQEnumHelper<T>::Value || QtPrivate::IsQEnumHelper<QFlags<T> >::Value,
+    QDebug>::Type
+qt_QMetaEnum_flagDebugOperator_helper(QDebug debug, const QFlags<T> &flags)
+{
+    const QMetaObject *obj = qt_getEnumMetaObject(T());
+    const char *name = qt_getEnumName(T());
+    return qt_QMetaEnum_flagDebugOperator(debug, quint64(flags), obj, name);
+}
+
+template <class T>
+inline typename QtPrivate::QEnableIf<
+    !QtPrivate::IsQEnumHelper<T>::Value && !QtPrivate::IsQEnumHelper<QFlags<T> >::Value,
+    QDebug>::Type
+qt_QMetaEnum_flagDebugOperator_helper(QDebug debug, const QFlags<T> &flags)
+
+
+
+
+{
+    qt_QMetaEnum_flagDebugOperator(debug, sizeof(T), typename QFlags<T>::Int(flags));
+    return debug;
+}
+
+template<typename T>
+inline QDebug operator<<(QDebug debug, const QFlags<T> &flags)
+{
+
+
+    return qt_QMetaEnum_flagDebugOperator_helper(debug, flags);
+}
+# 476 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/io/qdebug.h"
+
+# 1 "../../include/QtCore/qdebug.h" 2
+# 46 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp" 2
+
+# 1 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 1
+# 55 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h"
+# 1 "../../include/QtCore/qjsonobject.h" 1
+# 56 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+# 1 "../../include/QtCore/qjsonvalue.h" 1
+# 57 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+# 1 "../../include/QtCore/qjsondocument.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsondocument.h" 1
+# 43 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsondocument.h"
+# 1 "../../include/QtCore/qjsonvalue.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/json/qjsondocument.h" 2
+
+
+
+class QDebug;
+
+namespace QJsonPrivate {
+    class Parser;
+}
+
+struct __attribute__((visibility("default"))) QJsonParseError
+{
+    enum ParseError {
+        NoError = 0,
+        UnterminatedObject,
+        MissingNameSeparator,
+        UnterminatedArray,
+        MissingValueSeparator,
+        IllegalValue,
+        TerminationByNumber,
+        IllegalNumber,
+        IllegalEscapeSequence,
+        IllegalUTF8String,
+        UnterminatedString,
+        MissingObject,
+        DeepNesting,
+        DocumentTooLarge,
+        GarbageAtEnd
+    };
+
+    QString errorString() const;
+
+    int offset;
+    ParseError error;
+};
+
+class __attribute__((visibility("default"))) QJsonDocument
+{
+public:
+
+    static const uint BinaryFormatTag = ('q') | ('b' << 8) | ('j' << 16) | ('s' << 24);
+
+
+
+
+    QJsonDocument();
+    explicit QJsonDocument(const QJsonObject &object);
+    explicit QJsonDocument(const QJsonArray &array);
+    ~QJsonDocument();
+
+    QJsonDocument(const QJsonDocument &other);
+    QJsonDocument &operator =(const QJsonDocument &other);
+
+    enum DataValidation {
+        Validate,
+        BypassValidation
+    };
+
+    static QJsonDocument fromRawData(const char *data, int size, DataValidation validation = Validate);
+    const char *rawData(int *size) const;
+
+    static QJsonDocument fromBinaryData(const QByteArray &data, DataValidation validation = Validate);
+    QByteArray toBinaryData() const;
+
+    static QJsonDocument fromVariant(const QVariant &variant);
+    QVariant toVariant() const;
+
+    enum JsonFormat {
+        Indented,
+        Compact
+    };
+
+    static QJsonDocument fromJson(const QByteArray &json, QJsonParseError *error = nullptr);
+
+
+
+
+    QByteArray toJson() const;
+    QByteArray toJson(JsonFormat format) const;
+
+
+    bool isEmpty() const;
+    bool isArray() const;
+    bool isObject() const;
+
+    QJsonObject object() const;
+    QJsonArray array() const;
+
+    void setObject(const QJsonObject &object);
+    void setArray(const QJsonArray &array);
+
+    bool operator==(const QJsonDocument &other) const;
+    bool operator!=(const QJsonDocument &other) const { return !(*this == other); }
+
+    bool isNull() const;
+
+private:
+    friend class QJsonValue;
+    friend class QJsonPrivate::Data;
+    friend class QJsonPrivate::Parser;
+    friend __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QJsonDocument &);
+
+    QJsonDocument(QJsonPrivate::Data *data);
+
+    QJsonPrivate::Data *d;
+};
+
+
+__attribute__((visibility("default"))) QDebug operator<<(QDebug, const QJsonDocument &);
+
+
+
+# 1 "../../include/QtCore/qjsondocument.h" 2
+# 58 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+# 1 "../../include/QtCore/qjsonarray.h" 1
+# 59 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+# 1 "../../include/QtCore/qatomic.h" 2
+# 60 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+# 1 "../../include/QtCore/qstring.h" 1
+# 61 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+# 1 "../../include/QtCore/qendian.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qendian.h" 1
+# 44 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qendian.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 45 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qendian.h" 2
+
+
+
+
+
+
+
+
+
+
+
+inline void qbswap_helper(const uchar *src, uchar *dest, int size)
+{
+    for (int i = 0; i < size ; ++i) dest[i] = src[size - 1 - i];
+}
+
+
+
+
+
+
+
+template <typename T> inline void qbswap(const T src, uchar *dest)
+{
+    qbswap_helper(reinterpret_cast<const uchar *>(&src), dest, sizeof(T));
+}
+
+
+
+template <typename T> inline void qToUnaligned(const T src, uchar *dest)
+{
+
+
+    const size_t size = sizeof(T);
+    memcpy(dest, &src, size);
+}
+template <typename T> inline T qFromUnaligned(const uchar *src)
+{
+    T dest;
+    const size_t size = sizeof(T);
+    memcpy(&dest, src, size);
+    return dest;
+}
+
+
+
+
+
+
+
+template <typename T> T qbswap(T source);
+
+
+
+
+template <> inline quint64 qbswap<quint64>(quint64 source)
+{
+    return __builtin_bswap64(source);
+}
+template <> inline quint32 qbswap<quint32>(quint32 source)
+{
+    return __builtin_bswap32(source);
+}
+
+template <> inline void qbswap<quint64>(quint64 source, uchar *dest)
+{
+    qToUnaligned<quint64>(__builtin_bswap64(source), dest);
+}
+template <> inline void qbswap<quint32>(quint32 source, uchar *dest)
+{
+    qToUnaligned<quint32>(__builtin_bswap32(source), dest);
+}
+# 141 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qendian.h"
+template <> inline quint16 qbswap<quint16>(quint16 source)
+{
+    return __builtin_bswap16(source);
+}
+template <> inline void qbswap<quint16>(quint16 source, uchar *dest)
+{
+    qToUnaligned<quint16>(__builtin_bswap16(source), dest);
+}
+# 159 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qendian.h"
+template <> inline qint64 qbswap<qint64>(qint64 source)
+{
+    return qbswap<quint64>(quint64(source));
+}
+
+template <> inline qint32 qbswap<qint32>(qint32 source)
+{
+    return qbswap<quint32>(quint32(source));
+}
+
+template <> inline qint16 qbswap<qint16>(qint16 source)
+{
+    return qbswap<quint16>(quint16(source));
+}
+
+template <> inline void qbswap<qint64>(qint64 source, uchar *dest)
+{
+    qbswap<quint64>(quint64(source), dest);
+}
+
+template <> inline void qbswap<qint32>(qint32 source, uchar *dest)
+{
+    qbswap<quint32>(quint32(source), dest);
+}
+
+template <> inline void qbswap<qint16>(qint16 source, uchar *dest)
+{
+    qbswap<quint16>(quint16(source), dest);
+}
+# 205 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/global/qendian.h"
+template <typename T> inline T qToBigEndian(T source)
+{ return qbswap<T>(source); }
+template <typename T> inline T qFromBigEndian(T source)
+{ return qbswap<T>(source); }
+template <typename T> inline T qToLittleEndian(T source)
+{ return source; }
+template <typename T> inline T qFromLittleEndian(T source)
+{ return source; }
+template <typename T> inline void qToBigEndian(T src, uchar *dest)
+{ qbswap<T>(src, dest); }
+template <typename T> inline void qToLittleEndian(T src, uchar *dest)
+{ qToUnaligned<T>(src, dest); }
+
+
+
+template <> inline quint8 qbswap<quint8>(quint8 source)
+{
+    return source;
+}
+
+template <> inline qint8 qbswap<qint8>(qint8 source)
+{
+    return source;
+}
+
+
+
+
+
+
+template <typename T> inline T qFromLittleEndian(const uchar *src)
+{
+    return qFromLittleEndian(qFromUnaligned<T>(src));
+}
+
+template <> inline quint8 qFromLittleEndian<quint8>(const uchar *src)
+{ return static_cast<quint8>(src[0]); }
+template <> inline qint8 qFromLittleEndian<qint8>(const uchar *src)
+{ return static_cast<qint8>(src[0]); }
+
+
+
+
+
+template <class T> inline T qFromBigEndian(const uchar *src)
+{
+    return qFromBigEndian(qFromUnaligned<T>(src));
+}
+
+template <> inline quint8 qFromBigEndian<quint8>(const uchar *src)
+{ return static_cast<quint8>(src[0]); }
+template <> inline qint8 qFromBigEndian<qint8>(const uchar *src)
+{ return static_cast<qint8>(src[0]); }
+
+
+# 1 "../../include/QtCore/qendian.h" 2
+# 62 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+# 1 "../../include/QtCore/qnumeric.h" 1
+# 63 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+
+# 1 "../../include/QtCore/5.7.0/QtCore/private/qsimd_p.h" 1
+# 1 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h" 1
+# 55 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 56 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h" 2
+# 1 "../../include/QtCore/qatomic.h" 1
+# 1 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 1
+# 41 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h"
+# 1 "../../include/QtCore/qglobal.h" 1
+# 42 "../../include/QtCore/../../../../qt5/qtbase/src/corelib/thread/qatomic.h" 2
+# 1 "../../include/QtCore/qatomic.h" 2
+# 57 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h" 2
+# 280 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h"
+# 281 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h" 2
+# 290 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h"
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/arm_acle.h" 1 3 4
+# 32 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include/arm_acle.h" 3 4
+#pragma GCC push_options
+
+#pragma GCC target ("+nothing+crc")
+
+
+extern "C" {
+
+
+__extension__ static __inline uint32_t __attribute__ ((__always_inline__))
+__crc32b (uint32_t __a, uint8_t __b)
+{
+  return __builtin_aarch64_crc32b (__a, __b);
+}
+
+__extension__ static __inline uint32_t __attribute__ ((__always_inline__))
+__crc32cb (uint32_t __a, uint8_t __b)
+{
+  return __builtin_aarch64_crc32cb (__a, __b);
+}
+
+__extension__ static __inline uint32_t __attribute__ ((__always_inline__))
+__crc32ch (uint32_t __a, uint16_t __b)
+{
+  return __builtin_aarch64_crc32ch (__a, __b);
+}
+
+__extension__ static __inline uint32_t __attribute__ ((__always_inline__))
+__crc32cw (uint32_t __a, uint32_t __b)
+{
+  return __builtin_aarch64_crc32cw (__a, __b);
+}
+
+__extension__ static __inline uint32_t __attribute__ ((__always_inline__))
+__crc32cd (uint32_t __a, uint64_t __b)
+{
+  return __builtin_aarch64_crc32cx (__a, __b);
+}
+
+__extension__ static __inline uint32_t __attribute__ ((__always_inline__))
+__crc32h (uint32_t __a, uint16_t __b)
+{
+  return __builtin_aarch64_crc32h (__a, __b);
+}
+
+__extension__ static __inline uint32_t __attribute__ ((__always_inline__))
+__crc32w (uint32_t __a, uint32_t __b)
+{
+  return __builtin_aarch64_crc32w (__a, __b);
+}
+
+__extension__ static __inline uint32_t __attribute__ ((__always_inline__))
+__crc32d (uint32_t __a, uint64_t __b)
+{
+  return __builtin_aarch64_crc32x (__a, __b);
+}
+
+
+}
+
+
+#pragma GCC pop_options
+# 291 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h" 2
+
+
+
+
+
+
+
+
+# 298 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h"
+enum CPUFeatures {
+
+    CpuFeatureNEON = 0,
+    CpuFeatureARM_NEON = CpuFeatureNEON,
+    CpuFeatureCRC32 = 1,
+# 345 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h"
+    QSimdInitialized = 0x80000000
+};
+
+static const quint64 qCompilerCpuFeatures = 0
+# 428 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h"
+        | (static_cast<unsigned long long>(1ULL) << CpuFeatureNEON)
+# 439 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h"
+        ;
+
+
+extern __attribute__((visibility("default"))) QBasicAtomicInteger<quint64> qt_cpu_features[1];
+
+
+
+__attribute__((visibility("default"))) void qDetectCpuFeatures();
+
+static inline quint64 qCpuFeatures()
+{
+    quint64 features = qt_cpu_features[0].load();
+
+
+
+    if (__builtin_expect(!!(features == 0), false)) {
+        qDetectCpuFeatures();
+        features = qt_cpu_features[0].load();
+
+
+
+        do { const bool valueOfExpression = features != 0; do { } while ((false) && (valueOfExpression)); if (valueOfExpression){} else __builtin_unreachable(); } while (0);
+    }
+    return features;
+}
+# 524 "../../include/QtCore/5.7.0/QtCore/private/../../../../../../../qt5/qtbase/src/corelib/tools/qsimd_p.h"
+template <typename T>
+inline __attribute__((always_inline))
+T qUnalignedLoad(const void *ptr) noexcept
+{
+    T result;
+
+
+
+    memcpy
+
+              (&result, ptr, sizeof result);
+    return result;
+}
+
+template <typename T>
+inline __attribute__((always_inline))
+void qUnalignedStore(void *ptr, T t) noexcept
+{
+
+
+
+    memcpy
+
+              (ptr, &t, sizeof t);
+}
+
+
+# 1 "../../include/QtCore/5.7.0/QtCore/private/qsimd_p.h" 2
+# 65 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+
+# 1 "/opt/toolchains/gcc-linaro-5.3-2016.02-x86_64_aarch64-linux-gnu/lib/gcc/aarch64-linux-gnu/5.3.1/include-fixed/limits.h" 1 3 4
+# 67 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h" 2
+
+
+
+# 125 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h"
+namespace QJsonPrivate {
+
+class Array;
+class Object;
+class Value;
+class Entry;
+
+template<typename T>
+class q_littleendian
+{
+public:
+    T val;
+
+    q_littleendian &operator =(T i) { val = qToLittleEndian(i); return *this; }
+    operator T() const { return qFromLittleEndian(val); }
+
+    bool operator ==(T i) { return qFromLittleEndian(val) == i; }
+    bool operator !=(T i) { return qFromLittleEndian(val) != i; }
+    bool operator ==(q_littleendian<T> i) { return val == i.val; }
+    bool operator !=(q_littleendian<T> i) { return val != i.val; }
+    bool operator <(T i) { return qFromLittleEndian(val) < i; }
+    bool operator >(T i) { return qFromLittleEndian(val) > i; }
+    bool operator <=(T i) { return qFromLittleEndian(val) <= i; }
+    bool operator >=(T i) { return qFromLittleEndian(val) >= i; }
+    q_littleendian &operator +=(T i) {
+        val = qToLittleEndian(qFromLittleEndian(val) + i);
+        return *this;
+    }
+};
+}
+
+template <typename T>
+class QTypeInfo<QJsonPrivate::q_littleendian<T> >
+    : public QTypeInfoMerger<QJsonPrivate::q_littleendian<T>, T> {};
+
+namespace QJsonPrivate {
+
+typedef q_littleendian<short> qle_short;
+typedef q_littleendian<unsigned short> qle_ushort;
+typedef q_littleendian<int> qle_int;
+typedef q_littleendian<unsigned int> qle_uint;
+
+template<int pos, int width>
+class qle_bitfield
+{
+public:
+    uint val;
+
+    enum {
+        mask = ((1u << width) - 1) << pos
+    };
+
+    void operator =(uint t) {
+        uint i = qFromLittleEndian(val);
+        i &= ~mask;
+        i |= t << pos;
+        val = qToLittleEndian(i);
+    }
+    operator uint() const {
+        uint t = qFromLittleEndian(val);
+        t &= mask;
+        t >>= pos;
+        return t;
+    }
+    bool operator !() const {
+        return !operator uint();
+    }
+
+    bool operator ==(uint t) { return uint(*this) == t; }
+    bool operator !=(uint t) { return uint(*this) != t; }
+    bool operator <(uint t) { return uint(*this) < t; }
+    bool operator >(uint t) { return uint(*this) > t; }
+    bool operator <=(uint t) { return uint(*this) <= t; }
+    bool operator >=(uint t) { return uint(*this) >= t; }
+    qle_bitfield &operator +=(uint i) {
+        *this = (uint(*this) + i);
+        return *this;
+    }
+    qle_bitfield &operator -=(uint i) {
+        *this = (uint(*this) - i);
+        return *this;
+    }
+};
+
+template<int pos, int width>
+class qle_signedbitfield
+{
+public:
+    uint val;
+
+    enum {
+        mask = ((1u << width) - 1) << pos
+    };
+
+    void operator =(int t) {
+        uint i = qFromLittleEndian(val);
+        i &= ~mask;
+        i |= t << pos;
+        val = qToLittleEndian(i);
+    }
+    operator int() const {
+        uint i = qFromLittleEndian(val);
+        i <<= 32 - width - pos;
+        int t = (int) i;
+        t >>= pos;
+        return t;
+    }
+    bool operator !() const {
+        return !operator int();
+    }
+
+    bool operator ==(int t) { return int(*this) == t; }
+    bool operator !=(int t) { return int(*this) != t; }
+    bool operator <(int t) { return int(*this) < t; }
+    bool operator >(int t) { return int(*this) > t; }
+    bool operator <=(int t) { return int(*this) <= t; }
+    bool operator >=(int t) { return int(*this) >= t; }
+    qle_signedbitfield &operator +=(int i) {
+        *this = (int(*this) + i);
+        return *this;
+    }
+    qle_signedbitfield &operator -=(int i) {
+        *this = (int(*this) - i);
+        return *this;
+    }
+};
+
+typedef qle_uint offset;
+
+
+inline int alignedSize(int size) { return (size + 3) & ~3; }
+
+static inline bool useCompressed(const QString &s)
+{
+    if (s.length() >= 0x8000)
+        return false;
+    const ushort *uc = (const ushort *)s.constData();
+    const ushort *e = uc + s.length();
+    while (uc < e) {
+        if (*uc > 0xff)
+            return false;
+        ++uc;
+    }
+    return true;
+}
+
+static inline int qStringSize(const QString &string, bool compress)
+{
+    int l = 2 + string.length();
+    if (!compress)
+        l *= 2;
+    return alignedSize(l);
+}
+
+
+static inline int compressedNumber(double d)
+{
+
+    const int exponent_off = 52;
+    const quint64 fraction_mask = 0x000fffffffffffffull;
+    const quint64 exponent_mask = 0x7ff0000000000000ull;
+
+    quint64 val;
+    memcpy (&val, &d, sizeof(double));
+    int exp = (int)((val & exponent_mask) >> exponent_off) - 1023;
+    if (exp < 0 || exp > 25)
+        return 0x7fffffff;
+
+    quint64 non_int = val & (fraction_mask >> exp);
+    if (non_int)
+        return 0x7fffffff;
+
+    bool neg = (val >> 63) != 0;
+    val &= fraction_mask;
+    val |= ((quint64)1 << 52);
+    int res = (int)(val >> (52 - exp));
+    return neg ? -res : res;
+}
+
+class Latin1String;
+
+class String
+{
+public:
+    String(const char *data) { d = (Data *)data; }
+
+    struct Data {
+        qle_int length;
+        qle_ushort utf16[1];
+    };
+
+    Data *d;
+
+    inline String &operator=(const QString &str)
+    {
+        d->length = str.length();
+
+
+
+
+
+        memcpy(d->utf16, str.unicode(), str.length()*sizeof(ushort));
+
+        if (str.length() & 1)
+            d->utf16[str.length()] = 0;
+        return *this;
+    }
+
+    inline bool operator ==(const QString &str) const {
+        int slen = str.length();
+        int l = d->length;
+        if (slen != l)
+            return false;
+        const ushort *s = (const ushort *)str.constData();
+        const qle_ushort *a = d->utf16;
+        const ushort *b = s;
+        while (l-- && *a == *b)
+            a++,b++;
+        return (l == -1);
+    }
+    inline bool operator !=(const QString &str) const {
+        return !operator ==(str);
+    }
+    inline bool operator >=(const QString &str) const {
+
+        return toString() >= str;
+    }
+
+    inline bool operator<(const Latin1String &str) const;
+    inline bool operator>=(const Latin1String &str) const { return !operator <(str); }
+    inline bool operator ==(const Latin1String &str) const;
+
+    inline bool operator ==(const String &str) const {
+        if (d->length != str.d->length)
+            return false;
+        return !memcmp(d->utf16, str.d->utf16, d->length*sizeof(ushort));
+    }
+    inline bool operator<(const String &other) const;
+    inline bool operator >=(const String &other) const { return !(*this < other); }
+
+    inline QString toString() const {
+
+        return QString((QChar *)d->utf16, d->length);
+# 376 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h"
+    }
+
+};
+
+class Latin1String
+{
+public:
+    Latin1String(const char *data) { d = (Data *)data; }
+
+    struct Data {
+        qle_short length;
+        char latin1[1];
+    };
+    Data *d;
+
+    inline Latin1String &operator=(const QString &str)
+    {
+        int len = d->length = str.length();
+        uchar *l = (uchar *)d->latin1;
+        const ushort *uc = (const ushort *)str.unicode();
+        int i = 0;
+# 417 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h"
+        for ( ; i < len; ++i)
+            l[i] = uc[i];
+        for ( ; (quintptr)(l+i) & 0x3; ++i)
+            l[i] = 0;
+        return *this;
+    }
+
+    inline bool operator ==(const QString &str) const {
+        return QLatin1String(d->latin1, d->length) == str;
+    }
+    inline bool operator !=(const QString &str) const {
+        return !operator ==(str);
+    }
+    inline bool operator >=(const QString &str) const {
+        return QLatin1String(d->latin1, d->length) >= str;
+    }
+
+    inline bool operator ==(const Latin1String &str) const {
+        return d->length == str.d->length && !strcmp(d->latin1, str.d->latin1);
+    }
+    inline bool operator >=(const Latin1String &str) const {
+        int l = qMin(d->length, str.d->length);
+        int val = strncmp(d->latin1, str.d->latin1, l);
+        if (!val)
+            val = d->length - str.d->length;
+        return val >= 0;
+    }
+    inline bool operator<(const String &str) const
+    {
+        const qle_ushort *uc = (qle_ushort *) str.d->utf16;
+        if (!uc || *uc == 0)
+            return false;
+
+        const uchar *c = (uchar *)d->latin1;
+        const uchar *e = c + qMin((int)d->length, (int)str.d->length);
+
+        while (c < e) {
+            if (*c != *uc)
+                break;
+            ++c;
+            ++uc;
+        }
+        return (c == e ? (int)d->length < (int)str.d->length : *c < *uc);
+
+    }
+    inline bool operator ==(const String &str) const {
+        return (str == *this);
+    }
+    inline bool operator >=(const String &str) const {
+        return !(*this < str);
+    }
+
+    inline QString toString() const {
+        return QString::fromLatin1(d->latin1, d->length);
+    }
+};
+
+inline bool String::operator ==(const Latin1String &str) const
+{
+    if ((int)d->length != (int)str.d->length)
+        return false;
+    const qle_ushort *uc = d->utf16;
+    const qle_ushort *e = uc + d->length;
+    const uchar *c = (uchar *)str.d->latin1;
+
+    while (uc < e) {
+        if (*uc != *c)
+            return false;
+        ++uc;
+        ++c;
+    }
+    return true;
+}
+
+inline bool String::operator <(const String &other) const
+{
+    int alen = d->length;
+    int blen = other.d->length;
+    int l = qMin(alen, blen);
+    qle_ushort *a = d->utf16;
+    qle_ushort *b = other.d->utf16;
+
+    while (l-- && *a == *b)
+        a++,b++;
+    if (l==-1)
+        return (alen < blen);
+    return (ushort)*a < (ushort)*b;
+}
+
+inline bool String::operator<(const Latin1String &str) const
+{
+    const uchar *c = (uchar *) str.d->latin1;
+    if (!c || *c == 0)
+        return false;
+
+    const qle_ushort *uc = d->utf16;
+    const qle_ushort *e = uc + qMin((int)d->length, (int)str.d->length);
+
+    while (uc < e) {
+        if (*uc != *c)
+            break;
+        ++uc;
+        ++c;
+    }
+    return (uc == e ? (int)d->length < (int)str.d->length : (ushort)*uc < *c);
+
+}
+
+static inline void copyString(char *dest, const QString &str, bool compress)
+{
+    if (compress) {
+        Latin1String string(dest);
+        string = str;
+    } else {
+        String string(dest);
+        string = str;
+    }
+}
+# 548 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjson_p.h"
+class Base
+{
+public:
+    qle_uint size;
+    union {
+        uint _dummy;
+        qle_bitfield<0, 1> is_object;
+        qle_bitfield<1, 31> length;
+    };
+    offset tableOffset;
+
+
+    inline bool isObject() const { return !!is_object; }
+    inline bool isArray() const { return !isObject(); }
+
+    inline offset *table() const { return (offset *) (((char *) this) + tableOffset); }
+
+    int reserveSpace(uint dataSize, int posInTable, uint numItems, bool replace);
+    void removeItems(int pos, int numItems);
+};
+
+class Object : public Base
+{
+public:
+    Entry *entryAt(int i) const {
+        return reinterpret_cast<Entry *>(((char *)this) + table()[i]);
+    }
+    int indexOf(const QString &key, bool *exists);
+
+    bool isValid() const;
+};
+
+
+class Array : public Base
+{
+public:
+    inline Value at(int i) const;
+    inline Value &operator [](int i);
+
+    bool isValid() const;
+};
+
+
+class Value
+{
+public:
+    enum {
+        MaxSize = (1<<27) - 1
+    };
+    union {
+        uint _dummy;
+        qle_bitfield<0, 3> type;
+        qle_bitfield<3, 1> latinOrIntValue;
+        qle_bitfield<4, 1> latinKey;
+        qle_bitfield<5, 27> value;
+        qle_signedbitfield<5, 27> int_value;
+    };
+
+    inline char *data(const Base *b) const { return ((char *)b) + value; }
+    int usedStorage(const Base *b) const;
+
+    bool toBoolean() const;
+    double toDouble(const Base *b) const;
+    QString toString(const Base *b) const;
+    String asString(const Base *b) const;
+    Latin1String asLatin1String(const Base *b) const;
+    Base *base(const Base *b) const;
+
+    bool isValid(const Base *b) const;
+
+    static int requiredStorage(QJsonValue &v, bool *compressed);
+    static uint valueToStore(const QJsonValue &v, uint offset);
+    static void copyData(const QJsonValue &v, char *dest, bool compressed);
+};
+
+inline Value Array::at(int i) const
+{
+    return *(Value *) (table() + i);
+}
+
+inline Value &Array::operator [](int i)
+{
+    return *(Value *) (table() + i);
+}
+
+
+
+class Entry {
+public:
+    Value value;
+
+
+
+    int size() const {
+        int s = sizeof(Entry);
+        if (value.latinKey)
+            s += sizeof(ushort) + qFromLittleEndian(*(ushort *) ((const char *)this + sizeof(Entry)));
+        else
+            s += sizeof(uint) + sizeof(ushort)*qFromLittleEndian(*(int *) ((const char *)this + sizeof(Entry)));
+        return alignedSize(s);
+    }
+
+    int usedStorage(Base *b) const {
+        return size() + value.usedStorage(b);
+    }
+
+    String shallowKey() const
+    {
+        do { } while ((false) && (!value.latinKey));
+        return String((const char *)this + sizeof(Entry));
+    }
+    Latin1String shallowLatin1Key() const
+    {
+        do { } while ((false) && (value.latinKey));
+        return Latin1String((const char *)this + sizeof(Entry));
+    }
+    QString key() const
+    {
+        if (value.latinKey) {
+            return shallowLatin1Key().toString();
+        }
+        return shallowKey().toString();
+    }
+
+    bool operator ==(const QString &key) const;
+    inline bool operator !=(const QString &key) const { return !operator ==(key); }
+    inline bool operator >=(const QString &key) const;
+
+    bool operator ==(const Entry &other) const;
+    bool operator >=(const Entry &other) const;
+};
+
+inline bool Entry::operator >=(const QString &key) const
+{
+    if (value.latinKey)
+        return (shallowLatin1Key() >= key);
+    else
+        return (shallowKey() >= key);
+}
+
+inline bool operator <(const QString &key, const Entry &e)
+{ return e >= key; }
+
+
+class Header {
+public:
+    qle_uint tag;
+    qle_uint version;
+    Base *root() { return (Base *)(this + 1); }
+};
+
+
+inline bool Value::toBoolean() const
+{
+    do { } while ((false) && (type == QJsonValue::Bool));
+    return value != 0;
+}
+
+inline double Value::toDouble(const Base *b) const
+{
+    do { } while ((false) && (type == QJsonValue::Double));
+    if (latinOrIntValue)
+        return int_value;
+
+    quint64 i = qFromLittleEndian<quint64>((const uchar *)b + value);
+    double d;
+    memcpy(&d, &i, sizeof(double));
+    return d;
+}
+
+inline String Value::asString(const Base *b) const
+{
+    do { } while ((false) && (type == QJsonValue::String && !latinOrIntValue));
+    return String(data(b));
+}
+
+inline Latin1String Value::asLatin1String(const Base *b) const
+{
+    do { } while ((false) && (type == QJsonValue::String && latinOrIntValue));
+    return Latin1String(data(b));
+}
+
+inline QString Value::toString(const Base *b) const
+{
+    if (latinOrIntValue)
+        return asLatin1String(b).toString();
+    else
+        return asString(b).toString();
+}
+
+inline Base *Value::base(const Base *b) const
+{
+    do { } while ((false) && (type == QJsonValue::Array || type == QJsonValue::Object));
+    return reinterpret_cast<Base *>(data(b));
+}
+
+class Data {
+public:
+    enum Validation {
+        Unchecked,
+        Validated,
+        Invalid
+    };
+
+    QAtomicInt ref;
+    int alloc;
+    union {
+        char *rawData;
+        Header *header;
+    };
+    uint compactionCounter : 31;
+    uint ownsData : 1;
+
+    inline Data(char *raw, int a)
+        : alloc(a), rawData(raw), compactionCounter(0), ownsData(true)
+    {
+    }
+    inline Data(int reserved, QJsonValue::Type valueType)
+        : rawData(0), compactionCounter(0), ownsData(true)
+    {
+        do { } while ((false) && (valueType == QJsonValue::Array || valueType == QJsonValue::Object));
+
+        alloc = sizeof(Header) + sizeof(Base) + reserved + sizeof(offset);
+        header = (Header *)malloc(alloc);
+        do { if (!(header)) qBadAlloc(); } while (0);
+        header->tag = QJsonDocument::BinaryFormatTag;
+        header->version = 1;
+        Base *b = header->root();
+        b->size = sizeof(Base);
+        b->is_object = (valueType == QJsonValue::Object);
+        b->tableOffset = sizeof(Base);
+        b->length = 0;
+    }
+    inline ~Data()
+    { if (ownsData) free(rawData); }
+
+    uint offsetOf(const void *ptr) const { return (uint)(((char *)ptr - rawData)); }
+
+    QJsonObject toObject(Object *o) const
+    {
+        return QJsonObject(const_cast<Data *>(this), o);
+    }
+
+    QJsonArray toArray(Array *a) const
+    {
+        return QJsonArray(const_cast<Data *>(this), a);
+    }
+
+    Data *clone(Base *b, int reserve = 0)
+    {
+        int size = sizeof(Header) + b->size;
+        if (b == header->root() && ref.load() == 1 && alloc >= size + reserve)
+            return this;
+
+        if (reserve) {
+            if (reserve < 128)
+                reserve = 128;
+            size = qMax(size + reserve, qMin(size *2, (int)Value::MaxSize));
+            if (size > Value::MaxSize) {
+                QMessageLogger(nullptr, 0, nullptr).warning("QJson: Document too large to store in data structure");
+                return 0;
+            }
+        }
+        char *raw = (char *)malloc(size);
+        do { if (!(raw)) qBadAlloc(); } while (0);
+        memcpy(raw + sizeof(Header), b, b->size);
+        Header *h = (Header *)raw;
+        h->tag = QJsonDocument::BinaryFormatTag;
+        h->version = 1;
+        Data *d = new Data(raw, size);
+        d->compactionCounter = (b == header->root()) ? compactionCounter : 0;
+        return d;
+    }
+
+    void compact();
+    bool valid() const;
+
+private:
+    Data(const Data &) = delete; Data &operator=(const Data &) = delete;
+};
+
+}
+
+
+# 48 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp" 2
+
+
+# 106 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+QJsonValue::QJsonValue(Type type)
+    : ui(0), d(0), t(type)
+{
+}
+
+
+
+
+QJsonValue::QJsonValue(QJsonPrivate::Data *data, QJsonPrivate::Base *base, const QJsonPrivate::Value &v)
+    : d(0)
+{
+    t = (Type)(uint)v.type;
+    switch (t) {
+    case Undefined:
+    case Null:
+        dbl = 0;
+        break;
+    case Bool:
+        b = v.toBoolean();
+        break;
+    case Double:
+        dbl = v.toDouble(base);
+        break;
+    case String: {
+        QString s = v.toString(base);
+        stringData = s.data_ptr();
+        stringData->ref.ref();
+        break;
+    }
+    case Array:
+    case Object:
+        d = data;
+        this->base = v.base(base);
+        break;
+    }
+    if (d)
+        d->ref.ref();
+}
+
+
+
+
+QJsonValue::QJsonValue(bool b)
+    : d(0), t(Bool)
+{
+    this->b = b;
+}
+
+
+
+
+QJsonValue::QJsonValue(double n)
+    : d(0), t(Double)
+{
+    this->dbl = n;
+}
+
+
+
+
+
+QJsonValue::QJsonValue(int n)
+    : d(0), t(Double)
+{
+    this->dbl = n;
+}
+
+
+
+
+
+
+
+QJsonValue::QJsonValue(qint64 n)
+    : d(0), t(Double)
+{
+    this->dbl = double(n);
+}
+
+
+
+
+QJsonValue::QJsonValue(const QString &s)
+    : d(0), t(String)
+{
+    stringDataFromQStringHelper(s);
+}
+# 206 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+void QJsonValue::stringDataFromQStringHelper(const QString &string)
+{
+    stringData = *(QStringData **)(&string);
+    stringData->ref.ref();
+}
+
+
+
+
+QJsonValue::QJsonValue(QLatin1String s)
+    : d(0), t(String)
+{
+
+    QString str(s);
+    stringDataFromQStringHelper(str);
+}
+
+
+
+
+QJsonValue::QJsonValue(const QJsonArray &a)
+    : d(a.d), t(Array)
+{
+    base = a.a;
+    if (d)
+        d->ref.ref();
+}
+
+
+
+
+QJsonValue::QJsonValue(const QJsonObject &o)
+    : d(o.d), t(Object)
+{
+    base = o.o;
+    if (d)
+        d->ref.ref();
+}
+
+
+
+
+
+QJsonValue::~QJsonValue()
+{
+    if (t == String && stringData && !stringData->ref.deref())
+        free(stringData);
+
+    if (d && !d->ref.deref())
+        delete d;
+}
+
+
+
+
+QJsonValue::QJsonValue(const QJsonValue &other)
+{
+    t = other.t;
+    d = other.d;
+    ui = other.ui;
+    if (d)
+        d->ref.ref();
+
+    if (t == String && stringData)
+        stringData->ref.ref();
+}
+
+
+
+
+QJsonValue &QJsonValue::operator =(const QJsonValue &other)
+{
+    if (t == String && stringData && !stringData->ref.deref())
+        free(stringData);
+
+    t = other.t;
+    dbl = other.dbl;
+
+    if (d != other.d) {
+
+        if (d && !d->ref.deref())
+            delete d;
+        d = other.d;
+        if (d)
+            d->ref.ref();
+
+    }
+
+    if (t == String && stringData)
+        stringData->ref.ref();
+
+    return *this;
+}
+# 407 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+QJsonValue QJsonValue::fromVariant(const QVariant &variant)
+{
+    switch (variant.userType()) {
+    case QVariant::Bool:
+        return QJsonValue(variant.toBool());
+    case QVariant::Int:
+    case QMetaType::Float:
+    case QVariant::Double:
+    case QVariant::LongLong:
+    case QVariant::ULongLong:
+    case QVariant::UInt:
+        return QJsonValue(variant.toDouble());
+    case QVariant::String:
+        return QJsonValue(variant.toString());
+    case QVariant::StringList:
+        return QJsonValue(QJsonArray::fromStringList(variant.toStringList()));
+    case QVariant::List:
+        return QJsonValue(QJsonArray::fromVariantList(variant.toList()));
+    case QVariant::Map:
+        return QJsonValue(QJsonObject::fromVariantMap(variant.toMap()));
+    case QVariant::Hash:
+        return QJsonValue(QJsonObject::fromVariantHash(variant.toHash()));
+
+    case QMetaType::QJsonValue:
+        return variant.toJsonValue();
+    case QMetaType::QJsonObject:
+        return variant.toJsonObject();
+    case QMetaType::QJsonArray:
+        return variant.toJsonArray();
+    case QMetaType::QJsonDocument: {
+        QJsonDocument doc = variant.toJsonDocument();
+        return doc.isArray() ? QJsonValue(doc.array()) : QJsonValue(doc.object());
+    }
+
+    default:
+        break;
+    }
+    QString string = variant.toString();
+    if (string.isEmpty())
+        return QJsonValue();
+    return QJsonValue(string);
+}
+# 465 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+QVariant QJsonValue::toVariant() const
+{
+    switch (t) {
+    case Bool:
+        return b;
+    case Double:
+        return dbl;
+    case String:
+        return toString();
+    case Array:
+        return d ?
+               QJsonArray(d, static_cast<QJsonPrivate::Array *>(base)).toVariantList() :
+               QVariantList();
+    case Object:
+        return d ?
+               QJsonObject(d, static_cast<QJsonPrivate::Object *>(base)).toVariantMap() :
+               QVariantMap();
+    case Null:
+    case Undefined:
+        break;
+    }
+    return QVariant();
+}
+# 510 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+QJsonValue::Type QJsonValue::type() const
+{
+    return t;
+}
+
+
+
+
+
+
+bool QJsonValue::toBool(bool defaultValue) const
+{
+    if (t != Bool)
+        return defaultValue;
+    return b;
+}
+
+
+
+
+
+
+
+int QJsonValue::toInt(int defaultValue) const
+{
+    if (t == Double && int(dbl) == dbl)
+        return int(dbl);
+    return defaultValue;
+}
+
+
+
+
+
+
+double QJsonValue::toDouble(double defaultValue) const
+{
+    if (t != Double)
+        return defaultValue;
+    return dbl;
+}
+
+
+
+
+
+
+QString QJsonValue::toString(const QString &defaultValue) const
+{
+    if (t != String)
+        return defaultValue;
+    stringData->ref.ref();
+    QStringDataPtr holder = { stringData };
+    return QString(holder);
+}
+
+
+
+
+
+
+QJsonArray QJsonValue::toArray(const QJsonArray &defaultValue) const
+{
+    if (!d || t != Array)
+        return defaultValue;
+
+    return QJsonArray(d, static_cast<QJsonPrivate::Array *>(base));
+}
+# 586 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+QJsonArray QJsonValue::toArray() const
+{
+    return toArray(QJsonArray());
+}
+
+
+
+
+
+
+QJsonObject QJsonValue::toObject(const QJsonObject &defaultValue) const
+{
+    if (!d || t != Object)
+        return defaultValue;
+
+    return QJsonObject(d, static_cast<QJsonPrivate::Object *>(base));
+}
+# 611 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+QJsonObject QJsonValue::toObject() const
+{
+    return toObject(QJsonObject());
+}
+
+
+
+
+bool QJsonValue::operator==(const QJsonValue &other) const
+{
+    if (t != other.t)
+        return false;
+
+    switch (t) {
+    case Undefined:
+    case Null:
+        break;
+    case Bool:
+        return b == other.b;
+    case Double:
+        return dbl == other.dbl;
+    case String:
+        return toString() == other.toString();
+    case Array:
+        if (base == other.base)
+            return true;
+        if (!base)
+            return !other.base->length;
+        if (!other.base)
+            return !base->length;
+        return QJsonArray(d, static_cast<QJsonPrivate::Array *>(base))
+                == QJsonArray(other.d, static_cast<QJsonPrivate::Array *>(other.base));
+    case Object:
+        if (base == other.base)
+            return true;
+        if (!base)
+            return !other.base->length;
+        if (!other.base)
+            return !base->length;
+        return QJsonObject(d, static_cast<QJsonPrivate::Object *>(base))
+                == QJsonObject(other.d, static_cast<QJsonPrivate::Object *>(other.base));
+    }
+    return true;
+}
+
+
+
+
+bool QJsonValue::operator!=(const QJsonValue &other) const
+{
+    return !(*this == other);
+}
+
+
+
+
+void QJsonValue::detach()
+{
+    if (!d)
+        return;
+
+    QJsonPrivate::Data *x = d->clone(base);
+    x->ref.ref();
+    if (!d->ref.deref())
+        delete d;
+    d = x;
+    base = static_cast<QJsonPrivate::Object *>(d->header->root());
+}
+# 705 "/home/jeremy/src/qt/qt5/qtbase/src/corelib/json/qjsonvalue.cpp"
+QJsonValueRef &QJsonValueRef::operator =(const QJsonValue &val)
+{
+    if (is_object)
+        o->setValueAt(index, val);
+    else
+        a->replace(index, val);
+
+    return *this;
+}
+
+QJsonValueRef &QJsonValueRef::operator =(const QJsonValueRef &ref)
+{
+    if (is_object)
+        o->setValueAt(index, ref);
+    else
+        a->replace(index, ref);
+
+    return *this;
+}
+
+QVariant QJsonValueRef::toVariant() const
+{
+    return toValue().toVariant();
+}
+
+QJsonArray QJsonValueRef::toArray() const
+{
+    return toValue().toArray();
+}
+
+QJsonObject QJsonValueRef::toObject() const
+{
+    return toValue().toObject();
+}
+
+QJsonValue QJsonValueRef::toValue() const
+{
+    if (!is_object)
+        return a->at(index);
+    return o->valueAt(index);
+}
+
+
+QDebug operator<<(QDebug dbg, const QJsonValue &o)
+{
+    QDebugStateSaver saver(dbg);
+    switch (o.t) {
+    case QJsonValue::Undefined:
+        dbg << "QJsonValue(undefined)";
+        break;
+    case QJsonValue::Null:
+        dbg << "QJsonValue(null)";
+        break;
+    case QJsonValue::Bool:
+        dbg.nospace() << "QJsonValue(bool, " << o.toBool() << ')';
+        break;
+    case QJsonValue::Double:
+        dbg.nospace() << "QJsonValue(double, " << o.toDouble() << ')';
+        break;
+    case QJsonValue::String:
+        dbg.nospace() << "QJsonValue(string, " << o.toString() << ')';
+        break;
+    case QJsonValue::Array:
+        dbg.nospace() << "QJsonValue(array, ";
+        dbg << o.toArray();
+        dbg << ')';
+        break;
+    case QJsonValue::Object:
+        dbg.nospace() << "QJsonValue(object, ";
+        dbg << o.toObject();
+        dbg << ')';
+        break;
+    }
+    return dbg;
+}
+
+
+