diff --git a/src/openrct2/ParkFile b/src/openrct2/ParkFile
new file mode 100644
index 0000000000..596d7165ce
--- /dev/null
+++ b/src/openrct2/ParkFile
@@ -0,0 +1,112108 @@
+# 1 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp"
+# 1 "/home/ted/dev/openrct2//"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "/usr/include/stdc-predef.h" 1 3 4
+# 1 "<command-line>" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp"
+# 10 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp"
+# 1 "/home/ted/dev/openrct2/src/openrct2/ParkFile.h" 1
+       
+
+# 1 "/usr/include/c++/10.2.0/string_view" 1 3
+# 36 "/usr/include/c++/10.2.0/string_view" 3
+       
+# 37 "/usr/include/c++/10.2.0/string_view" 3
+# 4 "/home/ted/dev/openrct2/src/openrct2/ParkFile.h" 2
+# 1 "/usr/include/c++/10.2.0/vector" 1 3
+# 58 "/usr/include/c++/10.2.0/vector" 3
+       
+# 59 "/usr/include/c++/10.2.0/vector" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 1 3
+# 59 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 1 3
+# 258 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+
+# 258 "/usr/include/c++/10.2.0/x86_64-pc-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;
+
+}
+# 280 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+namespace std
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+namespace __gnu_cxx
+{
+  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+# 518 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3
+# 39 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 3
+# 1 "/usr/include/features.h" 1 3 4
+# 473 "/usr/include/features.h" 3 4
+# 1 "/usr/include/sys/cdefs.h" 1 3 4
+# 462 "/usr/include/sys/cdefs.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 463 "/usr/include/sys/cdefs.h" 2 3 4
+# 1 "/usr/include/bits/long-double.h" 1 3 4
+# 464 "/usr/include/sys/cdefs.h" 2 3 4
+# 474 "/usr/include/features.h" 2 3 4
+# 497 "/usr/include/features.h" 3 4
+# 1 "/usr/include/gnu/stubs.h" 1 3 4
+# 10 "/usr/include/gnu/stubs.h" 3 4
+# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
+# 11 "/usr/include/gnu/stubs.h" 2 3 4
+# 498 "/usr/include/features.h" 2 3 4
+# 40 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3
+# 519 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3
+# 522 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+# 60 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/functexcept.h" 1 3
+# 40 "/usr/include/c++/10.2.0/bits/functexcept.h" 3
+# 1 "/usr/include/c++/10.2.0/bits/exception_defines.h" 1 3
+# 41 "/usr/include/c++/10.2.0/bits/functexcept.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  void
+  __throw_bad_exception(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_alloc(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_cast(void) __attribute__((__noreturn__));
+
+  void
+  __throw_bad_typeid(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_logic_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_domain_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_length_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_out_of_range(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_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_ios_failure(const char*, int) __attribute__((__noreturn__));
+
+
+  void
+  __throw_system_error(int) __attribute__((__noreturn__));
+
+
+  void
+  __throw_future_error(int) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_function_call() __attribute__((__noreturn__));
+
+
+}
+# 61 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+       
+# 36 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+# 67 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+extern "C++" {
+
+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;
+    };
+# 184 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+  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;
+    };
+# 270 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; template<> struct __is_integer<unsigned __int128> { enum { __value = 1 }; typedef __true_type __type; };
+# 287 "/usr/include/c++/10.2.0/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_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;
+    };
+# 423 "/usr/include/c++/10.2.0/bits/cpp_type_traits.h" 3
+  template<typename> struct iterator_traits;
+
+
+  template<typename _Tp>
+    struct __is_nonvolatile_trivially_copyable
+    {
+      enum { __value = __is_trivially_copyable(_Tp) };
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_nonvolatile_trivially_copyable<volatile _Tp>
+    {
+      enum { __value = 0 };
+    };
+
+
+  template<typename _OutputIter, typename _InputIter>
+    struct __memcpyable
+    {
+      enum { __value = 0 };
+    };
+
+  template<typename _Tp>
+    struct __memcpyable<_Tp*, _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct __memcpyable<_Tp*, const _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+
+
+
+
+
+  template<typename _Iter1, typename _Iter2>
+    struct __memcmpable
+    {
+      enum { __value = 0 };
+    };
+
+
+  template<typename _Tp>
+    struct __memcmpable<_Tp*, _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct __memcmpable<const _Tp*, _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct __memcmpable<_Tp*, const _Tp*>
+    : __is_nonvolatile_trivially_copyable<_Tp>
+    { };
+
+
+
+
+  template<typename _Tp>
+    struct __is_move_iterator
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+
+
+  template<typename _Iterator>
+   
+    inline _Iterator
+    __miter_base(_Iterator __it)
+    { return __it; }
+
+
+}
+}
+# 62 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/ext/type_traits.h" 1 3
+# 32 "/usr/include/c++/10.2.0/ext/type_traits.h" 3
+       
+# 33 "/usr/include/c++/10.2.0/ext/type_traits.h" 3
+
+
+
+
+extern "C++" {
+
+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 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/ext/numeric_traits.h" 1 3
+# 32 "/usr/include/c++/10.2.0/ext/numeric_traits.h" 3
+       
+# 33 "/usr/include/c++/10.2.0/ext/numeric_traits.h" 3
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+# 54 "/usr/include/c++/10.2.0/ext/numeric_traits.h" 3
+  template<typename _Value>
+    struct __numeric_traits_integer
+    {
+
+      static const _Value __min = (((_Value)(-1) < 0) ? -(((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0) - 1 : (_Value)0);
+      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
+
+
+
+      static const bool __is_signed = ((_Value)(-1) < 0);
+      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
+    };
+
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__min;
+
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__max;
+
+  template<typename _Value>
+    const bool __numeric_traits_integer<_Value>::__is_signed;
+
+  template<typename _Value>
+    const int __numeric_traits_integer<_Value>::__digits;
+# 99 "/usr/include/c++/10.2.0/ext/numeric_traits.h" 3
+  template<typename _Value>
+    struct __numeric_traits_floating
+    {
+
+      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
+
+
+      static const bool __is_signed = true;
+      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
+      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
+    };
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_digits10;
+
+  template<typename _Value>
+    const bool __numeric_traits_floating<_Value>::__is_signed;
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__digits10;
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_exponent10;
+
+  template<typename _Value>
+    struct __numeric_traits
+    : public __conditional_type<std::__is_integer<_Value>::__value,
+    __numeric_traits_integer<_Value>,
+    __numeric_traits_floating<_Value> >::__type
+    { };
+
+
+}
+# 64 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_pair.h" 1 3
+# 59 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+# 1 "/usr/include/c++/10.2.0/bits/move.h" 1 3
+# 38 "/usr/include/c++/10.2.0/bits/move.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _Tp>
+    inline constexpr _Tp*
+    __addressof(_Tp& __r) noexcept
+    { return __builtin_addressof(__r); }
+
+
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/type_traits" 1 3
+# 32 "/usr/include/c++/10.2.0/type_traits" 3
+       
+# 33 "/usr/include/c++/10.2.0/type_traits" 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 56 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename _Tp, _Tp __v>
+    struct integral_constant
+    {
+      static constexpr _Tp value = __v;
+      typedef _Tp value_type;
+      typedef integral_constant<_Tp, __v> type;
+      constexpr operator value_type() const noexcept { return value; }
+
+
+
+
+      constexpr value_type operator()() const noexcept { 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>;
+# 91 "/usr/include/c++/10.2.0/type_traits" 3
+  template<bool, typename, typename>
+    struct conditional;
+
+  template <typename _Type>
+    struct __type_identity
+    { using type = _Type; };
+
+  template<typename _Tp>
+    using __type_identity_t = typename __type_identity<_Tp>::type;
+
+  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 __bool_constant<!bool(_Pp::value)>
+    { };
+# 188 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename>
+    struct is_reference;
+  template<typename>
+    struct is_function;
+  template<typename>
+    struct is_void;
+  template<typename>
+    struct __is_array_unknown_bounds;
+
+
+
+
+  template <typename _Tp, size_t = sizeof(_Tp)>
+    constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>)
+    { return {}; }
+
+  template <typename _TypeIdentity,
+      typename _NestedType = typename _TypeIdentity::type>
+    constexpr typename __or_<
+      is_reference<_NestedType>,
+      is_function<_NestedType>,
+      is_void<_NestedType>,
+      __is_array_unknown_bounds<_NestedType>
+    >::type __is_complete_or_unbounded(_TypeIdentity)
+    { return {}; }
+
+
+
+
+
+
+  template<typename _Tp>
+    struct __success_type
+    { typedef _Tp type; };
+
+  struct __failure_type
+  { };
+
+  template<typename>
+    struct remove_cv;
+
+
+  template<typename _Tp>
+    using __remove_cv_t = typename remove_cv<_Tp>::type;
+
+  template<typename>
+    struct is_const;
+
+
+
+  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<__remove_cv_t<_Tp>>::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 { };
+# 284 "/usr/include/c++/10.2.0/type_traits" 3
+  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 { };
+
+
+
+
+  template<>
+    struct __is_integral_helper<__int128>
+    : public true_type { };
+
+  template<>
+    struct __is_integral_helper<unsigned __int128>
+    : public true_type { };
+# 364 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename _Tp>
+    struct is_integral
+    : public __is_integral_helper<__remove_cv_t<_Tp>>::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 { };
+
+
+  template<>
+    struct __is_floating_point_helper<__float128>
+    : public true_type { };
+
+
+
+  template<typename _Tp>
+    struct is_floating_point
+    : public __is_floating_point_helper<__remove_cv_t<_Tp>>::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<__remove_cv_t<_Tp>>::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_member_object_pointer_helper
+    : public false_type { };
+
+  template<typename _Tp, typename _Cp>
+    struct __is_member_object_pointer_helper<_Tp _Cp::*>
+    : public __not_<is_function<_Tp>>::type { };
+
+
+  template<typename _Tp>
+    struct is_member_object_pointer
+    : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::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 is_function<_Tp>::type { };
+
+
+  template<typename _Tp>
+    struct is_member_function_pointer
+    : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::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 _Tp>
+    struct is_function
+    : public __bool_constant<!is_const<const _Tp>::value> { };
+
+  template<typename _Tp>
+    struct is_function<_Tp&>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct is_function<_Tp&&>
+    : public false_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<__remove_cv_t<_Tp>>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_nullptr_t
+    : public is_null_pointer<_Tp>
+    { } __attribute__ ((__deprecated__));
+
+
+
+
+  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 __not_<is_fundamental<_Tp>>::type { };
+
+  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<__remove_cv_t<_Tp>>::type
+    { };
+
+  template<typename, typename>
+    struct is_same;
+
+  template<typename _Tp, typename... _Types>
+    using __is_one_of = __or_<is_same<_Tp, _Types>...>;
+
+
+  template<typename _Tp>
+    using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
+   signed char, signed short, signed int, signed long,
+   signed long long
+
+   , signed __int128
+# 604 "/usr/include/c++/10.2.0/type_traits" 3
+   >;
+
+
+  template<typename _Tp>
+    using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
+   unsigned char, unsigned short, unsigned int, unsigned long,
+   unsigned long long
+
+   , unsigned __int128
+# 623 "/usr/include/c++/10.2.0/type_traits" 3
+   >;
+
+
+  template<typename _Tp>
+    using __is_standard_integer
+      = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;
+
+
+  template<typename...> using __void_t = void;
+
+
+
+  template<typename _Tp, typename = void>
+    struct __is_referenceable
+    : public false_type
+    { };
+
+  template<typename _Tp>
+    struct __is_referenceable<_Tp, __void_t<_Tp&>>
+    : 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)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_trivially_copyable
+    : public integral_constant<bool, __is_trivially_copyable(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_standard_layout
+    : public integral_constant<bool, __is_standard_layout(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+  template<typename _Tp>
+    struct
+   
+    is_pod
+    : public integral_constant<bool, __is_pod(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_literal_type
+    : public integral_constant<bool, __is_literal_type(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  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>>>
+    { };
+# 770 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename _Tp, typename _Up = _Tp&&>
+    _Up
+    __declval(int);
+
+  template<typename _Tp>
+    _Tp
+    __declval(long);
+
+  template<typename _Tp>
+    auto declval() noexcept -> decltype(__declval<_Tp>(0));
+
+  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>>>
+    { };
+
+
+
+
+
+
+  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
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+
+
+  struct __do_is_nt_destructible_impl
+  {
+    template<typename _Tp>
+      static __bool_constant<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
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_constructible_impl
+    : public __bool_constant<__is_constructible(_Tp, _Args...)>
+    { };
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_constructible
+      : public __is_constructible_impl<_Tp, _Args...>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_default_constructible
+    : public __is_constructible_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_copy_constructible
+    : public __is_copy_constructible_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_move_constructible
+    : public __is_move_constructible_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  template<bool, typename _Tp, typename... _Args>
+    struct __is_nt_constructible_impl
+    : public false_type
+    { };
+
+  template<typename _Tp, typename... _Args>
+    struct __is_nt_constructible_impl<true, _Tp, _Args...>
+    : public __bool_constant<noexcept(_Tp(std::declval<_Args>()...))>
+    { };
+
+  template<typename _Tp, typename _Arg>
+    struct __is_nt_constructible_impl<true, _Tp, _Arg>
+    : public __bool_constant<noexcept(static_cast<_Tp>(std::declval<_Arg>()))>
+    { };
+
+  template<typename _Tp>
+    struct __is_nt_constructible_impl<true, _Tp>
+    : public __bool_constant<noexcept(_Tp())>
+    { };
+
+  template<typename _Tp, size_t _Num>
+    struct __is_nt_constructible_impl<true, _Tp[_Num]>
+    : public __bool_constant<noexcept(typename remove_all_extents<_Tp>::type())>
+    { };
+# 1001 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename _Tp, typename... _Args>
+    using __is_nothrow_constructible_impl
+      = __is_nt_constructible_impl<__is_constructible(_Tp, _Args...),
+       _Tp, _Args...>;
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_nothrow_constructible
+    : public __is_nothrow_constructible_impl<_Tp, _Args...>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_nothrow_default_constructible
+    : public __is_nothrow_constructible_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  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_impl<_Tp, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_copy_constructible
+    : public __is_nothrow_copy_constructible_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_move_constructible
+    : public __is_nothrow_move_constructible_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_assignable
+    : public __bool_constant<__is_assignable(_Tp, _Up)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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 __bool_constant<__is_assignable(_Tp&, const _Tp&)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_copy_assignable
+    : public __is_copy_assignable_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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 __bool_constant<__is_assignable(_Tp&, _Tp&&)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_move_assignable
+    : public __is_move_assignable_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl
+    : public __and_<__bool_constant<__is_assignable(_Tp, _Up)>,
+      __is_nt_assignable_impl<_Tp, _Up>>
+    { };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_nothrow_assignable
+    : public __is_nothrow_assignable_impl<_Tp, _Up>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp&, const _Tp&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_copy_assignable
+    : public __is_nt_copy_assignable_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  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_impl<_Tp&, _Tp&&>
+    { };
+
+
+  template<typename _Tp>
+    struct is_nothrow_move_assignable
+    : public __is_nt_move_assignable_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp, typename... _Args>
+    struct is_trivially_constructible
+    : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_trivially_default_constructible
+    : public __bool_constant<__is_trivially_constructible(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  struct __do_is_implicitly_default_constructible_impl
+  {
+    template <typename _Tp>
+    static void __helper(const _Tp&);
+
+    template <typename _Tp>
+    static true_type __test(const _Tp&,
+                            decltype(__helper<const _Tp&>({}))* = 0);
+
+    static false_type __test(...);
+  };
+
+  template<typename _Tp>
+    struct __is_implicitly_default_constructible_impl
+    : public __do_is_implicitly_default_constructible_impl
+    {
+      typedef decltype(__test(declval<_Tp>())) type;
+    };
+
+  template<typename _Tp>
+    struct __is_implicitly_default_constructible_safe
+    : public __is_implicitly_default_constructible_impl<_Tp>::type
+    { };
+
+  template <typename _Tp>
+    struct __is_implicitly_default_constructible
+    : public __and_<__is_constructible_impl<_Tp>,
+      __is_implicitly_default_constructible_safe<_Tp>>
+    { };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_trivially_copy_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_trivially_copy_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_trivially_copy_constructible_impl<_Tp, true>
+    : public __and_<__is_copy_constructible_impl<_Tp>,
+      integral_constant<bool,
+   __is_trivially_constructible(_Tp, const _Tp&)>>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_copy_constructible
+    : public __is_trivially_copy_constructible_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_trivially_move_constructible_impl;
+
+  template<typename _Tp>
+    struct __is_trivially_move_constructible_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_trivially_move_constructible_impl<_Tp, true>
+    : public __and_<__is_move_constructible_impl<_Tp>,
+      integral_constant<bool,
+   __is_trivially_constructible(_Tp, _Tp&&)>>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_move_constructible
+    : public __is_trivially_move_constructible_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_trivially_assignable
+    : public __bool_constant<__is_trivially_assignable(_Tp, _Up)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_trivially_copy_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_trivially_copy_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_trivially_copy_assignable_impl<_Tp, true>
+    : public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_copy_assignable
+    : public __is_trivially_copy_assignable_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+  template<typename _Tp, bool = __is_referenceable<_Tp>::value>
+    struct __is_trivially_move_assignable_impl;
+
+  template<typename _Tp>
+    struct __is_trivially_move_assignable_impl<_Tp, false>
+    : public false_type { };
+
+  template<typename _Tp>
+    struct __is_trivially_move_assignable_impl<_Tp, true>
+    : public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)>
+    { };
+
+
+  template<typename _Tp>
+    struct is_trivially_move_assignable
+    : public __is_trivially_move_assignable_impl<_Tp>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_trivially_destructible
+    : public __and_<__is_destructible_safe<_Tp>,
+      __bool_constant<__has_trivial_destructor(_Tp)>>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+  template<typename _Tp>
+    struct has_virtual_destructor
+    : public integral_constant<bool, __has_virtual_destructor(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+
+
+  template<typename _Tp>
+    struct alignment_of
+    : public integral_constant<std::size_t, alignof(_Tp)>
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  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 _Tp, typename _Up>
+    struct is_same
+
+    : public integral_constant<bool, __is_same_as(_Tp, _Up)>
+
+
+
+    { };
+# 1410 "/usr/include/c++/10.2.0/type_traits" 3
+  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;
+    };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+  template<typename _From, typename _To>
+    class __is_convertible_helper<_From, _To, false>
+    {
+      template<typename _To1>
+ static void __test_aux(_To1) noexcept;
+
+      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;
+    };
+#pragma GCC diagnostic pop
+
+
+  template<typename _From, typename _To>
+    struct is_convertible
+    : public __is_convertible_helper<_From, _To>::type
+    { };
+
+
+  template<typename _ToElementType, typename _FromElementType>
+    using __is_array_convertible
+      = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
+
+  template<typename _From, typename _To,
+           bool = __or_<is_void<_From>, is_function<_To>,
+                        is_array<_To>>::value>
+    struct __is_nt_convertible_helper
+    : is_void<_To>
+    { };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+  template<typename _From, typename _To>
+    class __is_nt_convertible_helper<_From, _To, false>
+    {
+      template<typename _To1>
+ static void __test_aux(_To1) noexcept;
+
+      template<typename _From1, typename _To1>
+ static
+ __bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))>
+ __test(int);
+
+      template<typename, typename>
+ static false_type
+ __test(...);
+
+    public:
+      using type = decltype(__test<_From, _To>(0));
+    };
+#pragma GCC diagnostic pop
+
+
+  template<typename _From, typename _To>
+    struct __is_nothrow_convertible
+    : public __is_nt_convertible_helper<_From, _To>::type
+    { };
+# 1508 "/usr/include/c++/10.2.0/type_traits" 3
+  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
+    { using type = _Tp; };
+
+  template<typename _Tp>
+    struct remove_cv<const _Tp>
+    { using type = _Tp; };
+
+  template<typename _Tp>
+    struct remove_cv<volatile _Tp>
+    { using type = _Tp; };
+
+  template<typename _Tp>
+    struct remove_cv<const volatile _Tp>
+    { using type = _Tp; };
+
+
+  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; };
+
+
+  template<>
+    struct __make_unsigned<__int128>
+    { typedef unsigned __int128 __type; };
+# 1730 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename _Tp,
+    bool _IsInt = is_integral<_Tp>::value,
+    bool _IsEnum = is_enum<_Tp>::value>
+    class __make_unsigned_selector;
+
+  template<typename _Tp>
+    class __make_unsigned_selector<_Tp, true, false>
+    {
+      using __unsigned_type
+ = typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
+
+    public:
+      using __type
+ = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
+    };
+
+  class __make_unsigned_selector_base
+  {
+  protected:
+    template<typename...> struct _List { };
+
+    template<typename _Tp, typename... _Up>
+      struct _List<_Tp, _Up...> : _List<_Up...>
+      { static constexpr size_t __size = sizeof(_Tp); };
+
+    template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)>
+      struct __select;
+
+    template<size_t _Sz, typename _Uint, typename... _UInts>
+      struct __select<_Sz, _List<_Uint, _UInts...>, true>
+      { using __type = _Uint; };
+
+    template<size_t _Sz, typename _Uint, typename... _UInts>
+      struct __select<_Sz, _List<_Uint, _UInts...>, false>
+      : __select<_Sz, _List<_UInts...>>
+      { };
+  };
+
+
+  template<typename _Tp>
+    class __make_unsigned_selector<_Tp, false, true>
+    : __make_unsigned_selector_base
+    {
+
+      using _UInts = _List<unsigned char, unsigned short, unsigned int,
+      unsigned long, unsigned long long>;
+
+      using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type;
+
+    public:
+      using __type
+ = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
+    };
+
+
+
+
+
+
+  template<>
+    struct __make_unsigned<wchar_t>
+    {
+      using __type
+ = typename __make_unsigned_selector<wchar_t, false, true>::__type;
+    };
+# 1806 "/usr/include/c++/10.2.0/type_traits" 3
+  template<>
+    struct __make_unsigned<char16_t>
+    {
+      using __type
+ = typename __make_unsigned_selector<char16_t, false, true>::__type;
+    };
+
+  template<>
+    struct __make_unsigned<char32_t>
+    {
+      using __type
+ = typename __make_unsigned_selector<char32_t, false, true>::__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<unsigned __int128>
+    { typedef __int128 __type; };
+# 1884 "/usr/include/c++/10.2.0/type_traits" 3
+  template<typename _Tp,
+    bool _IsInt = is_integral<_Tp>::value,
+    bool _IsEnum = is_enum<_Tp>::value>
+    class __make_signed_selector;
+
+  template<typename _Tp>
+    class __make_signed_selector<_Tp, true, false>
+    {
+      using __signed_type
+ = typename __make_signed<__remove_cv_t<_Tp>>::__type;
+
+    public:
+      using __type
+ = typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
+    };
+
+
+  template<typename _Tp>
+    class __make_signed_selector<_Tp, false, true>
+    {
+      typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type;
+
+    public:
+      typedef typename __make_signed_selector<__unsigned_type>::__type __type;
+    };
+
+
+
+
+
+
+  template<>
+    struct __make_signed<wchar_t>
+    {
+      using __type
+ = typename __make_signed_selector<wchar_t, false, true>::__type;
+    };
+# 1932 "/usr/include/c++/10.2.0/type_traits" 3
+  template<>
+    struct __make_signed<char16_t>
+    {
+      using __type
+ = typename __make_signed_selector<char16_t, false, true>::__type;
+    };
+
+  template<>
+    struct __make_signed<char32_t>
+    {
+      using __type
+ = typename __make_signed_selector<char32_t, false, true>::__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, __remove_cv_t<_Tp>>
+    { };
+
+
+  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;
+      };
+    };
+# 2067 "/usr/include/c++/10.2.0/type_traits" 3
+  template<std::size_t _Len, std::size_t _Align =
+    __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+    struct aligned_storage
+    {
+      union type
+      {
+ unsigned char __data[_Len];
+ struct __attribute__((__aligned__((_Align)))) { } __align;
+      };
+    };
+
+  template <typename... _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;
+    };
+# 2106 "/usr/include/c++/10.2.0/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 __remove_cv_t<_Up> __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>
+    using __decay_t = typename decay<_Tp>::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>
+    using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
+
+
+
+
+  template<bool, typename _Tp = void>
+    struct enable_if
+    { };
+
+
+  template<typename _Tp>
+    struct enable_if<true, _Tp>
+    { typedef _Tp type; };
+
+
+  template<bool _Cond, typename _Tp = void>
+    using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
+
+  template<typename... _Cond>
+    using _Require = __enable_if_t<__and_<_Cond...>::value>;
+
+
+
+  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>
+    using __remove_cvref_t
+     = typename remove_cv<typename remove_reference<_Tp>::type>::type;
+
+
+  template<typename... _Tp>
+    struct common_type;
+
+
+
+  struct __do_common_type_impl
+  {
+    template<typename _Tp, typename _Up>
+      using __cond_t
+ = decltype(true ? std::declval<_Tp>() : std::declval<_Up>());
+
+
+
+    template<typename _Tp, typename _Up>
+      static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
+      _S_test(int);
+# 2239 "/usr/include/c++/10.2.0/type_traits" 3
+    template<typename, typename>
+      static __failure_type
+      _S_test_2(...);
+
+    template<typename _Tp, typename _Up>
+      static decltype(_S_test_2<_Tp, _Up>(0))
+      _S_test(...);
+  };
+
+
+  template<>
+    struct common_type<>
+    { };
+
+
+  template<typename _Tp0>
+    struct common_type<_Tp0>
+    : public common_type<_Tp0, _Tp0>
+    { };
+
+
+  template<typename _Tp1, typename _Tp2,
+    typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>>
+    struct __common_type_impl
+    {
+
+
+      using type = common_type<_Dp1, _Dp2>;
+    };
+
+  template<typename _Tp1, typename _Tp2>
+    struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
+    : private __do_common_type_impl
+    {
+
+
+      using type = decltype(_S_test<_Tp1, _Tp2>(0));
+    };
+
+
+  template<typename _Tp1, typename _Tp2>
+    struct common_type<_Tp1, _Tp2>
+    : public __common_type_impl<_Tp1, _Tp2>::type
+    { };
+
+  template<typename...>
+    struct __common_type_pack
+    { };
+
+  template<typename, typename, typename = void>
+    struct __common_type_fold;
+
+
+  template<typename _Tp1, typename _Tp2, typename... _Rp>
+    struct common_type<_Tp1, _Tp2, _Rp...>
+    : public __common_type_fold<common_type<_Tp1, _Tp2>,
+    __common_type_pack<_Rp...>>
+    { };
+
+
+
+
+  template<typename _CTp, typename... _Rp>
+    struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
+         __void_t<typename _CTp::type>>
+    : public common_type<typename _CTp::type, _Rp...>
+    { };
+
+
+  template<typename _CTp, typename _Rp>
+    struct __common_type_fold<_CTp, _Rp, void>
+    { };
+
+  template<typename _Tp, bool = is_enum<_Tp>::value>
+    struct __underlying_type_impl
+    {
+      using type = __underlying_type(_Tp);
+    };
+
+  template<typename _Tp>
+    struct __underlying_type_impl<_Tp, false>
+    { };
+
+
+  template<typename _Tp>
+    struct underlying_type
+    : public __underlying_type_impl<_Tp>
+    { };
+
+  template<typename _Tp>
+    struct __declval_protector
+    {
+      static const bool __stop = false;
+    };
+
+  template<typename _Tp>
+    auto declval() noexcept -> decltype(__declval<_Tp>(0))
+    {
+      static_assert(__declval_protector<_Tp>::__stop,
+      "declval() must not be used!");
+      return __declval<_Tp>(0);
+    }
+
+
+  template<typename _Signature>
+    class result_of;
+
+
+
+
+
+  struct __invoke_memfun_ref { };
+  struct __invoke_memfun_deref { };
+  struct __invoke_memobj_ref { };
+  struct __invoke_memobj_deref { };
+  struct __invoke_other { };
+
+
+  template<typename _Tp, typename _Tag>
+    struct __result_of_success : __success_type<_Tp>
+    { using __invoke_type = _Tag; };
+
+
+  struct __result_of_memfun_ref_impl
+  {
+    template<typename _Fp, typename _Tp1, typename... _Args>
+      static __result_of_success<decltype(
+      (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
+      ), __invoke_memfun_ref> _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 __result_of_success<decltype(
+      ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
+      ), __invoke_memfun_deref> _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 __result_of_success<decltype(
+      std::declval<_Tp1>().*std::declval<_Fp>()
+      ), __invoke_memobj_ref> _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 __result_of_success<decltype(
+      (*std::declval<_Tp1>()).*std::declval<_Fp>()
+      ), __invoke_memobj_deref> _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 __remove_cvref_t<_Arg> _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_reference<_Arg>::type _Argval;
+      typedef _Res _Class::* _MemPtr;
+      typedef typename conditional<is_base_of<_Class, _Argval>::value,
+        __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
+        __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
+      >::type::type type;
+    };
+
+
+
+
+
+
+  template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>>
+    struct __inv_unwrap
+    {
+      using type = _Tp;
+    };
+
+  template<typename _Tp, typename _Up>
+    struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
+    {
+      using type = _Up&;
+    };
+
+  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<__decay_t<_MemPtr>,
+    typename __inv_unwrap<_Arg>::type>
+    { };
+
+  template<typename _MemPtr, typename _Arg, typename... _Args>
+    struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
+    : public __result_of_memfun<__decay_t<_MemPtr>,
+    typename __inv_unwrap<_Arg>::type, _Args...>
+    { };
+
+
+  struct __result_of_other_impl
+  {
+    template<typename _Fn, typename... _Args>
+      static __result_of_success<decltype(
+      std::declval<_Fn>()(std::declval<_Args>()...)
+      ), __invoke_other> _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 __invoke_result
+    : 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<typename _Functor, typename... _ArgTypes>
+    struct result_of<_Functor(_ArgTypes...)>
+    : public __invoke_result<_Functor, _ArgTypes...>
+    { };
+
+
+
+  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;
+
+
+
+  template<typename _Default, typename _AlwaysVoid,
+    template<typename...> class _Op, typename... _Args>
+    struct __detector
+    {
+      using value_t = false_type;
+      using type = _Default;
+    };
+
+
+  template<typename _Default, template<typename...> class _Op,
+     typename... _Args>
+    struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...>
+    {
+      using value_t = true_type;
+      using type = _Op<_Args...>;
+    };
+
+
+  template<typename _Default, template<typename...> class _Op,
+    typename... _Args>
+    using __detected_or = __detector<_Default, void, _Op, _Args...>;
+
+
+  template<typename _Default, template<typename...> class _Op,
+    typename... _Args>
+    using __detected_or_t
+      = typename __detected_or<_Default, _Op, _Args...>::type;
+# 2624 "/usr/include/c++/10.2.0/type_traits" 3
+  template <typename _Tp>
+    struct __is_swappable;
+
+  template <typename _Tp>
+    struct __is_nothrow_swappable;
+
+  template<typename... _Elements>
+    class tuple;
+
+  template<typename>
+    struct __is_tuple_like_impl : false_type
+    { };
+
+  template<typename... _Tps>
+    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_tuple_like
+    : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
+    { };
+
+  template<typename _Tp>
+   
+    inline
+    _Require<__not_<__is_tuple_like<_Tp>>,
+      is_move_constructible<_Tp>,
+      is_move_assignable<_Tp>>
+    swap(_Tp&, _Tp&)
+    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+             is_nothrow_move_assignable<_Tp>>::value);
+
+  template<typename _Tp, size_t _Nm>
+   
+    inline
+    __enable_if_t<__is_swappable<_Tp>::value>
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+    noexcept(__is_nothrow_swappable<_Tp>::value);
+
+  namespace __swappable_details {
+    using std::swap;
+
+    struct __do_is_swappable_impl
+    {
+      template<typename _Tp, typename
+               = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
+        static true_type __test(int);
+
+      template<typename>
+        static false_type __test(...);
+    };
+
+    struct __do_is_nothrow_swappable_impl
+    {
+      template<typename _Tp>
+        static __bool_constant<
+          noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
+        > __test(int);
+
+      template<typename>
+        static false_type __test(...);
+    };
+
+  }
+
+  template<typename _Tp>
+    struct __is_swappable_impl
+    : public __swappable_details::__do_is_swappable_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp>
+    struct __is_nothrow_swappable_impl
+    : public __swappable_details::__do_is_nothrow_swappable_impl
+    {
+      typedef decltype(__test<_Tp>(0)) type;
+    };
+
+  template<typename _Tp>
+    struct __is_swappable
+    : public __is_swappable_impl<_Tp>::type
+    { };
+
+  template<typename _Tp>
+    struct __is_nothrow_swappable
+    : public __is_nothrow_swappable_impl<_Tp>::type
+    { };
+
+
+
+
+
+
+  template<typename _Tp>
+    struct is_swappable
+    : public __is_swappable_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+  template<typename _Tp>
+    struct is_nothrow_swappable
+    : public __is_nothrow_swappable_impl<_Tp>::type
+    {
+      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+    };
+
+
+
+  template<typename _Tp>
+    constexpr bool is_swappable_v =
+      is_swappable<_Tp>::value;
+
+
+  template<typename _Tp>
+    constexpr bool is_nothrow_swappable_v =
+      is_nothrow_swappable<_Tp>::value;
+
+
+  namespace __swappable_with_details {
+    using std::swap;
+
+    struct __do_is_swappable_with_impl
+    {
+      template<typename _Tp, typename _Up, typename
+               = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
+               typename
+               = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
+        static true_type __test(int);
+
+      template<typename, typename>
+        static false_type __test(...);
+    };
+
+    struct __do_is_nothrow_swappable_with_impl
+    {
+      template<typename _Tp, typename _Up>
+        static __bool_constant<
+          noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
+          &&
+          noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
+        > __test(int);
+
+      template<typename, typename>
+        static false_type __test(...);
+    };
+
+  }
+
+  template<typename _Tp, typename _Up>
+    struct __is_swappable_with_impl
+    : public __swappable_with_details::__do_is_swappable_with_impl
+    {
+      typedef decltype(__test<_Tp, _Up>(0)) type;
+    };
+
+
+  template<typename _Tp>
+    struct __is_swappable_with_impl<_Tp&, _Tp&>
+    : public __swappable_details::__do_is_swappable_impl
+    {
+      typedef decltype(__test<_Tp&>(0)) type;
+    };
+
+  template<typename _Tp, typename _Up>
+    struct __is_nothrow_swappable_with_impl
+    : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
+    {
+      typedef decltype(__test<_Tp, _Up>(0)) type;
+    };
+
+
+  template<typename _Tp>
+    struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
+    : public __swappable_details::__do_is_nothrow_swappable_impl
+    {
+      typedef decltype(__test<_Tp&>(0)) type;
+    };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_swappable_with
+    : public __is_swappable_with_impl<_Tp, _Up>::type
+    { };
+
+
+  template<typename _Tp, typename _Up>
+    struct is_nothrow_swappable_with
+    : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
+    { };
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr bool is_swappable_with_v =
+      is_swappable_with<_Tp, _Up>::value;
+
+
+  template<typename _Tp, typename _Up>
+    constexpr bool is_nothrow_swappable_with_v =
+      is_nothrow_swappable_with<_Tp, _Up>::value;
+
+
+
+
+
+
+
+  template<typename _Result, typename _Ret,
+    bool = is_void<_Ret>::value, typename = void>
+    struct __is_invocable_impl : false_type { };
+
+
+  template<typename _Result, typename _Ret>
+    struct __is_invocable_impl<_Result, _Ret,
+                                true,
+          __void_t<typename _Result::type>>
+    : true_type
+    { };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+
+  template<typename _Result, typename _Ret>
+    struct __is_invocable_impl<_Result, _Ret,
+                                false,
+          __void_t<typename _Result::type>>
+    {
+    private:
+
+
+      static typename _Result::type _S_get();
+
+      template<typename _Tp>
+ static void _S_conv(_Tp);
+
+
+      template<typename _Tp, typename = decltype(_S_conv<_Tp>(_S_get()))>
+ static true_type
+ _S_test(int);
+
+      template<typename _Tp>
+ static false_type
+ _S_test(...);
+
+    public:
+      using type = decltype(_S_test<_Ret>(1));
+    };
+#pragma GCC diagnostic pop
+
+  template<typename _Fn, typename... _ArgTypes>
+    struct __is_invocable
+    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
+    { };
+
+  template<typename _Fn, typename _Tp, typename... _Args>
+    constexpr bool __call_is_nt(__invoke_memfun_ref)
+    {
+      using _Up = typename __inv_unwrap<_Tp>::type;
+      return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
+     std::declval<_Args>()...));
+    }
+
+  template<typename _Fn, typename _Tp, typename... _Args>
+    constexpr bool __call_is_nt(__invoke_memfun_deref)
+    {
+      return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
+     std::declval<_Args>()...));
+    }
+
+  template<typename _Fn, typename _Tp>
+    constexpr bool __call_is_nt(__invoke_memobj_ref)
+    {
+      using _Up = typename __inv_unwrap<_Tp>::type;
+      return noexcept(std::declval<_Up>().*std::declval<_Fn>());
+    }
+
+  template<typename _Fn, typename _Tp>
+    constexpr bool __call_is_nt(__invoke_memobj_deref)
+    {
+      return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
+    }
+
+  template<typename _Fn, typename... _Args>
+    constexpr bool __call_is_nt(__invoke_other)
+    {
+      return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
+    }
+
+  template<typename _Result, typename _Fn, typename... _Args>
+    struct __call_is_nothrow
+    : __bool_constant<
+ std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
+      >
+    { };
+
+  template<typename _Fn, typename... _Args>
+    using __call_is_nothrow_
+      = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
+
+
+  template<typename _Fn, typename... _Args>
+    struct __is_nothrow_invocable
+    : __and_<__is_invocable<_Fn, _Args...>,
+             __call_is_nothrow_<_Fn, _Args...>>::type
+    { };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+  struct __nonesuchbase {};
+  struct __nonesuch : private __nonesuchbase {
+    ~__nonesuch() = delete;
+    __nonesuch(__nonesuch const&) = delete;
+    void operator=(__nonesuch const&) = delete;
+  };
+#pragma GCC diagnostic pop
+# 3455 "/usr/include/c++/10.2.0/type_traits" 3
+
+}
+# 58 "/usr/include/c++/10.2.0/bits/move.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 74 "/usr/include/c++/10.2.0/bits/move.h" 3
+  template<typename _Tp>
+    constexpr _Tp&&
+    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
+    { return static_cast<_Tp&&>(__t); }
+
+
+
+
+
+
+
+  template<typename _Tp>
+    constexpr _Tp&&
+    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
+    {
+      static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
+      " substituting _Tp is an lvalue reference type");
+      return static_cast<_Tp&&>(__t);
+    }
+
+
+
+
+
+
+  template<typename _Tp>
+    constexpr typename std::remove_reference<_Tp>::type&&
+    move(_Tp&& __t) noexcept
+    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
+
+
+  template<typename _Tp>
+    struct __move_if_noexcept_cond
+    : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
+                    is_copy_constructible<_Tp>>::type { };
+# 118 "/usr/include/c++/10.2.0/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); }
+# 138 "/usr/include/c++/10.2.0/bits/move.h" 3
+  template<typename _Tp>
+    inline _Tp*
+    addressof(_Tp& __r) noexcept
+    { return std::__addressof(__r); }
+
+
+
+  template<typename _Tp>
+    const _Tp* addressof(const _Tp&&) = delete;
+
+
+  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;
+    }
+# 179 "/usr/include/c++/10.2.0/bits/move.h" 3
+  template<typename _Tp>
+   
+    inline
+
+    typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
+         is_move_constructible<_Tp>,
+         is_move_assignable<_Tp>>::value>::type
+
+
+
+    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
+
+    typename enable_if<__is_swappable<_Tp>::value>::type
+
+
+
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+    noexcept(__is_nothrow_swappable<_Tp>::value)
+    {
+      for (size_t __n = 0; __n < _Nm; ++__n)
+ swap(__a[__n], __b[__n]);
+    }
+
+
+
+}
+# 60 "/usr/include/c++/10.2.0/bits/stl_pair.h" 2 3
+# 69 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 80 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
+
+
+  constexpr piecewise_construct_t piecewise_construct =
+    piecewise_construct_t();
+
+
+
+
+  template<typename...>
+    class tuple;
+
+  template<std::size_t...>
+    struct _Index_tuple;
+
+
+
+
+
+
+  template <bool, typename _T1, typename _T2>
+    struct _PCC
+    {
+      template <typename _U1, typename _U2>
+      static constexpr bool _ConstructiblePair()
+      {
+ return __and_<is_constructible<_T1, const _U1&>,
+        is_constructible<_T2, const _U2&>>::value;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyConvertiblePair()
+      {
+ return __and_<is_convertible<const _U1&, _T1>,
+        is_convertible<const _U2&, _T2>>::value;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _MoveConstructiblePair()
+      {
+ return __and_<is_constructible<_T1, _U1&&>,
+        is_constructible<_T2, _U2&&>>::value;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyMoveConvertiblePair()
+      {
+ return __and_<is_convertible<_U1&&, _T1>,
+        is_convertible<_U2&&, _T2>>::value;
+      }
+
+      template <bool __implicit, typename _U1, typename _U2>
+      static constexpr bool _CopyMovePair()
+      {
+ using __do_converts = __and_<is_convertible<const _U1&, _T1>,
+      is_convertible<_U2&&, _T2>>;
+ using __converts = typename conditional<__implicit,
+           __do_converts,
+           __not_<__do_converts>>::type;
+ return __and_<is_constructible<_T1, const _U1&>,
+        is_constructible<_T2, _U2&&>,
+        __converts
+        >::value;
+      }
+
+      template <bool __implicit, typename _U1, typename _U2>
+      static constexpr bool _MoveCopyPair()
+      {
+ using __do_converts = __and_<is_convertible<_U1&&, _T1>,
+      is_convertible<const _U2&, _T2>>;
+ using __converts = typename conditional<__implicit,
+           __do_converts,
+           __not_<__do_converts>>::type;
+ return __and_<is_constructible<_T1, _U1&&>,
+        is_constructible<_T2, const _U2&&>,
+        __converts
+        >::value;
+      }
+  };
+
+  template <typename _T1, typename _T2>
+    struct _PCC<false, _T1, _T2>
+    {
+      template <typename _U1, typename _U2>
+      static constexpr bool _ConstructiblePair()
+      {
+ return false;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyConvertiblePair()
+      {
+ return false;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _MoveConstructiblePair()
+      {
+ return false;
+      }
+
+      template <typename _U1, typename _U2>
+      static constexpr bool _ImplicitlyMoveConvertiblePair()
+      {
+ return false;
+      }
+  };
+
+
+  template<typename _U1, typename _U2> class __pair_base
+  {
+
+    template<typename _T1, typename _T2> friend struct pair;
+    __pair_base() = default;
+    ~__pair_base() = default;
+    __pair_base(const __pair_base&) = default;
+    __pair_base& operator=(const __pair_base&) = delete;
+
+  };
+# 210 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  template<typename _T1, typename _T2>
+    struct pair
+    : private __pair_base<_T1, _T2>
+    {
+      typedef _T1 first_type;
+      typedef _T2 second_type;
+
+      _T1 first;
+      _T2 second;
+
+
+
+
+
+
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<__and_<
+                                     __is_implicitly_default_constructible<_U1>,
+                                     __is_implicitly_default_constructible<_U2>>
+                                   ::value, bool>::type = true>
+
+      constexpr pair()
+      : first(), second() { }
+
+
+      template <typename _U1 = _T1,
+                typename _U2 = _T2,
+                typename enable_if<__and_<
+                       is_default_constructible<_U1>,
+                       is_default_constructible<_U2>,
+                       __not_<
+                         __and_<__is_implicitly_default_constructible<_U1>,
+                                __is_implicitly_default_constructible<_U2>>>>
+                                   ::value, bool>::type = false>
+      explicit constexpr pair()
+      : first(), second() { }
+# 256 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+      using _PCCP = _PCC<true, _T1, _T2>;
+
+
+
+      template<typename _U1 = _T1, typename _U2=_T2, typename
+        enable_if<_PCCP::template
+      _ConstructiblePair<_U1, _U2>()
+                  && _PCCP::template
+      _ImplicitlyConvertiblePair<_U1, _U2>(),
+                         bool>::type=true>
+      constexpr pair(const _T1& __a, const _T2& __b)
+      : first(__a), second(__b) { }
+
+
+       template<typename _U1 = _T1, typename _U2=_T2, typename
+  enable_if<_PCCP::template
+       _ConstructiblePair<_U1, _U2>()
+                   && !_PCCP::template
+       _ImplicitlyConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+      explicit constexpr pair(const _T1& __a, const _T2& __b)
+      : first(__a), second(__b) { }
+# 288 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+      template <typename _U1, typename _U2>
+        using _PCCFP = _PCC<!is_same<_T1, _U1>::value
+       || !is_same<_T2, _U2>::value,
+       _T1, _T2>;
+
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _ConstructiblePair<_U1, _U2>()
+                  && _PCCFP<_U1, _U2>::template
+      _ImplicitlyConvertiblePair<_U1, _U2>(),
+     bool>::type=true>
+        constexpr pair(const pair<_U1, _U2>& __p)
+        : first(__p.first), second(__p.second) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _ConstructiblePair<_U1, _U2>()
+    && !_PCCFP<_U1, _U2>::template
+      _ImplicitlyConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+ explicit constexpr pair(const pair<_U1, _U2>& __p)
+ : first(__p.first), second(__p.second) { }
+
+
+
+      constexpr pair(const pair&) = default;
+      constexpr pair(pair&&) = default;
+
+
+      template<typename _U1, typename
+        enable_if<_PCCP::template
+      _MoveCopyPair<true, _U1, _T2>(),
+                         bool>::type=true>
+       constexpr pair(_U1&& __x, const _T2& __y)
+       : first(std::forward<_U1>(__x)), second(__y) { }
+
+      template<typename _U1, typename
+        enable_if<_PCCP::template
+      _MoveCopyPair<false, _U1, _T2>(),
+                         bool>::type=false>
+       explicit constexpr pair(_U1&& __x, const _T2& __y)
+       : first(std::forward<_U1>(__x)), second(__y) { }
+
+      template<typename _U2, typename
+        enable_if<_PCCP::template
+      _CopyMovePair<true, _T1, _U2>(),
+                         bool>::type=true>
+       constexpr pair(const _T1& __x, _U2&& __y)
+       : first(__x), second(std::forward<_U2>(__y)) { }
+
+      template<typename _U2, typename
+        enable_if<_PCCP::template
+      _CopyMovePair<false, _T1, _U2>(),
+                         bool>::type=false>
+       explicit pair(const _T1& __x, _U2&& __y)
+       : first(__x), second(std::forward<_U2>(__y)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCP::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && _PCCP::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=true>
+ constexpr pair(_U1&& __x, _U2&& __y)
+ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCP::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && !_PCCP::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+ explicit constexpr pair(_U1&& __x, _U2&& __y)
+ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
+
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && _PCCFP<_U1, _U2>::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=true>
+ constexpr pair(pair<_U1, _U2>&& __p)
+ : first(std::forward<_U1>(__p.first)),
+   second(std::forward<_U2>(__p.second)) { }
+
+      template<typename _U1, typename _U2, typename
+        enable_if<_PCCFP<_U1, _U2>::template
+      _MoveConstructiblePair<_U1, _U2>()
+     && !_PCCFP<_U1, _U2>::template
+      _ImplicitlyMoveConvertiblePair<_U1, _U2>(),
+                         bool>::type=false>
+ explicit 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=(typename conditional<
+  __and_<is_copy_assignable<_T1>,
+         is_copy_assignable<_T2>>::value,
+  const pair&, const __nonesuch&>::type __p)
+      {
+ first = __p.first;
+ second = __p.second;
+ return *this;
+      }
+
+      pair&
+      operator=(typename conditional<
+  __and_<is_move_assignable<_T1>,
+         is_move_assignable<_T2>>::value,
+  pair&&, __nonesuch&&>::type __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<typename _U1, typename _U2>
+
+ typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
+      is_assignable<_T2&, const _U2&>>::value,
+      pair&>::type
+ operator=(const pair<_U1, _U2>& __p)
+ {
+   first = __p.first;
+   second = __p.second;
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+
+ typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
+      is_assignable<_T2&, _U2&&>>::value,
+      pair&>::type
+ operator=(pair<_U1, _U2>&& __p)
+ {
+   first = std::forward<_U1>(__p.first);
+   second = std::forward<_U2>(__p.second);
+   return *this;
+ }
+
+
+      void
+      swap(pair& __p)
+      noexcept(__and_<__is_nothrow_swappable<_T1>,
+                      __is_nothrow_swappable<_T2>>::value)
+      {
+ 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...>);
+
+    };
+# 464 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first == __y.first && __x.second == __y.second; }
+# 487 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  template<typename _T1, typename _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<typename _T1, typename _T2>
+    inline constexpr bool
+    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __y < __x; }
+
+
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _T1, typename _T2>
+    inline constexpr bool
+    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x < __y); }
+# 524 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  template<typename _T1, typename _T2>
+    inline
+
+
+    typename enable_if<__and_<__is_swappable<_T1>,
+                              __is_swappable<_T2>>::value>::type
+
+
+
+    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+  template<typename _T1, typename _T2>
+    typename enable_if<!__and_<__is_swappable<_T1>,
+          __is_swappable<_T2>>::value>::type
+    swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
+# 564 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+  template<typename _T1, typename _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));
+    }
+# 583 "/usr/include/c++/10.2.0/bits/stl_pair.h" 3
+
+}
+# 65 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 1 3
+# 62 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+       
+# 63 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+# 74 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 93 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+  struct input_iterator_tag { };
+
+
+  struct output_iterator_tag { };
+
+
+  struct forward_iterator_tag : public input_iterator_tag { };
+
+
+
+  struct bidirectional_iterator_tag : public forward_iterator_tag { };
+
+
+
+  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
+# 125 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
+           typename _Pointer = _Tp*, typename _Reference = _Tp&>
+    struct iterator
+    {
+
+      typedef _Category iterator_category;
+
+      typedef _Tp value_type;
+
+      typedef _Distance difference_type;
+
+      typedef _Pointer pointer;
+
+      typedef _Reference reference;
+    };
+# 149 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+  template<typename _Iterator>
+    struct iterator_traits;
+
+
+
+
+  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> { };
+# 209 "/usr/include/c++/10.2.0/bits/stl_iterator_base_types.h" 3
+  template<typename _Tp>
+    struct iterator_traits<_Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef _Tp& reference;
+    };
+
+
+  template<typename _Tp>
+    struct iterator_traits<const _Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef const _Tp* pointer;
+      typedef const _Tp& reference;
+    };
+
+
+
+
+
+
+  template<typename _Iter>
+    inline constexpr
+    typename iterator_traits<_Iter>::iterator_category
+    __iterator_category(const _Iter&)
+    { return typename iterator_traits<_Iter>::iterator_category(); }
+
+
+
+
+  template<typename _Iter>
+    using __iterator_category_t
+      = typename iterator_traits<_Iter>::iterator_category;
+
+  template<typename _InIter>
+    using _RequireInputIter =
+      __enable_if_t<is_convertible<__iterator_category_t<_InIter>,
+       input_iterator_tag>::value>;
+
+  template<typename _It,
+    typename _Cat = __iterator_category_t<_It>>
+    struct __is_random_access_iter
+      : is_base_of<random_access_iterator_tag, _Cat>
+    {
+      typedef is_base_of<random_access_iterator_tag, _Cat> _Base;
+      enum { __value = _Base::value };
+    };
+
+
+
+
+
+
+
+
+}
+# 66 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 1 3
+# 62 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 3
+       
+# 63 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/concept_check.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/concept_check.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/concept_check.h" 3
+# 65 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 2 3
+# 1 "/usr/include/c++/10.2.0/debug/assertions.h" 1 3
+# 66 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template <typename> struct _List_iterator;
+  template <typename> struct _List_const_iterator;
+
+
+  template<typename _InputIterator>
+    inline constexpr
+    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 constexpr
+    typename iterator_traits<_RandomAccessIterator>::difference_type
+    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
+               random_access_iterator_tag)
+    {
+
+     
+
+      return __last - __first;
+    }
+
+
+
+  template<typename _Tp>
+    ptrdiff_t
+    __distance(std::_List_iterator<_Tp>,
+        std::_List_iterator<_Tp>,
+        input_iterator_tag);
+
+  template<typename _Tp>
+    ptrdiff_t
+    __distance(std::_List_const_iterator<_Tp>,
+        std::_List_const_iterator<_Tp>,
+        input_iterator_tag);
+# 135 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 3
+  template<typename _InputIterator>
+    inline
+    typename iterator_traits<_InputIterator>::difference_type
+    distance(_InputIterator __first, _InputIterator __last)
+    {
+
+      return std::__distance(__first, __last,
+        std::__iterator_category(__first));
+    }
+
+  template<typename _InputIterator, typename _Distance>
+    inline constexpr void
+    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
+    {
+
+     
+      ;
+      while (__n--)
+ ++__i;
+    }
+
+  template<typename _BidirectionalIterator, typename _Distance>
+    inline constexpr 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 constexpr void
+    __advance(_RandomAccessIterator& __i, _Distance __n,
+              random_access_iterator_tag)
+    {
+
+     
+
+      if (__builtin_constant_p(__n) && __n == 1)
+ ++__i;
+      else if (__builtin_constant_p(__n) && __n == -1)
+ --__i;
+      else
+ __i += __n;
+    }
+# 200 "/usr/include/c++/10.2.0/bits/stl_iterator_base_funcs.h" 3
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    advance(_InputIterator& __i, _Distance __n)
+    {
+
+      typename iterator_traits<_InputIterator>::difference_type __d = __n;
+      std::__advance(__i, __d, std::__iterator_category(__i));
+    }
+
+
+
+  template<typename _InputIterator>
+    inline _InputIterator
+    next(_InputIterator __x, typename
+  iterator_traits<_InputIterator>::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 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 1 3
+# 66 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+# 1 "/usr/include/c++/10.2.0/bits/ptr_traits.h" 1 3
+# 42 "/usr/include/c++/10.2.0/bits/ptr_traits.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  class __undefined;
+
+
+  template<typename _Tp>
+    struct __get_first_arg
+    { using type = __undefined; };
+
+  template<template<typename, typename...> class _Template, typename _Tp,
+           typename... _Types>
+    struct __get_first_arg<_Template<_Tp, _Types...>>
+    { using type = _Tp; };
+
+  template<typename _Tp>
+    using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
+
+
+  template<typename _Tp, typename _Up>
+    struct __replace_first_arg
+    { };
+
+  template<template<typename, typename...> class _Template, typename _Up,
+           typename _Tp, typename... _Types>
+    struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
+    { using type = _Template<_Up, _Types...>; };
+
+  template<typename _Tp, typename _Up>
+    using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
+
+  template<typename _Tp>
+    using __make_not_void
+      = typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
+
+
+
+
+
+  template<typename _Ptr>
+    struct pointer_traits
+    {
+    private:
+      template<typename _Tp>
+ using __element_type = typename _Tp::element_type;
+
+      template<typename _Tp>
+ using __difference_type = typename _Tp::difference_type;
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __rebind : __replace_first_arg<_Tp, _Up> { };
+
+      template<typename _Tp, typename _Up>
+ struct __rebind<_Tp, _Up, __void_t<typename _Tp::template rebind<_Up>>>
+ { using type = typename _Tp::template rebind<_Up>; };
+
+    public:
+
+      using pointer = _Ptr;
+
+
+      using element_type
+ = __detected_or_t<__get_first_arg_t<_Ptr>, __element_type, _Ptr>;
+
+
+      using difference_type
+ = __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
+
+
+      template<typename _Up>
+        using rebind = typename __rebind<_Ptr, _Up>::type;
+
+      static _Ptr
+      pointer_to(__make_not_void<element_type>& __e)
+      { return _Ptr::pointer_to(__e); }
+
+      static_assert(!is_same<element_type, __undefined>::value,
+   "pointer type defines element_type or is like SomePointer<T, Args>");
+    };
+
+
+
+
+
+  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(__make_not_void<element_type>& __r) noexcept
+      { return std::addressof(__r); }
+    };
+
+
+  template<typename _Ptr, typename _Tp>
+    using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
+
+  template<typename _Tp>
+    constexpr _Tp*
+    __to_address(_Tp* __ptr) noexcept
+    {
+      static_assert(!std::is_function<_Tp>::value, "not a function pointer");
+      return __ptr;
+    }
+
+
+  template<typename _Ptr>
+    constexpr typename std::pointer_traits<_Ptr>::element_type*
+    __to_address(const _Ptr& __ptr)
+    { return std::__to_address(__ptr.operator->()); }
+# 210 "/usr/include/c++/10.2.0/bits/ptr_traits.h" 3
+
+}
+# 67 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 2 3
+# 85 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 124 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    class reverse_iterator
+    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
+        typename iterator_traits<_Iterator>::value_type,
+        typename iterator_traits<_Iterator>::difference_type,
+        typename iterator_traits<_Iterator>::pointer,
+                      typename iterator_traits<_Iterator>::reference>
+    {
+    protected:
+      _Iterator current;
+
+      typedef iterator_traits<_Iterator> __traits_type;
+
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef typename __traits_type::pointer pointer;
+      typedef typename __traits_type::reference reference;
+# 160 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+     
+      reverse_iterator() : current() { }
+
+
+
+
+      explicit
+      reverse_iterator(iterator_type __x) : current(__x) { }
+
+
+
+
+     
+      reverse_iterator(const reverse_iterator& __x)
+      : current(__x.current) { }
+
+
+      reverse_iterator& operator=(const reverse_iterator&) = default;
+
+
+
+
+
+
+      template<typename _Iter>
+
+        reverse_iterator(const reverse_iterator<_Iter>& __x)
+ : current(__x.base()) { }
+
+
+
+
+      iterator_type
+      base() const
+      { return current; }
+# 206 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+      reference
+      operator*() const
+      {
+ _Iterator __tmp = current;
+ return *--__tmp;
+      }
+
+
+
+
+
+
+      pointer
+      operator->() const
+
+
+
+
+      {
+
+
+ _Iterator __tmp = current;
+ --__tmp;
+ return _S_to_pointer(__tmp);
+      }
+
+
+
+
+
+
+      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); }
+
+    private:
+      template<typename _Tp>
+ static _Tp*
+ _S_to_pointer(_Tp* __p)
+        { return __p; }
+
+      template<typename _Tp>
+ static pointer
+ _S_to_pointer(_Tp __t)
+        { return __t.operator->(); }
+    };
+# 358 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    inline bool
+    operator==(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y.base() < __x.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator!=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y < __x; }
+
+  template<typename _Iterator>
+    inline bool
+    operator<=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _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); }
+# 498 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  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(); }
+
+
+  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 _Iterator>
+    inline reverse_iterator<_Iterator>
+    __make_reverse_iterator(_Iterator __i)
+    { return reverse_iterator<_Iterator>(__i); }
+
+
+
+
+
+
+
+  template<typename _Iterator>
+    inline reverse_iterator<_Iterator>
+    make_reverse_iterator(_Iterator __i)
+    { return reverse_iterator<_Iterator>(__i); }
+# 539 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+   
+    auto
+    __niter_base(reverse_iterator<_Iterator> __it)
+    -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
+    { return __make_reverse_iterator(__niter_base(__it.base())); }
+
+  template<typename _Iterator>
+    struct __is_move_iterator<reverse_iterator<_Iterator> >
+      : __is_move_iterator<_Iterator>
+    { };
+
+  template<typename _Iterator>
+   
+    auto
+    __miter_base(reverse_iterator<_Iterator> __it)
+    -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
+    { return __make_reverse_iterator(__miter_base(__it.base())); }
+# 570 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class back_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+
+    public:
+
+      typedef _Container container_type;
+
+
+
+
+
+
+
+      explicit
+      back_insert_iterator(_Container& __x)
+      : container(std::__addressof(__x)) { }
+# 610 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+     
+      back_insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+ container->push_back(__value);
+ return *this;
+      }
+
+     
+      back_insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+ container->push_back(std::move(__value));
+ return *this;
+      }
+
+
+
+     
+      back_insert_iterator&
+      operator*()
+      { return *this; }
+
+
+     
+      back_insert_iterator&
+      operator++()
+      { return *this; }
+
+
+     
+      back_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+# 657 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Container>
+   
+    inline back_insert_iterator<_Container>
+    back_inserter(_Container& __x)
+    { return back_insert_iterator<_Container>(__x); }
+# 673 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class front_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _Container* container;
+
+    public:
+
+      typedef _Container container_type;
+
+
+
+
+
+
+
+      explicit
+      front_insert_iterator(_Container& __x)
+      : container(std::__addressof(__x)) { }
+# 713 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+     
+      front_insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+ container->push_front(__value);
+ return *this;
+      }
+
+     
+      front_insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+ container->push_front(std::move(__value));
+ return *this;
+      }
+
+
+
+     
+      front_insert_iterator&
+      operator*()
+      { return *this; }
+
+
+     
+      front_insert_iterator&
+      operator++()
+      { return *this; }
+
+
+     
+      front_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+# 760 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Container>
+   
+    inline front_insert_iterator<_Container>
+    front_inserter(_Container& __x)
+    { return front_insert_iterator<_Container>(__x); }
+# 780 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+
+
+
+
+
+
+
+      typedef typename _Container::iterator _Iter;
+
+    protected:
+      _Container* container;
+      _Iter iter;
+
+
+    public:
+
+      typedef _Container container_type;
+# 812 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+     
+      insert_iterator(_Container& __x, _Iter __i)
+      : container(std::__addressof(__x)), iter(__i) {}
+# 848 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+     
+      insert_iterator&
+      operator=(const typename _Container::value_type& __value)
+      {
+ iter = container->insert(iter, __value);
+ ++iter;
+ return *this;
+      }
+
+     
+      insert_iterator&
+      operator=(typename _Container::value_type&& __value)
+      {
+ iter = container->insert(iter, std::move(__value));
+ ++iter;
+ return *this;
+      }
+
+
+
+     
+      insert_iterator&
+      operator*()
+      { return *this; }
+
+
+     
+      insert_iterator&
+      operator++()
+      { return *this; }
+
+
+     
+      insert_iterator&
+      operator++(int)
+      { return *this; }
+    };
+# 904 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Container, typename _Iterator>
+    inline insert_iterator<_Container>
+    inserter(_Container& __x, _Iterator __i)
+    {
+      return insert_iterator<_Container>(__x,
+      typename _Container::iterator(__i));
+    }
+
+
+
+
+
+}
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+# 929 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator
+    {
+    protected:
+      _Iterator _M_current;
+
+      typedef std::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; }
+    };
+# 1061 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+   
+    inline bool
+    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    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")))
+{
+
+
+  template<typename _Iterator, typename _Container>
+   
+    _Iterator
+    __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
+    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
+    { return __it.base(); }
+# 1260 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    class move_iterator
+    {
+      _Iterator _M_current;
+
+      using __traits_type = iterator_traits<_Iterator>;
+
+
+
+      using __base_ref = typename __traits_type::reference;
+
+
+    public:
+      using iterator_type = _Iterator;
+# 1284 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+      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(std::move(__i)) { }
+
+      template<typename _Iter>
+
+ move_iterator(const move_iterator<_Iter>& __i)
+ : _M_current(__i.base()) { }
+
+
+      iterator_type
+      base() const
+      { return _M_current; }
+# 1326 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+      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]); }
+# 1423 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+    };
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator==(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+
+
+
+    { return __x.base() == __y.base(); }
+# 1442 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator!=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __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 _IteratorL, typename _IteratorR>
+    inline bool
+    operator<=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __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 _IteratorL, typename _IteratorR>
+    inline bool
+    operator>=(const move_iterator<_IteratorL>& __x,
+        const move_iterator<_IteratorR>& __y)
+
+
+
+    { return !(__x < __y); }
+# 1493 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    inline bool
+    operator==(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator!=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<(const move_iterator<_Iterator>& __x,
+       const move_iterator<_Iterator>& __y)
+    { return __x.base() < __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<=(const move_iterator<_Iterator>& __x,
+        const move_iterator<_Iterator>& __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 _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 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>(std::move(__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); }
+
+
+
+  template<typename _Tp, typename _ReturnType
+    = typename conditional<__move_if_noexcept_cond<_Tp>::value,
+      const _Tp*, move_iterator<_Tp*>>::type>
+    inline _ReturnType
+    __make_move_if_noexcept_iterator(_Tp* __i)
+    { return _ReturnType(__i); }
+# 2154 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    auto
+    __niter_base(move_iterator<_Iterator> __it)
+    -> decltype(make_move_iterator(__niter_base(__it.base())))
+    { return make_move_iterator(__niter_base(__it.base())); }
+
+  template<typename _Iterator>
+    struct __is_move_iterator<move_iterator<_Iterator> >
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<typename _Iterator>
+    auto
+    __miter_base(move_iterator<_Iterator> __it)
+    -> decltype(__miter_base(__it.base()))
+    { return __miter_base(__it.base()); }
+# 2201 "/usr/include/c++/10.2.0/bits/stl_iterator.h" 3
+
+}
+# 68 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/debug/debug.h" 1 3
+# 48 "/usr/include/c++/10.2.0/debug/debug.h" 3
+namespace std
+{
+  namespace __debug { }
+}
+
+
+
+
+namespace __gnu_debug
+{
+  using namespace std::__debug;
+
+  template<typename _Ite, typename _Seq, typename _Cat>
+    struct _Safe_iterator;
+}
+# 70 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/predefined_ops.h" 1 3
+# 33 "/usr/include/c++/10.2.0/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
+  {
+
+    constexpr _Iter_less_val() = default;
+
+
+
+
+   
+    explicit
+    _Iter_less_val(_Iter_less_iter) { }
+
+    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
+  {
+
+    constexpr _Val_less_iter() = default;
+
+
+
+
+   
+    explicit
+    _Val_less_iter(_Iter_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;
+
+      explicit constexpr
+      _Iter_comp_iter(_Compare __comp)
+ : _M_comp(std::move(__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>(std::move(__comp)); }
+
+  template<typename _Compare>
+    struct _Iter_comp_val
+    {
+      _Compare _M_comp;
+
+     
+      explicit
+      _Iter_comp_val(_Compare __comp)
+ : _M_comp(std::move(__comp))
+      { }
+
+     
+      explicit
+      _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
+ : _M_comp(__comp._M_comp)
+      { }
+
+
+     
+      explicit
+      _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
+ : _M_comp(std::move(__comp._M_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>(std::move(__comp)); }
+
+  template<typename _Compare>
+   
+    inline _Iter_comp_val<_Compare>
+    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
+    { return _Iter_comp_val<_Compare>(std::move(__comp)); }
+
+  template<typename _Compare>
+    struct _Val_comp_iter
+    {
+      _Compare _M_comp;
+
+     
+      explicit
+      _Val_comp_iter(_Compare __comp)
+ : _M_comp(std::move(__comp))
+      { }
+
+     
+      explicit
+      _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
+ : _M_comp(__comp._M_comp)
+      { }
+
+
+     
+      explicit
+      _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
+ : _M_comp(std::move(__comp._M_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>(std::move(__comp)); }
+
+  template<typename _Compare>
+   
+    inline _Val_comp_iter<_Compare>
+    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
+    { return _Val_comp_iter<_Compare>(std::move(__comp)); }
+
+  template<typename _Value>
+    struct _Iter_equals_val
+    {
+      _Value& _M_value;
+
+     
+      explicit
+      _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
+    {
+      _Iterator1 _M_it1;
+
+     
+      explicit
+      _Iter_equals_iter(_Iterator1 __it1)
+ : _M_it1(__it1)
+      { }
+
+      template<typename _Iterator2>
+
+ bool
+ operator()(_Iterator2 __it2)
+ { return *__it2 == *_M_it1; }
+    };
+
+  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;
+
+     
+      explicit
+      _Iter_pred(_Predicate __pred)
+ : _M_pred(std::move(__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>(std::move(__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(std::move(__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>(std::move(__comp), __val);
+    }
+
+  template<typename _Compare, typename _Iterator1>
+    struct _Iter_comp_to_iter
+    {
+      _Compare _M_comp;
+      _Iterator1 _M_it1;
+
+     
+      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
+ : _M_comp(std::move(__comp)), _M_it1(__it1)
+      { }
+
+      template<typename _Iterator2>
+
+ bool
+ operator()(_Iterator2 __it2)
+ { return bool(_M_comp(*__it2, *_M_it1)); }
+    };
+
+  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>(
+   std::move(__comp._M_comp), __it);
+    }
+
+  template<typename _Predicate>
+    struct _Iter_negate
+    {
+      _Predicate _M_pred;
+
+     
+      explicit
+      _Iter_negate(_Predicate __pred)
+ : _M_pred(std::move(__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>(std::move(__pred._M_pred)); }
+
+}
+}
+# 72 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 2 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr
+    inline int
+    __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num)
+    {
+
+      static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp");
+# 105 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+ return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num);
+    }
+# 149 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+   
+    inline void
+    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+    {
+
+     
+
+     
+# 182 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+      swap(*__a, *__b);
+
+    }
+# 198 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+   
+    _ForwardIterator2
+    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+  _ForwardIterator2 __first2)
+    {
+
+     
+
+     
+
+      ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ std::iter_swap(__first1, __first2);
+      return __first2;
+    }
+# 227 "/usr/include/c++/10.2.0/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;
+    }
+# 251 "/usr/include/c++/10.2.0/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;
+    }
+# 275 "/usr/include/c++/10.2.0/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;
+    }
+# 297 "/usr/include/c++/10.2.0/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>
+   
+    inline _Iterator
+    __niter_base(_Iterator __it)
+    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
+    { return __it; }
+
+
+
+
+  template<typename _From, typename _To>
+   
+    inline _From
+    __niter_wrap(_From __from, _To __res)
+    { return __from + (__res - std::__niter_base(__from)); }
+
+
+  template<typename _Iterator>
+   
+    inline _Iterator
+    __niter_wrap(const _Iterator&, _Iterator __res)
+    { return __res; }
+
+
+
+
+
+
+
+  template<bool _IsMove, bool _IsSimple, typename _Category>
+    struct __copy_move
+    {
+      template<typename _II, typename _OI>
+
+ static _OI
+ __copy_m(_II __first, _II __last, _OI __result)
+ {
+   for (; __first != __last; ++__result, (void)++__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, (void)++__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)
+ {
+
+   using __assignable = conditional<_IsMove,
+        is_move_assignable<_Tp>,
+        is_copy_assignable<_Tp>>;
+
+   static_assert( __assignable::type::value, "type is not assignable" );
+
+   const ptrdiff_t _Num = __last - __first;
+   if (_Num)
+     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
+   return __result + _Num;
+ }
+    };
+
+
+
+  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)
+    {
+      typedef typename iterator_traits<_II>::iterator_category _Category;
+
+
+
+
+
+      return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value,
+         _Category>::__copy_m(__first, __last, __result);
+    }
+
+
+
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    struct _Deque_iterator;
+
+
+
+  template<bool _IsMove,
+    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
+    _OI
+    __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+     std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+     _OI);
+
+  template<bool _IsMove,
+    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
+    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
+    __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>,
+     std::_Deque_iterator<_ITp, _IRef, _IPtr>,
+     std::_Deque_iterator<_OTp, _OTp&, _OTp*>);
+
+  template<bool _IsMove, typename _II, typename _Tp>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value,
+      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
+    __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<bool _IsMove, typename _II, typename _OI>
+   
+    inline _OI
+    __copy_move_a1(_II __first, _II __last, _OI __result)
+    { return std::__copy_move_a2<_IsMove>(__first, __last, __result); }
+
+  template<bool _IsMove, typename _II, typename _OI>
+   
+    inline _OI
+    __copy_move_a(_II __first, _II __last, _OI __result)
+    {
+      return std::__niter_wrap(__result,
+  std::__copy_move_a1<_IsMove>(std::__niter_base(__first),
+          std::__niter_base(__last),
+          std::__niter_base(__result)));
+    }
+
+  template<bool _IsMove,
+    typename _Ite, typename _Seq, typename _Cat, typename _OI>
+    _OI
+    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+    _OI);
+
+  template<bool _IsMove,
+    typename _II, typename _Ite, typename _Seq, typename _Cat>
+    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
+    __copy_move_a(_II, _II,
+    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);
+
+  template<bool _IsMove,
+    typename _IIte, typename _ISeq, typename _ICat,
+    typename _OIte, typename _OSeq, typename _OCat>
+    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
+    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
+    const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
+    const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);
+# 557 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _II, typename _OI>
+   
+    inline _OI
+    copy(_II __first, _II __last, _OI __result)
+    {
+
+     
+     
+
+      ;
+
+      return std::__copy_move_a<__is_move_iterator<_II>::__value>
+      (std::__miter_base(__first), std::__miter_base(__last), __result);
+    }
+# 590 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _II, typename _OI>
+   
+    inline _OI
+    move(_II __first, _II __last, _OI __result)
+    {
+
+     
+     
+
+      ;
+
+      return std::__copy_move_a<true>(std::__miter_base(__first),
+          std::__miter_base(__last), __result);
+    }
+
+
+
+
+
+
+  template<bool _IsMove, bool _IsSimple, typename _Category>
+    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 = __last - __first;
+   for (; __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 = __last - __first;
+   for (; __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)
+ {
+
+   using __assignable = conditional<_IsMove,
+        is_move_assignable<_Tp>,
+        is_copy_assignable<_Tp>>;
+
+   static_assert( __assignable::type::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_a2(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      typedef typename iterator_traits<_BI1>::iterator_category _Category;
+
+
+
+
+
+      return std::__copy_move_backward<_IsMove,
+           __memcpyable<_BI2, _BI1>::__value,
+           _Category>::__copy_move_b(__first,
+         __last,
+         __result);
+    }
+
+  template<bool _IsMove, typename _BI1, typename _BI2>
+   
+    inline _BI2
+    __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result)
+    { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); }
+
+  template<bool _IsMove,
+    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
+    _OI
+    __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+       std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+       _OI);
+
+  template<bool _IsMove,
+    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
+    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
+    __copy_move_backward_a1(
+   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
+   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
+   std::_Deque_iterator<_OTp, _OTp&, _OTp*>);
+
+  template<bool _IsMove, typename _II, typename _Tp>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value,
+      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
+    __copy_move_backward_a1(_II, _II,
+       std::_Deque_iterator<_Tp, _Tp&, _Tp*>);
+
+  template<bool _IsMove, typename _II, typename _OI>
+   
+    inline _OI
+    __copy_move_backward_a(_II __first, _II __last, _OI __result)
+    {
+      return std::__niter_wrap(__result,
+  std::__copy_move_backward_a1<_IsMove>
+    (std::__niter_base(__first), std::__niter_base(__last),
+     std::__niter_base(__result)));
+    }
+
+  template<bool _IsMove,
+    typename _Ite, typename _Seq, typename _Cat, typename _OI>
+    _OI
+    __copy_move_backward_a(
+  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+  _OI);
+
+  template<bool _IsMove,
+    typename _II, typename _Ite, typename _Seq, typename _Cat>
+    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
+    __copy_move_backward_a(_II, _II,
+  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);
+
+  template<bool _IsMove,
+    typename _IIte, typename _ISeq, typename _ICat,
+    typename _OIte, typename _OSeq, typename _OCat>
+    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
+    __copy_move_backward_a(
+  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
+  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
+  const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);
+# 794 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _BI1, typename _BI2>
+   
+    inline _BI2
+    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value>
+      (std::__miter_base(__first), std::__miter_base(__last), __result);
+    }
+# 830 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _BI1, typename _BI2>
+   
+    inline _BI2
+    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__copy_move_backward_a<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_a1(_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_a1(_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_a1(_Tp* __first, _Tp* __last, const _Tp& __c)
+    {
+      const _Tp __tmp = __c;
+# 892 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+      if (const size_t __len = __last - __first)
+ __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
+    }
+
+  template<typename _Ite, typename _Cont, typename _Tp>
+   
+    inline void
+    __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first,
+       ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last,
+       const _Tp& __value)
+    { std::__fill_a1(__first.base(), __last.base(), __value); }
+
+  template<typename _Tp, typename _VTp>
+    void
+    __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
+       const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
+       const _VTp&);
+
+  template<typename _FIte, typename _Tp>
+   
+    inline void
+    __fill_a(_FIte __first, _FIte __last, const _Tp& __value)
+    { std::__fill_a1(__first, __last, __value); }
+
+  template<typename _Ite, typename _Seq, typename _Cat, typename _Tp>
+    void
+    __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+      const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
+      const _Tp&);
+# 934 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    inline void
+    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
+    {
+
+     
+
+      ;
+
+      std::__fill_a(__first, __last, __value);
+    }
+
+
+  inline constexpr int
+  __size_to_integer(int __n) { return __n; }
+  inline constexpr unsigned
+  __size_to_integer(unsigned __n) { return __n; }
+  inline constexpr long
+  __size_to_integer(long __n) { return __n; }
+  inline constexpr unsigned long
+  __size_to_integer(unsigned long __n) { return __n; }
+  inline constexpr long long
+  __size_to_integer(long long __n) { return __n; }
+  inline constexpr unsigned long long
+  __size_to_integer(unsigned long long __n) { return __n; }
+
+
+  inline constexpr __int128
+  __size_to_integer(__int128 __n) { return __n; }
+  inline constexpr unsigned __int128
+  __size_to_integer(unsigned __int128 __n) { return __n; }
+# 986 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  inline constexpr long long
+  __size_to_integer(float __n) { return __n; }
+  inline constexpr long long
+  __size_to_integer(double __n) { return __n; }
+  inline constexpr long long
+  __size_to_integer(long double __n) { return __n; }
+
+  inline constexpr long long
+  __size_to_integer(__float128 __n) { return __n; }
+
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+   
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      for (; __n > 0; --__n, (void) ++__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_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (; __n > 0; --__n, (void) ++__first)
+ *__first = __tmp;
+      return __first;
+    }
+
+  template<typename _Ite, typename _Seq, typename _Cat, typename _Size,
+    typename _Tp>
+    ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
+    __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first,
+        _Size __n, const _Tp& __value,
+        std::input_iterator_tag);
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+   
+    inline _OutputIterator
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
+        std::output_iterator_tag)
+    {
+
+      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");
+
+      return __fill_n_a1(__first, __n, __value);
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+   
+    inline _OutputIterator
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
+        std::input_iterator_tag)
+    {
+
+      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");
+
+      return __fill_n_a1(__first, __n, __value);
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+   
+    inline _OutputIterator
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
+        std::random_access_iterator_tag)
+    {
+
+      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");
+
+      if (__n <= 0)
+ return __first;
+
+      ;
+
+      std::__fill_a(__first, __first + __n, __value);
+      return __first + __n;
+    }
+# 1086 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _OI, typename _Size, typename _Tp>
+   
+    inline _OI
+    fill_n(_OI __first, _Size __n, const _Tp& __value)
+    {
+
+     
+
+      return std::__fill_n_a(__first, std::__size_to_integer(__n), __value,
+          std::__iterator_category(__first));
+    }
+
+  template<bool _BoolType>
+    struct __equal
+    {
+      template<typename _II1, typename _II2>
+
+ static bool
+ equal(_II1 __first1, _II1 __last1, _II2 __first2)
+ {
+   for (; __first1 != __last1; ++__first1, (void) ++__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 !std::__memcmp(__first1, __first2, __len);
+   return true;
+ }
+    };
+
+  template<typename _Tp, typename _Ref, typename _Ptr, typename _II>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value, bool>::__type
+    __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+   std::_Deque_iterator<_Tp, _Ref, _Ptr>,
+   _II);
+
+  template<typename _Tp1, typename _Ref1, typename _Ptr1,
+    typename _Tp2, typename _Ref2, typename _Ptr2>
+    bool
+    __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
+   std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
+   std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);
+
+  template<typename _II, typename _Tp, typename _Ref, typename _Ptr>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value, bool>::__type
+    __equal_aux1(_II, _II,
+  std::_Deque_iterator<_Tp, _Ref, _Ptr>);
+
+  template<typename _II1, typename _II2>
+   
+    inline bool
+    __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      const bool __simple = ((__is_integer<_ValueType1>::__value
+         || __is_pointer<_ValueType1>::__value)
+        && __memcmpable<_II1, _II2>::__value);
+      return std::__equal<__simple>::equal(__first1, __last1, __first2);
+    }
+
+  template<typename _II1, typename _II2>
+   
+    inline bool
+    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      return std::__equal_aux1(std::__niter_base(__first1),
+          std::__niter_base(__last1),
+          std::__niter_base(__first2));
+    }
+
+  template<typename _II1, typename _Seq1, typename _Cat1, typename _II2>
+    bool
+    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
+  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
+  _II2);
+
+  template<typename _II1, typename _II2, typename _Seq2, typename _Cat2>
+    bool
+    __equal_aux(_II1, _II1,
+  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);
+
+  template<typename _II1, typename _Seq1, typename _Cat1,
+    typename _II2, typename _Seq2, typename _Cat2>
+    bool
+    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
+  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
+  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);
+
+  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, (void)++__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 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+ {
+   using __gnu_cxx::__ops::__iter_less_iter;
+   return std::__lexicographical_compare_impl(__first1, __last1,
+           __first2, __last2,
+           __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 = std::__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;
+    }
+# 1347 "/usr/include/c++/10.2.0/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 (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+
+  inline constexpr unsigned
+  __lg(unsigned __n)
+  { return (int)sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+
+  inline constexpr long
+  __lg(long __n)
+  { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+
+  inline constexpr unsigned long
+  __lg(unsigned long __n)
+  { return (int)sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+
+  inline constexpr long long
+  __lg(long long __n)
+  { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+
+  inline constexpr unsigned long long
+  __lg(unsigned long long __n)
+  { return (int)sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+
+
+# 1403 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+   
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__equal_aux(__first1, __last1, __first2);
+    }
+# 1434 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+   
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+   _IIter2 __first2, _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+      ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ if (!bool(__binary_pred(*__first1, *__first2)))
+   return false;
+      return true;
+    }
+
+
+
+  template<typename _II1, typename _II2>
+   
+    inline bool
+    __equal4(_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, (void)++__first2)
+ if (!(*__first1 == *__first2))
+   return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+
+
+  template<typename _II1, typename _II2, typename _BinaryPredicate>
+   
+    inline bool
+    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2,
+      _BinaryPredicate __binary_pred)
+    {
+      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,
+           __binary_pred);
+ }
+
+      for (; __first1 != __last1 && __first2 != __last2;
+   ++__first1, (void)++__first2)
+ if (!bool(__binary_pred(*__first1, *__first2)))
+   return false;
+      return __first1 == __last1 && __first2 == __last2;
+    }
+# 1524 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+   
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__equal4(__first1, __last1, __first2, __last2);
+    }
+# 1557 "/usr/include/c++/10.2.0/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)
+    {
+
+     
+     
+      ;
+      ;
+
+      return std::__equal4(__first1, __last1, __first2, __last2,
+          __binary_pred);
+    }
+# 1589 "/usr/include/c++/10.2.0/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));
+    }
+# 1626 "/usr/include/c++/10.2.0/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));
+    }
+# 1740 "/usr/include/c++/10.2.0/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+   
+    pair<_InputIterator1, _InputIterator2>
+    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+      while (__first1 != __last1 && __binary_pred(__first1, __first2))
+ {
+   ++__first1;
+   ++__first2;
+ }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+# 1768 "/usr/include/c++/10.2.0/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());
+    }
+# 1802 "/usr/include/c++/10.2.0/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);
+    }
+# 1851 "/usr/include/c++/10.2.0/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());
+    }
+# 1887 "/usr/include/c++/10.2.0/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));
+    }
+
+
+
+
+
+  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>
+   
+    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;
+    }
+
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    bool
+    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2, _BinaryPredicate __pred)
+    {
+
+
+      for (; __first1 != __last1; ++__first1, (void)++__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;
+    }
+# 2044 "/usr/include/c++/10.2.0/bits/stl_algobase.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());
+    }
+
+
+
+}
+# 61 "/usr/include/c++/10.2.0/vector" 2 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/allocator.h" 1 3
+# 46 "/usr/include/c++/10.2.0/bits/allocator.h" 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3
+# 33 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
+# 1 "/usr/include/c++/10.2.0/ext/new_allocator.h" 1 3
+# 33 "/usr/include/c++/10.2.0/ext/new_allocator.h" 3
+# 1 "/usr/include/c++/10.2.0/new" 1 3
+# 38 "/usr/include/c++/10.2.0/new" 3
+       
+# 39 "/usr/include/c++/10.2.0/new" 3
+
+
+# 1 "/usr/include/c++/10.2.0/exception" 1 3
+# 33 "/usr/include/c++/10.2.0/exception" 3
+       
+# 34 "/usr/include/c++/10.2.0/exception" 3
+
+#pragma GCC visibility push(default)
+
+
+# 1 "/usr/include/c++/10.2.0/bits/exception.h" 1 3
+# 34 "/usr/include/c++/10.2.0/bits/exception.h" 3
+       
+# 35 "/usr/include/c++/10.2.0/bits/exception.h" 3
+
+#pragma GCC visibility push(default)
+
+
+
+extern "C++" {
+
+namespace std
+{
+# 60 "/usr/include/c++/10.2.0/bits/exception.h" 3
+  class exception
+  {
+  public:
+    exception() noexcept { }
+    virtual ~exception() noexcept;
+
+    exception(const exception&) = default;
+    exception& operator=(const exception&) = default;
+    exception(exception&&) = default;
+    exception& operator=(exception&&) = default;
+
+
+
+
+    virtual const char*
+    what() const noexcept;
+  };
+
+}
+
+}
+
+#pragma GCC visibility pop
+# 39 "/usr/include/c++/10.2.0/exception" 2 3
+
+extern "C++" {
+
+namespace std
+{
+
+
+
+
+
+
+  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__));
+# 105 "/usr/include/c++/10.2.0/exception" 3
+ 
+  bool uncaught_exception() noexcept __attribute__ ((__pure__));
+
+
+
+
+  int uncaught_exceptions() noexcept __attribute__ ((__pure__));
+
+
+
+}
+
+namespace __gnu_cxx
+{
+
+# 137 "/usr/include/c++/10.2.0/exception" 3
+  void __verbose_terminate_handler();
+
+
+}
+
+}
+
+#pragma GCC visibility pop
+
+
+# 1 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 1 3
+# 34 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 3
+#pragma GCC visibility push(default)
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/cxxabi_init_exception.h" 1 3
+# 34 "/usr/include/c++/10.2.0/bits/cxxabi_init_exception.h" 3
+       
+# 35 "/usr/include/c++/10.2.0/bits/cxxabi_init_exception.h" 3
+
+#pragma GCC visibility push(default)
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 143 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+typedef long int ptrdiff_t;
+# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+typedef long unsigned int size_t;
+# 415 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+typedef struct {
+  long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))));
+  long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))));
+# 426 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 3 4
+} max_align_t;
+
+
+
+
+
+
+  typedef decltype(nullptr) nullptr_t;
+# 39 "/usr/include/c++/10.2.0/bits/cxxabi_init_exception.h" 2 3
+# 50 "/usr/include/c++/10.2.0/bits/cxxabi_init_exception.h" 3
+namespace std
+{
+  class type_info;
+}
+
+namespace __cxxabiv1
+{
+  struct __cxa_refcounted_exception;
+
+  extern "C"
+    {
+
+      void*
+      __cxa_allocate_exception(size_t) noexcept;
+
+      void
+      __cxa_free_exception(void*) noexcept;
+
+
+      __cxa_refcounted_exception*
+      __cxa_init_primary_exception(void *object, std::type_info *tinfo,
+                void ( *dest) (void *)) noexcept;
+
+    }
+}
+
+
+
+#pragma GCC visibility pop
+# 39 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 2 3
+# 1 "/usr/include/c++/10.2.0/typeinfo" 1 3
+# 32 "/usr/include/c++/10.2.0/typeinfo" 3
+       
+# 33 "/usr/include/c++/10.2.0/typeinfo" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/hash_bytes.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/hash_bytes.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/hash_bytes.h" 3
+
+
+
+namespace std
+{
+
+
+
+
+
+
+
+  size_t
+  _Hash_bytes(const void* __ptr, size_t __len, size_t __seed);
+
+
+
+
+
+  size_t
+  _Fnv_hash_bytes(const void* __ptr, size_t __len, size_t __seed);
+
+
+}
+# 37 "/usr/include/c++/10.2.0/typeinfo" 2 3
+
+
+#pragma GCC visibility push(default)
+
+extern "C++" {
+
+namespace __cxxabiv1
+{
+  class __class_type_info;
+}
+# 80 "/usr/include/c++/10.2.0/typeinfo" 3
+namespace std
+{
+
+
+
+
+
+
+  class type_info
+  {
+  public:
+
+
+
+
+    virtual ~type_info();
+
+
+
+    const char* name() const noexcept
+    { return __name[0] == '*' ? __name + 1 : __name; }
+# 115 "/usr/include/c++/10.2.0/typeinfo" 3
+    bool before(const type_info& __arg) const noexcept
+    { return (__name[0] == '*' && __arg.__name[0] == '*')
+ ? __name < __arg.__name
+ : __builtin_strcmp (__name, __arg.__name) < 0; }
+
+    bool operator==(const type_info& __arg) const noexcept
+    {
+      return ((__name == __arg.__name)
+       || (__name[0] != '*' &&
+    __builtin_strcmp (__name, __arg.__name) == 0));
+    }
+# 138 "/usr/include/c++/10.2.0/typeinfo" 3
+    bool operator!=(const type_info& __arg) const noexcept
+    { return !operator==(__arg); }
+
+
+
+    size_t hash_code() const noexcept
+    {
+
+      return _Hash_bytes(name(), __builtin_strlen(name()),
+    static_cast<size_t>(0xc70f6907UL));
+
+
+
+    }
+
+
+
+    virtual bool __is_pointer_p() const;
+
+
+    virtual bool __is_function_p() const;
+
+
+
+
+
+
+
+    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
+       unsigned __outer) const;
+
+
+    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
+        void **__obj_ptr) const;
+
+  protected:
+    const char *__name;
+
+    explicit type_info(const char *__n): __name(__n) { }
+
+  private:
+
+    type_info& operator=(const type_info&);
+    type_info(const type_info&);
+  };
+
+
+
+
+
+
+
+  class bad_cast : public exception
+  {
+  public:
+    bad_cast() noexcept { }
+
+
+
+    virtual ~bad_cast() noexcept;
+
+
+    virtual const char* what() const noexcept;
+  };
+
+
+
+
+
+  class bad_typeid : public exception
+  {
+  public:
+    bad_typeid () noexcept { }
+
+
+
+    virtual ~bad_typeid() noexcept;
+
+
+    virtual const char* what() const noexcept;
+  };
+}
+
+}
+
+#pragma GCC visibility pop
+# 40 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 2 3
+# 1 "/usr/include/c++/10.2.0/new" 1 3
+# 41 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 2 3
+
+extern "C++" {
+
+namespace std
+{
+  class type_info;
+
+
+
+
+
+
+  namespace __exception_ptr
+  {
+    class exception_ptr;
+  }
+
+  using __exception_ptr::exception_ptr;
+
+
+
+
+
+  exception_ptr current_exception() noexcept;
+
+  template<typename _Ex>
+  exception_ptr make_exception_ptr(_Ex) noexcept;
+
+
+  void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));
+
+  namespace __exception_ptr
+  {
+    using std::rethrow_exception;
+
+
+
+
+
+    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);
+      template<typename _Ex>
+      friend exception_ptr std::make_exception_ptr(_Ex) noexcept;
+
+    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; }
+# 118 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 3
+      exception_ptr&
+      operator=(const exception_ptr&) noexcept;
+
+
+      exception_ptr&
+      operator=(exception_ptr&& __o) noexcept
+      {
+        exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
+        return *this;
+      }
+
+
+      ~exception_ptr() noexcept;
+
+      void
+      swap(exception_ptr&) noexcept;
+# 145 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 3
+      explicit operator bool() const
+      { return _M_exception_object; }
+
+
+      friend bool
+      operator==(const exception_ptr&, const exception_ptr&)
+ noexcept __attribute__ ((__pure__));
+
+      const class 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>
+      inline void
+      __dest_thunk(void* __x)
+      { static_cast<_Ex*>(__x)->~_Ex(); }
+
+
+  }
+
+
+  template<typename _Ex>
+    exception_ptr
+    make_exception_ptr(_Ex __ex) noexcept
+    {
+
+      void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
+      (void) __cxxabiv1::__cxa_init_primary_exception(
+   __e, const_cast<std::type_info*>(&typeid(__ex)),
+   __exception_ptr::__dest_thunk<_Ex>);
+      try
+ {
+          ::new (__e) _Ex(__ex);
+          return exception_ptr(__e);
+ }
+      catch(...)
+ {
+   __cxxabiv1::__cxa_free_exception(__e);
+   return current_exception();
+ }
+# 215 "/usr/include/c++/10.2.0/bits/exception_ptr.h" 3
+    }
+
+
+}
+
+}
+
+#pragma GCC visibility pop
+# 148 "/usr/include/c++/10.2.0/exception" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/nested_exception.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/nested_exception.h" 3
+#pragma GCC visibility push(default)
+# 42 "/usr/include/c++/10.2.0/bits/nested_exception.h" 3
+extern "C++" {
+
+namespace std
+{
+
+
+
+
+
+
+  class nested_exception
+  {
+    exception_ptr _M_ptr;
+
+  public:
+    nested_exception() noexcept : _M_ptr(current_exception()) { }
+
+    nested_exception(const nested_exception&) 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>
+    [[noreturn]]
+    inline void
+    __throw_with_nested_impl(_Tp&& __t, true_type)
+    {
+      using _Up = typename remove_reference<_Tp>::type;
+      throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
+    }
+
+  template<typename _Tp>
+    [[noreturn]]
+    inline void
+    __throw_with_nested_impl(_Tp&& __t, false_type)
+    { throw std::forward<_Tp>(__t); }
+
+
+
+
+
+  template<typename _Tp>
+    [[noreturn]]
+    inline void
+    throw_with_nested(_Tp&& __t)
+    {
+      using _Up = typename decay<_Tp>::type;
+      using _CopyConstructible
+ = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
+      static_assert(_CopyConstructible::value,
+   "throw_with_nested argument must be CopyConstructible");
+      using __nest = __and_<is_class<_Up>, __bool_constant<!__is_final(_Up)>,
+       __not_<is_base_of<nested_exception, _Up>>>;
+      std::__throw_with_nested_impl(std::forward<_Tp>(__t), __nest{});
+    }
+
+
+
+
+  template<typename _Tp>
+    using __rethrow_if_nested_cond = typename enable_if<
+      __and_<is_polymorphic<_Tp>,
+      __or_<__not_<is_base_of<nested_exception, _Tp>>,
+     is_convertible<_Tp*, nested_exception*>>>::value
+    >::type;
+
+
+  template<typename _Ex>
+    inline __rethrow_if_nested_cond<_Ex>
+    __rethrow_if_nested_impl(const _Ex* __ptr)
+    {
+      if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
+ __ne_ptr->rethrow_nested();
+    }
+
+
+  inline void
+  __rethrow_if_nested_impl(const void*)
+  { }
+
+
+
+
+  template<typename _Ex>
+    inline void
+    rethrow_if_nested(const _Ex& __ex)
+    { std::__rethrow_if_nested_impl(std::__addressof(__ex)); }
+
+
+}
+
+}
+
+
+
+#pragma GCC visibility pop
+# 149 "/usr/include/c++/10.2.0/exception" 2 3
+# 42 "/usr/include/c++/10.2.0/new" 2 3
+
+#pragma GCC visibility push(default)
+
+extern "C++" {
+
+namespace std
+{
+
+
+
+
+
+
+  class bad_alloc : public exception
+  {
+  public:
+    bad_alloc() throw() { }
+
+
+    bad_alloc(const bad_alloc&) = default;
+    bad_alloc& operator=(const bad_alloc&) = default;
+
+
+
+
+    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
+  {
+
+    explicit nothrow_t() = default;
+
+  };
+
+  extern const nothrow_t nothrow;
+
+
+
+  typedef void (*new_handler)();
+
+
+
+  new_handler set_new_handler(new_handler) throw();
+
+
+
+  new_handler get_new_handler() noexcept;
+
+}
+# 126 "/usr/include/c++/10.2.0/new" 3
+ void* operator new(std::size_t)
+  __attribute__((__externally_visible__));
+ void* operator new[](std::size_t)
+  __attribute__((__externally_visible__));
+void operator delete(void*) noexcept
+  __attribute__((__externally_visible__));
+void operator delete[](void*) noexcept
+  __attribute__((__externally_visible__));
+
+void operator delete(void*, std::size_t) noexcept
+  __attribute__((__externally_visible__));
+void operator delete[](void*, std::size_t) noexcept
+  __attribute__((__externally_visible__));
+
+ void* operator new(std::size_t, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__, __malloc__));
+ void* operator new[](std::size_t, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__, __malloc__));
+void operator delete(void*, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+void operator delete[](void*, const std::nothrow_t&) noexcept
+  __attribute__((__externally_visible__));
+# 174 "/usr/include/c++/10.2.0/new" 3
+ 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 { }
+
+}
+# 230 "/usr/include/c++/10.2.0/new" 3
+#pragma GCC visibility pop
+# 34 "/usr/include/c++/10.2.0/ext/new_allocator.h" 2 3
+
+
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+# 54 "/usr/include/c++/10.2.0/ext/new_allocator.h" 3
+  template<typename _Tp>
+    class new_allocator
+    {
+    public:
+      typedef _Tp value_type;
+      typedef std::size_t size_type;
+      typedef std::ptrdiff_t difference_type;
+
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+
+      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); }
+
+
+
+
+      _Tp*
+      allocate(size_type __n, const void* = static_cast<const void*>(0))
+      {
+ if (__n > this->_M_max_size())
+   std::__throw_bad_alloc();
+# 115 "/usr/include/c++/10.2.0/ext/new_allocator.h" 3
+ return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+      }
+
+
+      void
+      deallocate(_Tp* __p, size_type __t)
+      {
+# 133 "/usr/include/c++/10.2.0/ext/new_allocator.h" 3
+ ::operator delete(__p
+
+     , __t * sizeof(_Tp)
+
+    );
+      }
+
+
+      size_type
+      max_size() const noexcept
+      { return _M_max_size(); }
+
+
+      template<typename _Up, typename... _Args>
+ void
+ construct(_Up* __p, _Args&&... __args)
+ noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
+ { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+ void
+ destroy(_Up* __p)
+ noexcept(std::is_nothrow_destructible<_Up>::value)
+ { __p->~_Up(); }
+# 169 "/usr/include/c++/10.2.0/ext/new_allocator.h" 3
+      template<typename _Up>
+ friend bool
+ operator==(const new_allocator&, const new_allocator<_Up>&)
+ noexcept
+ { return true; }
+
+
+      template<typename _Up>
+ friend bool
+ operator!=(const new_allocator&, const new_allocator<_Up>&)
+ noexcept
+ { return false; }
+
+
+    private:
+      constexpr size_type
+      _M_max_size() const noexcept
+      {
+
+ return std::size_t(0x7fffffffffffffffL) / sizeof(_Tp);
+
+
+
+      }
+    };
+
+
+}
+# 34 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3
+
+
+namespace std
+{
+# 47 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
+  template<typename _Tp>
+    using __allocator_base = __gnu_cxx::new_allocator<_Tp>;
+}
+# 47 "/usr/include/c++/10.2.0/bits/allocator.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/memoryfwd.h" 1 3
+# 46 "/usr/include/c++/10.2.0/bits/memoryfwd.h" 3
+       
+# 47 "/usr/include/c++/10.2.0/bits/memoryfwd.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 63 "/usr/include/c++/10.2.0/bits/memoryfwd.h" 3
+  template<typename>
+    class allocator;
+
+
+  template<>
+    class allocator<void>;
+
+
+
+
+  template<typename, typename>
+    struct uses_allocator;
+
+
+
+
+
+}
+# 48 "/usr/include/c++/10.2.0/bits/allocator.h" 2 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+  template<>
+    class allocator<void>
+    {
+    public:
+      typedef void value_type;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+
+      typedef void* pointer;
+      typedef const void* const_pointer;
+
+      template<typename _Tp1>
+ struct rebind
+ { typedef allocator<_Tp1> other; };
+# 89 "/usr/include/c++/10.2.0/bits/allocator.h" 3
+      typedef true_type propagate_on_container_move_assignment;
+
+      typedef true_type is_always_equal;
+
+      template<typename _Up, typename... _Args>
+ void
+ construct(_Up* __p, _Args&&... __args)
+ noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
+ { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
+
+      template<typename _Up>
+ void
+ destroy(_Up* __p)
+ noexcept(std::is_nothrow_destructible<_Up>::value)
+ { __p->~_Up(); }
+
+    };
+# 115 "/usr/include/c++/10.2.0/bits/allocator.h" 3
+  template<typename _Tp>
+    class allocator : public __allocator_base<_Tp>
+    {
+    public:
+      typedef _Tp value_type;
+      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;
+
+      template<typename _Tp1>
+ struct rebind
+ { typedef allocator<_Tp1> other; };
+
+
+
+
+
+      typedef true_type propagate_on_container_move_assignment;
+
+      typedef true_type is_always_equal;
+
+
+
+
+     
+      allocator() noexcept { }
+
+     
+      allocator(const allocator& __a) noexcept
+      : __allocator_base<_Tp>(__a) { }
+
+
+
+      allocator& operator=(const allocator&) = default;
+
+
+      template<typename _Tp1>
+
+ allocator(const allocator<_Tp1>&) noexcept { }
+
+
+
+
+      ~allocator() noexcept { }
+# 191 "/usr/include/c++/10.2.0/bits/allocator.h" 3
+      friend bool
+      operator==(const allocator&, const allocator&) noexcept
+      { return true; }
+
+
+      friend bool
+      operator!=(const allocator&, const allocator&) noexcept
+      { return false; }
+
+
+
+    };
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator==(const allocator<_T1>&, const allocator<_T2>&)
+    noexcept
+    { return true; }
+
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator!=(const allocator<_T1>&, const allocator<_T2>&)
+    noexcept
+    { return false; }
+
+
+
+
+  template<typename _Tp>
+    class allocator<const _Tp>
+    {
+    public:
+      typedef _Tp value_type;
+      template<typename _Up> allocator(const allocator<_Up>&) { }
+    };
+
+  template<typename _Tp>
+    class allocator<volatile _Tp>
+    {
+    public:
+      typedef _Tp value_type;
+      template<typename _Up> allocator(const allocator<_Up>&) { }
+    };
+
+  template<typename _Tp>
+    class allocator<const volatile _Tp>
+    {
+    public:
+      typedef _Tp value_type;
+      template<typename _Up> allocator(const allocator<_Up>&) { }
+    };
+
+
+
+
+
+
+  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; }
+
+
+
+      }
+    };
+
+
+
+}
+# 65 "/usr/include/c++/10.2.0/vector" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_construct.h" 1 3
+# 73 "/usr/include/c++/10.2.0/bits/stl_construct.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 106 "/usr/include/c++/10.2.0/bits/stl_construct.h" 3
+  template<typename _Tp, typename... _Args>
+    inline void
+    _Construct(_Tp* __p, _Args&&... __args)
+    { ::new(static_cast<void*>(__p)) _Tp(std::forward<_Args>(__args)...); }
+# 121 "/usr/include/c++/10.2.0/bits/stl_construct.h" 3
+  template<typename _T1>
+    inline void
+    _Construct_novalue(_T1* __p)
+    { ::new(static_cast<void*>(__p)) _T1; }
+
+  template<typename _ForwardIterator>
+    void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last);
+
+
+
+
+  template<typename _Tp>
+    constexpr 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;
+
+
+      static_assert(is_destructible<_Value_type>::value,
+      "value type is destructible");
+
+
+
+
+
+      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
+ __destroy(__first, __last);
+    }
+
+  template<bool>
+    struct _Destroy_n_aux
+    {
+      template<typename _ForwardIterator, typename _Size>
+ static _ForwardIterator
+ __destroy_n(_ForwardIterator __first, _Size __count)
+ {
+   for (; __count > 0; (void)++__first, --__count)
+     std::_Destroy(std::__addressof(*__first));
+   return __first;
+ }
+    };
+
+  template<>
+    struct _Destroy_n_aux<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+        static _ForwardIterator
+        __destroy_n(_ForwardIterator __first, _Size __count)
+ {
+   std::advance(__first, __count);
+   return __first;
+ }
+    };
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    _Destroy_n(_ForwardIterator __first, _Size __count)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+                       _Value_type;
+
+
+      static_assert(is_destructible<_Value_type>::value,
+      "value type is destructible");
+
+
+
+
+
+      return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
+ __destroy_n(__first, __count);
+    }
+# 253 "/usr/include/c++/10.2.0/bits/stl_construct.h" 3
+
+}
+# 66 "/usr/include/c++/10.2.0/vector" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 1 3
+# 67 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+# 1 "/usr/include/c++/10.2.0/ext/alloc_traits.h" 1 3
+# 32 "/usr/include/c++/10.2.0/ext/alloc_traits.h" 3
+       
+# 33 "/usr/include/c++/10.2.0/ext/alloc_traits.h" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 1 3
+# 41 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  struct __allocator_traits_base
+  {
+    template<typename _Tp, typename _Up, typename = void>
+      struct __rebind : __replace_first_arg<_Tp, _Up> { };
+
+    template<typename _Tp, typename _Up>
+      struct __rebind<_Tp, _Up,
+        __void_t<typename _Tp::template rebind<_Up>::other>>
+      { using type = typename _Tp::template rebind<_Up>::other; };
+
+  protected:
+    template<typename _Tp>
+      using __pointer = typename _Tp::pointer;
+    template<typename _Tp>
+      using __c_pointer = typename _Tp::const_pointer;
+    template<typename _Tp>
+      using __v_pointer = typename _Tp::void_pointer;
+    template<typename _Tp>
+      using __cv_pointer = typename _Tp::const_void_pointer;
+    template<typename _Tp>
+      using __pocca = typename _Tp::propagate_on_container_copy_assignment;
+    template<typename _Tp>
+      using __pocma = typename _Tp::propagate_on_container_move_assignment;
+    template<typename _Tp>
+      using __pocs = typename _Tp::propagate_on_container_swap;
+    template<typename _Tp>
+      using __equal = typename _Tp::is_always_equal;
+  };
+
+  template<typename _Alloc, typename _Up>
+    using __alloc_rebind
+      = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
+
+
+
+
+
+  template<typename _Alloc>
+    struct allocator_traits : __allocator_traits_base
+    {
+
+      typedef _Alloc allocator_type;
+
+      typedef typename _Alloc::value_type value_type;
+
+
+
+
+
+
+      using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;
+
+    private:
+
+      template<template<typename> class _Func, typename _Tp, typename = void>
+ struct _Ptr
+ {
+   using type = typename pointer_traits<pointer>::template rebind<_Tp>;
+ };
+
+      template<template<typename> class _Func, typename _Tp>
+ struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
+ {
+   using type = _Func<_Alloc>;
+ };
+
+
+      template<typename _A2, typename _PtrT, typename = void>
+ struct _Diff
+ { using type = typename pointer_traits<_PtrT>::difference_type; };
+
+      template<typename _A2, typename _PtrT>
+ struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
+ { using type = typename _A2::difference_type; };
+
+
+      template<typename _A2, typename _DiffT, typename = void>
+ struct _Size : make_unsigned<_DiffT> { };
+
+      template<typename _A2, typename _DiffT>
+ struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
+ { using type = typename _A2::size_type; };
+
+    public:
+
+
+
+
+
+
+      using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;
+
+
+
+
+
+
+
+      using void_pointer = typename _Ptr<__v_pointer, void>::type;
+
+
+
+
+
+
+
+      using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;
+
+
+
+
+
+
+
+      using difference_type = typename _Diff<_Alloc, pointer>::type;
+
+
+
+
+
+
+
+      using size_type = typename _Size<_Alloc, difference_type>::type;
+
+
+
+
+
+
+
+      using propagate_on_container_copy_assignment
+ = __detected_or_t<false_type, __pocca, _Alloc>;
+
+
+
+
+
+
+
+      using propagate_on_container_move_assignment
+ = __detected_or_t<false_type, __pocma, _Alloc>;
+
+
+
+
+
+
+
+      using propagate_on_container_swap
+ = __detected_or_t<false_type, __pocs, _Alloc>;
+
+
+
+
+
+
+
+      using is_always_equal
+ = __detected_or_t<typename is_empty<_Alloc>::type, __equal, _Alloc>;
+
+      template<typename _Tp>
+ using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
+      template<typename _Tp>
+ using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;
+
+    private:
+      template<typename _Alloc2>
+ static constexpr auto
+ _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
+ -> decltype(__a.allocate(__n, __hint))
+ { return __a.allocate(__n, __hint); }
+
+      template<typename _Alloc2>
+ static constexpr pointer
+ _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
+ { 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 constexpr _Require<__has_construct<_Tp, _Args...>>
+ _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...)))
+ { __a.construct(__p, std::forward<_Args>(__args)...); }
+
+      template<typename _Tp, typename... _Args>
+ static constexpr
+ _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
+          is_constructible<_Tp, _Args...>>>
+ _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
+ noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value)
+ {
+
+   ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
+
+
+
+ }
+
+      template<typename _Alloc2, typename _Tp>
+ static constexpr auto
+ _S_destroy(_Alloc2& __a, _Tp* __p, int)
+ noexcept(noexcept(__a.destroy(__p)))
+ -> decltype(__a.destroy(__p))
+ { __a.destroy(__p); }
+
+      template<typename _Alloc2, typename _Tp>
+ static constexpr void
+ _S_destroy(_Alloc2&, _Tp* __p, ...)
+ noexcept(std::is_nothrow_destructible<_Tp>::value)
+ { std::_Destroy(__p); }
+
+      template<typename _Alloc2>
+ static constexpr auto
+ _S_max_size(_Alloc2& __a, int)
+ -> decltype(__a.max_size())
+ { return __a.max_size(); }
+
+      template<typename _Alloc2>
+ static constexpr size_type
+ _S_max_size(_Alloc2&, ...)
+ {
+
+
+   return __gnu_cxx::__numeric_traits<size_type>::__max
+     / sizeof(value_type);
+ }
+
+      template<typename _Alloc2>
+ static constexpr auto
+ _S_select(_Alloc2& __a, int)
+ -> decltype(__a.select_on_container_copy_construction())
+ { return __a.select_on_container_copy_construction(); }
+
+      template<typename _Alloc2>
+ static constexpr _Alloc2
+ _S_select(_Alloc2& __a, ...)
+ { return __a; }
+
+    public:
+# 312 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static pointer
+      allocate(_Alloc& __a, size_type __n)
+      { return __a.allocate(__n); }
+# 327 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static pointer
+      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
+      { return _S_allocate(__a, __n, __hint, 0); }
+# 339 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static void
+      deallocate(_Alloc& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+# 354 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      template<typename _Tp, typename... _Args>
+ static auto
+ construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
+ noexcept(noexcept(_S_construct(__a, __p,
+           std::forward<_Args>(__args)...)))
+ -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
+ { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
+# 370 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      template<typename _Tp>
+ static void
+ destroy(_Alloc& __a, _Tp* __p)
+ noexcept(noexcept(_S_destroy(__a, __p, 0)))
+ { _S_destroy(__a, __p, 0); }
+# 384 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static size_type
+      max_size(const _Alloc& __a) noexcept
+      { return _S_max_size(__a, 0); }
+# 396 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static _Alloc
+      select_on_container_copy_construction(const _Alloc& __rhs)
+      { return _S_select(__rhs, 0); }
+    };
+
+
+
+
+
+
+  template<typename _Tp>
+    struct allocator_traits<allocator<_Tp>>
+    {
+
+      using allocator_type = allocator<_Tp>;
+
+
+      using value_type = _Tp;
+
+
+      using pointer = _Tp*;
+
+
+      using const_pointer = const _Tp*;
+
+
+      using void_pointer = void*;
+
+
+      using const_void_pointer = const void*;
+
+
+      using difference_type = std::ptrdiff_t;
+
+
+      using size_type = std::size_t;
+
+
+      using propagate_on_container_copy_assignment = false_type;
+
+
+      using propagate_on_container_move_assignment = true_type;
+
+
+      using propagate_on_container_swap = false_type;
+
+
+      using is_always_equal = true_type;
+
+      template<typename _Up>
+ using rebind_alloc = allocator<_Up>;
+
+      template<typename _Up>
+ using rebind_traits = allocator_traits<allocator<_Up>>;
+# 458 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static pointer
+      allocate(allocator_type& __a, size_type __n)
+      { return __a.allocate(__n); }
+# 472 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static pointer
+      allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
+      {
+
+ return __a.allocate(__n, __hint);
+
+
+
+      }
+# 490 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      static void
+      deallocate(allocator_type& __a, pointer __p, size_type __n)
+      { __a.deallocate(__p, __n); }
+# 505 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      template<typename _Up, typename... _Args>
+ static void
+ construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
+    _Args&&... __args)
+ noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
+ {
+
+   __a.construct(__p, std::forward<_Args>(__args)...);
+
+
+
+ }
+# 525 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+      template<typename _Up>
+ static void
+ destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
+ noexcept(is_nothrow_destructible<_Up>::value)
+ {
+
+   __a.destroy(__p);
+
+
+
+ }
+
+
+
+
+
+
+      static size_type
+      max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
+      {
+
+ return __a.max_size();
+
+
+
+      }
+
+
+
+
+
+
+      static allocator_type
+      select_on_container_copy_construction(const allocator_type& __rhs)
+      { return __rhs; }
+    };
+
+
+  template<typename _Alloc>
+    inline void
+    __do_alloc_on_copy(_Alloc& __one, const _Alloc& __two, true_type)
+    { __one = __two; }
+
+  template<typename _Alloc>
+    inline void
+    __do_alloc_on_copy(_Alloc&, const _Alloc&, false_type)
+    { }
+
+
+  template<typename _Alloc>
+    constexpr 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>
+    constexpr _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>
+    constexpr 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>
+    constexpr 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, typename _Tp,
+    typename _ValueT = __remove_cvref_t<typename _Alloc::value_type>,
+    typename = void>
+    struct __is_alloc_insertable_impl
+    : false_type
+    { };
+
+  template<typename _Alloc, typename _Tp, typename _ValueT>
+    struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT,
+      __void_t<decltype(allocator_traits<_Alloc>::construct(
+     std::declval<_Alloc&>(), std::declval<_ValueT*>(),
+     std::declval<_Tp>()))>>
+    : true_type
+    { };
+
+
+
+
+  template<typename _Alloc>
+    struct __is_copy_insertable
+    : __is_alloc_insertable_impl<_Alloc,
+     typename _Alloc::value_type const&>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_copy_insertable<allocator<_Tp>>
+    : is_copy_constructible<_Tp>
+    { };
+
+
+
+
+  template<typename _Alloc>
+    struct __is_move_insertable
+    : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type
+    { };
+
+
+  template<typename _Tp>
+    struct __is_move_insertable<allocator<_Tp>>
+    : is_move_constructible<_Tp>
+    { };
+
+
+  template<typename _Alloc, typename = void>
+    struct __is_allocator : false_type { };
+
+  template<typename _Alloc>
+    struct __is_allocator<_Alloc,
+      __void_t<typename _Alloc::value_type,
+        decltype(std::declval<_Alloc&>().allocate(size_t{}))>>
+    : true_type { };
+
+  template<typename _Alloc>
+    using _RequireAllocator
+      = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;
+
+  template<typename _Alloc>
+    using _RequireNotAllocator
+      = typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type;
+# 719 "/usr/include/c++/10.2.0/bits/alloc_traits.h" 3
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      _Allocator& __alloc)
+    {
+      for (; __first != __last; ++__first)
+
+
+
+ allocator_traits<_Allocator>::destroy(__alloc,
+           std::__addressof(*__first));
+
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      allocator<_Tp>&)
+    {
+      _Destroy(__first, __last);
+    }
+
+
+}
+# 35 "/usr/include/c++/10.2.0/ext/alloc_traits.h" 2 3
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+template<typename _Alloc, typename = typename _Alloc::value_type>
+  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 constexpr
+      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
+      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
+      noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p),
+           std::forward<_Args>(__args)...)))
+      {
+ _Base_type::construct(__a, std::__to_address(__p),
+         std::forward<_Args>(__args)...);
+      }
+
+
+    template<typename _Ptr>
+      static constexpr
+      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
+      destroy(_Alloc& __a, _Ptr __p)
+      noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p))))
+      { _Base_type::destroy(__a, std::__to_address(__p)); }
+
+    static constexpr _Alloc _S_select_on_copy(const _Alloc& __a)
+    { return _Base_type::select_on_container_copy_construction(__a); }
+
+    static constexpr 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 _Base_type::is_always_equal::value; }
+
+    static constexpr bool _S_nothrow_move()
+    { return _S_propagate_on_move_assign() || _S_always_equal(); }
+
+    template<typename _Tp>
+      struct rebind
+      { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
+# 166 "/usr/include/c++/10.2.0/ext/alloc_traits.h" 3
+  };
+
+
+}
+# 68 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 2 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, (void)++__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); }
+    };
+# 123 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy(_InputIterator __first, _InputIterator __last,
+         _ForwardIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType2;
+
+
+
+
+
+      static_assert(is_constructible<_ValueType2, decltype(*__first)>::value,
+   "result type must be constructible from value type of input range");
+
+      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); }
+    };
+# 198 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
+         const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+
+
+
+      static_assert(is_constructible<_ValueType, const _Tp&>::value,
+   "result type must be constructible from input type");
+
+
+
+      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, (void) ++__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); }
+    };
+# 270 "/usr/include/c++/10.2.0/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;
+
+
+
+
+
+      static_assert(is_constructible<_ValueType, const _Tp&>::value,
+   "result type must be constructible from input type");
+
+
+
+      const bool __assignable = is_copy_assignable<_ValueType>::value;
+
+      return __uninitialized_fill_n<__is_trivial(_ValueType) && __assignable>::
+ __uninit_fill_n(__first, __n, __x);
+    }
+# 300 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  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, (void)++__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, (void) ++__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); }
+# 414 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_copy_move(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_copy(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
+         const _Tp& __x, _InputIterator __first,
+         _InputIterator __last, _Allocator& __alloc)
+    {
+      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
+    typename _Allocator>
+    inline void
+    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
+         _ForwardIterator __first2,
+         _ForwardIterator __last2, const _Tp& __x,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
+           __first2,
+           __alloc);
+      try
+ {
+   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first2, __mid2, __alloc);
+   throw;
+ }
+    }
+# 521 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  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, (void) ++__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, (void) ++__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<bool _TrivialValueType>
+    struct __uninitialized_default_novalue_1
+    {
+      template<typename _ForwardIterator>
+ static void
+ __uninit_default_novalue(_ForwardIterator __first,
+     _ForwardIterator __last)
+ {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct_novalue(std::__addressof(*__cur));
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_default_novalue_1<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __uninit_default_novalue(_ForwardIterator __first,
+     _ForwardIterator __last)
+ {
+ }
+    };
+
+  template<bool _TrivialValueType>
+    struct __uninitialized_default_novalue_n_1
+    {
+      template<typename _ForwardIterator, typename _Size>
+ static _ForwardIterator
+ __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
+ {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, (void) ++__cur)
+  std::_Construct_novalue(std::__addressof(*__cur));
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_default_novalue_n_1<true>
+    {
+      template<typename _ForwardIterator, typename _Size>
+ static _ForwardIterator
+ __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
+ { return std::next(__first, __n); }
+    };
+
+
+
+
+  template<typename _ForwardIterator>
+    inline void
+    __uninitialized_default_novalue(_ForwardIterator __first,
+        _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      std::__uninitialized_default_novalue_1<
+ is_trivially_default_constructible<_ValueType>::value>::
+ __uninit_default_novalue(__first, __last);
+    }
+
+
+
+  template<typename _ForwardIterator, typename _Size>
+    inline _ForwardIterator
+    __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      return __uninitialized_default_novalue_n_1<
+ is_trivially_default_constructible<_ValueType>::value>::
+ __uninit_default_novalue_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, (void) ++__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); }
+
+  template<typename _InputIterator, typename _Size,
+    typename _ForwardIterator>
+    pair<_InputIterator, _ForwardIterator>
+    __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
+      _ForwardIterator __result, input_iterator_tag)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   for (; __n > 0; --__n, (void) ++__first, ++__cur)
+     std::_Construct(std::__addressof(*__cur), *__first);
+   return {__first, __cur};
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur);
+   throw;
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Size,
+    typename _ForwardIterator>
+    inline pair<_RandomAccessIterator, _ForwardIterator>
+    __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n,
+      _ForwardIterator __result,
+      random_access_iterator_tag)
+    {
+      auto __second_res = uninitialized_copy(__first, __first + __n, __result);
+      auto __first_res = std::next(__first, __n);
+      return {__first_res, __second_res};
+    }
+# 852 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy_n(_InputIterator __first, _Size __n,
+    _ForwardIterator __result)
+    { return std::__uninitialized_copy_n(__first, __n, __result,
+      std::__iterator_category(__first)); }
+
+
+  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
+    inline pair<_InputIterator, _ForwardIterator>
+    __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
+         _ForwardIterator __result)
+    {
+      return
+ std::__uninitialized_copy_n_pair(__first, __n, __result,
+      std::__iterator_category(__first));
+    }
+# 966 "/usr/include/c++/10.2.0/bits/stl_uninitialized.h" 3
+  template<typename _Tp, typename _Up, typename _Allocator>
+    inline void
+    __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
+   _Allocator& __alloc)
+    noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
+    __dest, std::move(*__orig)))
+      && noexcept(std::allocator_traits<_Allocator>::destroy(
+       __alloc, std::__addressof(*__orig))))
+    {
+      typedef std::allocator_traits<_Allocator> __traits;
+      __traits::construct(__alloc, __dest, std::move(*__orig));
+      __traits::destroy(__alloc, std::__addressof(*__orig));
+    }
+
+
+
+  template<typename _Tp, typename = void>
+    struct __is_bitwise_relocatable
+    : is_trivial<_Tp> { };
+
+  template <typename _Tp, typename _Up>
+    inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
+    __relocate_a_1(_Tp* __first, _Tp* __last,
+     _Tp* __result, allocator<_Up>&) noexcept
+    {
+      ptrdiff_t __count = __last - __first;
+      if (__count > 0)
+ __builtin_memmove(__result, __first, __count * sizeof(_Tp));
+      return __result + __count;
+    }
+
+  template <typename _InputIterator, typename _ForwardIterator,
+     typename _Allocator>
+    inline _ForwardIterator
+    __relocate_a_1(_InputIterator __first, _InputIterator __last,
+     _ForwardIterator __result, _Allocator& __alloc)
+    noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
+            std::addressof(*__first),
+            __alloc)))
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType2;
+      static_assert(std::is_same<_ValueType, _ValueType2>::value,
+   "relocation is only possible for values of the same type");
+      _ForwardIterator __cur = __result;
+      for (; __first != __last; ++__first, (void)++__cur)
+ std::__relocate_object_a(std::__addressof(*__cur),
+     std::__addressof(*__first), __alloc);
+      return __cur;
+    }
+
+  template <typename _InputIterator, typename _ForwardIterator,
+     typename _Allocator>
+    inline _ForwardIterator
+    __relocate_a(_InputIterator __first, _InputIterator __last,
+   _ForwardIterator __result, _Allocator& __alloc)
+    noexcept(noexcept(__relocate_a_1(std::__niter_base(__first),
+         std::__niter_base(__last),
+         std::__niter_base(__result), __alloc)))
+    {
+      return __relocate_a_1(std::__niter_base(__first),
+       std::__niter_base(__last),
+       std::__niter_base(__result), __alloc);
+    }
+
+
+
+
+
+
+
+}
+# 67 "/usr/include/c++/10.2.0/vector" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_vector.h" 1 3
+# 63 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+# 1 "/usr/include/c++/10.2.0/initializer_list" 1 3
+# 33 "/usr/include/c++/10.2.0/initializer_list" 3
+       
+# 34 "/usr/include/c++/10.2.0/initializer_list" 3
+
+
+
+
+
+#pragma GCC visibility push(default)
+
+
+
+namespace std
+{
+
+  template<class _E>
+    class initializer_list
+    {
+    public:
+      typedef _E value_type;
+      typedef const _E& reference;
+      typedef const _E& const_reference;
+      typedef size_t size_type;
+      typedef const _E* iterator;
+      typedef const _E* const_iterator;
+
+    private:
+      iterator _M_array;
+      size_type _M_len;
+
+
+      constexpr initializer_list(const_iterator __a, size_type __l)
+      : _M_array(__a), _M_len(__l) { }
+
+    public:
+      constexpr initializer_list() noexcept
+      : _M_array(0), _M_len(0) { }
+
+
+      constexpr size_type
+      size() const noexcept { return _M_len; }
+
+
+      constexpr const_iterator
+      begin() const noexcept { return _M_array; }
+
+
+      constexpr const_iterator
+      end() const noexcept { return begin() + size(); }
+    };
+
+
+
+
+
+
+
+  template<class _Tp>
+    constexpr const _Tp*
+    begin(initializer_list<_Tp> __ils) noexcept
+    { return __ils.begin(); }
+
+
+
+
+
+
+
+  template<class _Tp>
+    constexpr const _Tp*
+    end(initializer_list<_Tp> __ils) noexcept
+    { return __ils.end(); }
+}
+
+#pragma GCC visibility pop
+# 64 "/usr/include/c++/10.2.0/bits/stl_vector.h" 2 3
+# 77 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _Tp, typename _Alloc>
+    struct _Vector_base
+    {
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_Tp>::other _Tp_alloc_type;
+      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
+        pointer;
+
+      struct _Vector_impl_data
+      {
+ pointer _M_start;
+ pointer _M_finish;
+ pointer _M_end_of_storage;
+
+ _Vector_impl_data() noexcept
+ : _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ _Vector_impl_data(_Vector_impl_data&& __x) noexcept
+ : _M_start(__x._M_start), _M_finish(__x._M_finish),
+   _M_end_of_storage(__x._M_end_of_storage)
+ { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); }
+
+
+ void
+ _M_copy_data(_Vector_impl_data const& __x) noexcept
+ {
+   _M_start = __x._M_start;
+   _M_finish = __x._M_finish;
+   _M_end_of_storage = __x._M_end_of_storage;
+ }
+
+ void
+ _M_swap_data(_Vector_impl_data& __x) noexcept
+ {
+
+
+   _Vector_impl_data __tmp;
+   __tmp._M_copy_data(*this);
+   _M_copy_data(__x);
+   __x._M_copy_data(__tmp);
+ }
+      };
+
+      struct _Vector_impl
+ : public _Tp_alloc_type, public _Vector_impl_data
+      {
+ _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value)
+
+ : _Tp_alloc_type()
+ { }
+
+ _Vector_impl(_Tp_alloc_type const& __a) noexcept
+ : _Tp_alloc_type(__a)
+ { }
+
+
+
+
+ _Vector_impl(_Vector_impl&& __x) noexcept
+ : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x))
+ { }
+
+ _Vector_impl(_Tp_alloc_type&& __a) noexcept
+ : _Tp_alloc_type(std::move(__a))
+ { }
+
+ _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept
+ : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv))
+ { }
+# 270 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      };
+
+    public:
+      typedef _Alloc allocator_type;
+
+      _Tp_alloc_type&
+      _M_get_Tp_allocator() noexcept
+      { return this->_M_impl; }
+
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const noexcept
+      { return this->_M_impl; }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Tp_allocator()); }
+
+
+      _Vector_base() = default;
+
+
+
+
+      _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(_Vector_base&&) = default;
+
+
+
+      _Vector_base(_Tp_alloc_type&& __a) noexcept
+      : _M_impl(std::move(__a)) { }
+
+      _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(const allocator_type& __a, _Vector_base&& __x)
+      : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl))
+      { }
+
+
+      ~_Vector_base() noexcept
+      {
+ _M_deallocate(_M_impl._M_start,
+        _M_impl._M_end_of_storage - _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);
+      }
+
+    protected:
+      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;
+      }
+    };
+# 388 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class vector : protected _Vector_base<_Tp, _Alloc>
+    {
+# 401 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
+   "std::vector must have a non-const, non-volatile 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;
+
+    private:
+
+      static constexpr bool
+      _S_nothrow_relocate(true_type)
+      {
+ return noexcept(std::__relocate_a(std::declval<pointer>(),
+       std::declval<pointer>(),
+       std::declval<pointer>(),
+       std::declval<_Tp_alloc_type&>()));
+      }
+
+      static constexpr bool
+      _S_nothrow_relocate(false_type)
+      { return false; }
+
+      static constexpr bool
+      _S_use_relocate()
+      {
+
+
+
+ return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{});
+      }
+
+      static pointer
+      _S_do_relocate(pointer __first, pointer __last, pointer __result,
+       _Tp_alloc_type& __alloc, true_type) noexcept
+      {
+ return std::__relocate_a(__first, __last, __result, __alloc);
+      }
+
+      static pointer
+      _S_do_relocate(pointer, pointer, pointer __result,
+       _Tp_alloc_type&, false_type) noexcept
+      { return __result; }
+
+      static pointer
+      _S_relocate(pointer __first, pointer __last, pointer __result,
+    _Tp_alloc_type& __alloc) noexcept
+      {
+ using __do_it = __bool_constant<_S_use_relocate()>;
+ return _S_do_relocate(__first, __last, __result, __alloc, __do_it{});
+      }
+
+
+    protected:
+      using _Base::_M_allocate;
+      using _Base::_M_deallocate;
+      using _Base::_M_impl;
+      using _Base::_M_get_Tp_allocator;
+
+    public:
+
+
+
+
+
+
+
+      vector() = default;
+# 496 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      explicit
+      vector(const allocator_type& __a) noexcept
+      : _Base(__a) { }
+# 509 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      explicit
+      vector(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(_S_check_init_len(__n, __a), __a)
+      { _M_default_initialize(__n); }
+# 522 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector(size_type __n, const value_type& __value,
+      const allocator_type& __a = allocator_type())
+      : _Base(_S_check_init_len(__n, __a), __a)
+      { _M_fill_initialize(__n, __value); }
+# 553 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector(const vector& __x)
+      : _Base(__x.size(),
+ _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
+      {
+ this->_M_impl._M_finish =
+   std::__uninitialized_copy_a(__x.begin(), __x.end(),
+          this->_M_impl._M_start,
+          _M_get_Tp_allocator());
+      }
+# 572 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector(vector&&) noexcept = default;
+
+
+      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());
+      }
+
+    private:
+      vector(vector&& __rv, const allocator_type& __m, true_type) noexcept
+      : _Base(__m, std::move(__rv))
+      { }
+
+      vector(vector&& __rv, const allocator_type& __m, false_type)
+      : _Base(__m)
+      {
+ if (__rv.get_allocator() == __m)
+   this->_M_impl._M_swap_data(__rv._M_impl);
+ else if (!__rv.empty())
+   {
+     this->_M_create_storage(__rv.size());
+     this->_M_impl._M_finish =
+       std::__uninitialized_move_a(__rv.begin(), __rv.end(),
+       this->_M_impl._M_start,
+       _M_get_Tp_allocator());
+     __rv.clear();
+   }
+      }
+
+    public:
+
+      vector(vector&& __rv, const allocator_type& __m)
+      noexcept( noexcept(
+ vector(std::declval<vector&&>(), std::declval<const allocator_type&>(),
+        std::declval<typename _Alloc_traits::is_always_equal>())) )
+      : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{})
+      { }
+# 625 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector(initializer_list<value_type> __l,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ _M_range_initialize(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+# 651 "/usr/include/c++/10.2.0/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_range_initialize(__first, __last,
+         std::__iterator_category(__first));
+ }
+# 678 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      ~vector() noexcept
+      {
+ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+        _M_get_Tp_allocator());
+ ;
+      }
+# 694 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector&
+      operator=(const vector& __x);
+# 708 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector&
+      operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+ constexpr bool __move_storage =
+   _Alloc_traits::_S_propagate_on_move_assign()
+   || _Alloc_traits::_S_always_equal();
+ _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
+ return *this;
+      }
+# 729 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      vector&
+      operator=(initializer_list<value_type> __l)
+      {
+ this->_M_assign_aux(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+ return *this;
+      }
+# 748 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 765 "/usr/include/c++/10.2.0/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()); }
+# 793 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      assign(initializer_list<value_type> __l)
+      {
+ this->_M_assign_aux(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+
+
+
+      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 _S_max_size(_M_get_Tp_allocator()); }
+# 936 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      resize(size_type __new_size)
+      {
+ if (__new_size > size())
+   _M_default_append(__new_size - size());
+ else if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+# 956 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      resize(size_type __new_size, const value_type& __x)
+      {
+ if (__new_size > size())
+   _M_fill_insert(end(), __new_size - size(), __x);
+ else if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+      }
+# 988 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      shrink_to_fit()
+      { _M_shrink_to_fit(); }
+
+
+
+
+
+
+      size_type
+      capacity() const noexcept
+      { return size_type(this->_M_impl._M_end_of_storage
+    - this->_M_impl._M_start); }
+
+
+
+
+
+      bool
+      empty() const noexcept
+      { return begin() == end(); }
+# 1027 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      reserve(size_type __n);
+# 1042 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      reference
+      operator[](size_type __n) noexcept
+      {
+ ;
+ return *(this->_M_impl._M_start + __n);
+      }
+# 1060 "/usr/include/c++/10.2.0/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:
+# 1091 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+# 1109 "/usr/include/c++/10.2.0/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);
+      }
+# 1167 "/usr/include/c++/10.2.0/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); }
+# 1186 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      push_back(const value_type& __x)
+      {
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         __x);
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   _M_realloc_insert(end(), __x);
+      }
+
+
+      void
+      push_back(value_type&& __x)
+      { emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+
+
+
+ void
+
+ emplace_back(_Args&&... __args);
+# 1224 "/usr/include/c++/10.2.0/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);
+ ;
+      }
+# 1246 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(const_iterator __position, _Args&&... __args)
+ { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
+# 1262 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+# 1292 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return _M_insert_rval(__position, std::move(__x)); }
+# 1309 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+      insert(const_iterator __position, initializer_list<value_type> __l)
+      {
+ auto __offset = __position - cbegin();
+ _M_range_insert(begin() + __offset, __l.begin(), __l.end(),
+   std::random_access_iterator_tag());
+ return begin() + __offset;
+      }
+# 1334 "/usr/include/c++/10.2.0/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;
+      }
+# 1376 "/usr/include/c++/10.2.0/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;
+ }
+# 1428 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      iterator
+
+      erase(const_iterator __position)
+      { return _M_erase(begin() + (__position - cbegin())); }
+# 1455 "/usr/include/c++/10.2.0/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));
+      }
+# 1479 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      void
+      swap(vector& __x) noexcept
+      {
+
+
+                                                          ;
+
+ 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;
+     }
+ }
+# 1556 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      template<typename _InputIterator>
+ void
+ _M_range_initialize(_InputIterator __first, _InputIterator __last,
+       std::input_iterator_tag)
+ {
+   try {
+     for (; __first != __last; ++__first)
+
+       emplace_back(*__first);
+
+
+
+   } catch(...) {
+     clear();
+     throw;
+   }
+ }
+
+
+      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(_S_check_init_len(__n, _M_get_Tp_allocator()));
+   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());
+      }
+# 1618 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      template<typename _Integer>
+ void
+ _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+ { _M_fill_assign(__n, __val); }
+
+
+      template<typename _InputIterator>
+ void
+ _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type)
+ { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+
+
+      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);
+
+
+
+
+
+
+
+      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)
+ {
+   _M_range_insert(__pos, __first, __last,
+     std::__iterator_category(__first));
+ }
+
+
+      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();
+# 1705 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+      struct _Temporary_value
+      {
+ template<typename... _Args>
+   explicit
+   _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec)
+   {
+     _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
+         std::forward<_Args>(__args)...);
+   }
+
+ ~_Temporary_value()
+ { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }
+
+ value_type&
+ _M_val() { return *_M_ptr(); }
+
+      private:
+ _Tp*
+ _M_ptr() { return reinterpret_cast<_Tp*>(&__buf); }
+
+ vector* _M_this;
+ typename aligned_storage<sizeof(_Tp), alignof(_Tp)>::type __buf;
+      };
+
+
+
+      template<typename _Arg>
+ void
+ _M_insert_aux(iterator __position, _Arg&& __arg);
+
+      template<typename... _Args>
+ void
+ _M_realloc_insert(iterator __position, _Args&&... __args);
+
+
+      iterator
+      _M_insert_rval(const_iterator __position, value_type&& __v);
+
+
+      template<typename... _Args>
+ iterator
+ _M_emplace_aux(const_iterator __position, _Args&&... __args);
+
+
+      iterator
+      _M_emplace_aux(const_iterator __position, value_type&& __v)
+      { return _M_insert_rval(__position, std::move(__v)); }
+
+
+
+      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;
+      }
+
+
+      static size_type
+      _S_check_init_len(size_type __n, const allocator_type& __a)
+      {
+ if (__n > _S_max_size(_Tp_alloc_type(__a)))
+   __throw_length_error(
+       ("cannot create std::vector larger than max_size()"));
+ return __n;
+      }
+
+      static size_type
+      _S_max_size(const _Tp_alloc_type& __a) noexcept
+      {
+
+
+
+ const size_t __diffmax
+   = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
+ const size_t __allocmax = _Alloc_traits::max_size(__a);
+ return (std::min)(__diffmax, __allocmax);
+      }
+
+
+
+
+
+      void
+      _M_erase_at_end(pointer __pos) noexcept
+      {
+ if (size_type __n = this->_M_impl._M_finish - __pos)
+   {
+     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, true_type) noexcept
+      {
+ vector __tmp(get_allocator());
+ this->_M_impl._M_swap_data(__x._M_impl);
+ __tmp._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, false_type)
+      {
+ if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
+   _M_move_assign(std::move(__x), true_type());
+ else
+   {
+
+
+     this->_M_assign_aux(std::make_move_iterator(__x.begin()),
+           std::make_move_iterator(__x.end()),
+    std::random_access_iterator_tag());
+     __x.clear();
+   }
+      }
+
+
+      template<typename _Up>
+ _Up*
+ _M_data_ptr(_Up* __ptr) const noexcept
+ { return __ptr; }
+
+
+      template<typename _Ptr>
+ typename std::pointer_traits<_Ptr>::element_type*
+ _M_data_ptr(_Ptr __ptr) const
+ { return empty() ? nullptr : std::__to_address(__ptr); }
+# 1868 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+    };
+# 1890 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return (__x.size() == __y.size()
+       && std::equal(__x.begin(), __x.end(), __y.begin())); }
+# 1928 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+# 1982 "/usr/include/c++/10.2.0/bits/stl_vector.h" 3
+
+}
+# 68 "/usr/include/c++/10.2.0/vector" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 1 3
+# 61 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+# 1 "/usr/include/c++/10.2.0/bits/functional_hash.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 49 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+  template<typename _Result, typename _Arg>
+    struct __hash_base
+    {
+      typedef _Result result_type ;
+      typedef _Arg argument_type ;
+    };
+
+
+  template<typename _Tp>
+    struct hash;
+
+  template<typename _Tp, typename = void>
+    struct __poison_hash
+    {
+      static constexpr bool __enable_hash_call = false;
+    private:
+
+      __poison_hash(__poison_hash&&);
+      ~__poison_hash();
+    };
+
+  template<typename _Tp>
+    struct __poison_hash<_Tp, __void_t<decltype(hash<_Tp>()(declval<_Tp>()))>>
+    {
+      static constexpr bool __enable_hash_call = true;
+    };
+
+
+  template<typename _Tp, bool = is_enum<_Tp>::value>
+    struct __hash_enum
+    {
+    private:
+
+      __hash_enum(__hash_enum&&);
+      ~__hash_enum();
+    };
+
+
+  template<typename _Tp>
+    struct __hash_enum<_Tp, true> : public __hash_base<size_t, _Tp>
+    {
+      size_t
+      operator()(_Tp __val) const noexcept
+      {
+       using __type = typename underlying_type<_Tp>::type;
+       return hash<__type>{}(static_cast<__type>(__val));
+      }
+    };
+
+
+
+  template<typename _Tp>
+    struct hash : __hash_enum<_Tp>
+    { };
+
+
+  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); }
+    };
+# 124 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+  template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+
+
+
+
+
+  template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };
+
+
+  template<> struct hash<__int128> : public __hash_base<size_t, __int128> { size_t operator()(__int128 __val) const noexcept { return static_cast<size_t>(__val); } };
+  template<> struct hash<__int128 unsigned> : public __hash_base<size_t, __int128 unsigned> { size_t operator()(__int128 unsigned __val) const noexcept { return static_cast<size_t>(__val); } };
+# 192 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+  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;
+    };
+# 278 "/usr/include/c++/10.2.0/bits/functional_hash.h" 3
+  template<typename _Hash>
+    struct __is_fast_hash : public std::true_type
+    { };
+
+  template<>
+    struct __is_fast_hash<hash<long double>> : public std::false_type
+    { };
+
+
+}
+# 62 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 2 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) { }
+
+
+    _Bit_reference(const _Bit_reference&) = default;
+
+
+    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);
+    }
+
+    friend bool
+    operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; }
+# 199 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+    friend bool
+    operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    {
+      return __x._M_p < __y._M_p
+     || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset);
+    }
+
+    friend bool
+    operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return !(__x == __y); }
+
+    friend bool
+    operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return __y < __x; }
+
+    friend bool
+    operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return !(__y < __x); }
+
+    friend bool
+    operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+    { return !(__x < __y); }
+
+
+    friend 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;
+    }
+
+    reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+
+    friend iterator
+    operator+(const iterator& __x, difference_type __n)
+    {
+      iterator __tmp = __x;
+      __tmp += __n;
+      return __tmp;
+    }
+
+    friend iterator
+    operator+(difference_type __n, const iterator& __x)
+    { return __x + __n; }
+
+    friend iterator
+    operator-(const iterator& __x, difference_type __n)
+    {
+      iterator __tmp = __x;
+      __tmp -= __n;
+      return __tmp;
+    }
+  };
+
+  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_reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+
+    friend const_iterator
+    operator+(const const_iterator& __x, difference_type __n)
+    {
+      const_iterator __tmp = __x;
+      __tmp += __n;
+      return __tmp;
+    }
+
+    friend const_iterator
+    operator-(const const_iterator& __x, difference_type __n)
+    {
+      const_iterator __tmp = __x;
+      __tmp -= __n;
+      return __tmp;
+    }
+
+    friend const_iterator
+    operator+(difference_type __n, const const_iterator& __x)
+    { return __x + __n; }
+  };
+
+  inline void
+  __fill_bvector(_Bit_type * __v,
+   unsigned int __first, unsigned int __last, bool __x)
+  {
+    const _Bit_type __fmask = ~0ul << __first;
+    const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
+    const _Bit_type __mask = __fmask & __lmask;
+
+    if (__x)
+      *__v |= __mask;
+    else
+      *__v &= ~__mask;
+  }
+
+  inline void
+  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
+  {
+    if (__first._M_p != __last._M_p)
+      {
+ _Bit_type* __first_p = __first._M_p;
+ if (__first._M_offset != 0)
+   __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);
+
+ __builtin_memset(__first_p, __x ? ~0 : 0,
+    (__last._M_p - __first_p) * sizeof(_Bit_type));
+
+ if (__last._M_offset != 0)
+   __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
+      }
+    else if (__first._M_offset != __last._M_offset)
+      __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __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_data
+      {
+ _Bit_iterator _M_start;
+ _Bit_iterator _M_finish;
+ _Bit_pointer _M_end_of_storage;
+
+ _Bvector_impl_data() noexcept
+ : _M_start(), _M_finish(), _M_end_of_storage()
+ { }
+
+
+ _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
+ : _M_start(__x._M_start), _M_finish(__x._M_finish)
+ , _M_end_of_storage(__x._M_end_of_storage)
+ { __x._M_reset(); }
+
+ void
+ _M_move_data(_Bvector_impl_data&& __x) noexcept
+ {
+   this->_M_start = __x._M_start;
+   this->_M_finish = __x._M_finish;
+   this->_M_end_of_storage = __x._M_end_of_storage;
+   __x._M_reset();
+ }
+
+
+ void
+ _M_reset() noexcept
+ {
+   _M_start = _M_finish = _Bit_iterator();
+   _M_end_of_storage = _Bit_pointer();
+ }
+      };
+
+      struct _Bvector_impl
+ : public _Bit_alloc_type, public _Bvector_impl_data
+ {
+ public:
+   _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value)
+
+   : _Bit_alloc_type()
+   { }
+
+   _Bvector_impl(const _Bit_alloc_type& __a) noexcept
+   : _Bit_alloc_type(__a)
+   { }
+
+
+ _Bvector_impl(_Bvector_impl&&) = default;
+
+
+ _Bit_type*
+ _M_end_addr() const noexcept
+ {
+   if (this->_M_end_of_storage)
+     return std::__addressof(this->_M_end_of_storage[-1]) + 1;
+   return 0;
+ }
+      };
+
+    public:
+      typedef _Alloc allocator_type;
+
+      _Bit_alloc_type&
+      _M_get_Bit_allocator() noexcept
+      { return this->_M_impl; }
+
+      const _Bit_alloc_type&
+      _M_get_Bit_allocator() const noexcept
+      { return this->_M_impl; }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Bit_allocator()); }
+
+
+      _Bvector_base() = default;
+
+
+
+
+      _Bvector_base(const allocator_type& __a)
+      : _M_impl(__a) { }
+
+
+      _Bvector_base(_Bvector_base&&) = default;
+
+
+      ~_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);
+     _M_impl._M_reset();
+   }
+      }
+
+
+      void
+      _M_move_data(_Bvector_base&& __x) noexcept
+      { _M_impl._M_move_data(std::move(__x._M_impl)); }
+
+
+      static size_t
+      _S_nword(size_t __n)
+      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
+    };
+
+
+
+}
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+# 614 "/usr/include/c++/10.2.0/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;
+
+
+      friend struct std::hash<vector>;
+
+
+    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() = default;
+
+
+
+
+      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);
+ _M_initialize_value(__value);
+      }
+
+      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&&) = default;
+
+      vector(vector&& __x, const allocator_type& __a)
+      noexcept(_Bit_alloc_traits::_S_always_equal())
+      : _Base(__a)
+      {
+ if (__x.get_allocator() == __a)
+   this->_M_move_data(std::move(__x));
+ 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()); }
+# 737 "/usr/include/c++/10.2.0/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_move_data(std::move(__x));
+     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_aux(__first, __last, std::__iterator_category(__first)); }
+# 828 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+      void
+      assign(initializer_list<bool> __l)
+      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }
+
+
+      iterator
+      begin() noexcept
+      { return iterator(this->_M_impl._M_start._M_p, 0); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(this->_M_impl._M_start._M_p, 0); }
+
+      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 const_iterator(this->_M_impl._M_start._M_p, 0); }
+
+      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
+      {
+ 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;
+ }
+# 1044 "/usr/include/c++/10.2.0/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)
+      {
+ if (__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);
+   }
+ else
+   {
+     this->_M_impl._M_end_of_storage = _Bit_pointer();
+     this->_M_impl._M_start = iterator(0, 0);
+   }
+ this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
+
+      }
+
+      void
+      _M_initialize_value(bool __x)
+      {
+ if (_Bit_type* __p = this->_M_impl._M_start._M_p)
+   __builtin_memset(__p, __x ? ~0 : 0,
+      (this->_M_impl._M_end_addr() - __p)
+      * sizeof(_Bit_type));
+      }
+
+      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));
+   _M_initialize_value(__x);
+ }
+
+      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);
+ }
+# 1230 "/usr/include/c++/10.2.0/bits/stl_bvector.h" 3
+      void
+      _M_fill_assign(size_t __n, bool __x)
+      {
+ if (__n > size())
+   {
+     _M_initialize_value(__x);
+     insert(end(), __n - size(), __x);
+   }
+ else
+   {
+     _M_erase_at_end(begin() + __n);
+     _M_initialize_value(__x);
+   }
+      }
+
+      template<typename _InputIterator>
+ void
+ _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag)
+ {
+   iterator __cur = begin();
+   for (; __first != __last && __cur != end(); ++__cur, (void)++__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;
+    };
+
+
+}
+# 69 "/usr/include/c++/10.2.0/vector" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/range_access.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/range_access.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/range_access.h" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 3
+
+# 1 "/usr/include/c++/10.2.0/concepts" 1 3
+# 36 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/range_cmp.h" 1 3
+# 38 "/usr/include/c++/10.2.0/bits/iterator_concepts.h" 2 3
+# 38 "/usr/include/c++/10.2.0/bits/range_access.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/int_limits.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/int_limits.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/int_limits.h" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __detail
+{
+
+
+
+
+
+
+  template<typename _Tp, bool = is_signed<_Tp>::value>
+    struct __int_limits
+    {
+      static_assert(is_integral<_Tp>::value, "unsupported specialization");
+      using _Up = typename make_unsigned<_Tp>::type;
+      static constexpr int digits = sizeof(_Tp) * 8 - 1;
+      static constexpr _Tp min() noexcept { return _Tp(_Up(1) << digits); }
+      static constexpr _Tp max() noexcept { return _Tp(_Up(~_Up(0)) >> 1); }
+    };
+
+
+  template<typename _Tp>
+    struct __int_limits<_Tp, false>
+    {
+      static_assert(is_integral<_Tp>::value, "unsupported specialization");
+      static constexpr int digits = sizeof(_Tp) * 8;
+      static constexpr _Tp min() noexcept { return 0; }
+      static constexpr _Tp max() noexcept { return _Tp(-1); }
+    };
+
+  template<> struct __int_limits<bool>;
+}
+
+}
+# 39 "/usr/include/c++/10.2.0/bits/range_access.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    begin(_Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    begin(const _Container& __cont) -> decltype(__cont.begin())
+    { return __cont.begin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    end(_Container& __cont) -> decltype(__cont.end())
+    { return __cont.end(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    end(const _Container& __cont) -> decltype(__cont.end())
+    { return __cont.end(); }
+
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline constexpr _Tp*
+    begin(_Tp (&__arr)[_Nm])
+    { return __arr; }
+
+
+
+
+
+
+  template<typename _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<typename _Container>
+    inline constexpr auto
+    cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
+      -> decltype(std::begin(__cont))
+    { return std::begin(__cont); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline constexpr auto
+    cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
+      -> decltype(std::end(__cont))
+    { return std::end(__cont); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    rbegin(_Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
+    { return __cont.rbegin(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    rend(_Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    rend(const _Container& __cont) -> decltype(__cont.rend())
+    { return __cont.rend(); }
+
+
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline reverse_iterator<_Tp*>
+    rbegin(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr + _Nm); }
+
+
+
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline reverse_iterator<_Tp*>
+    rend(_Tp (&__arr)[_Nm])
+    { return reverse_iterator<_Tp*>(__arr); }
+
+
+
+
+
+
+  template<typename _Tp>
+    inline reverse_iterator<const _Tp*>
+    rbegin(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.end()); }
+
+
+
+
+
+
+  template<typename _Tp>
+    inline reverse_iterator<const _Tp*>
+    rend(initializer_list<_Tp> __il)
+    { return reverse_iterator<const _Tp*>(__il.begin()); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
+    { return std::rbegin(__cont); }
+
+
+
+
+
+
+  template<typename _Container>
+    inline auto
+    crend(const _Container& __cont) -> decltype(std::rend(__cont))
+    { return std::rend(__cont); }
+# 1143 "/usr/include/c++/10.2.0/bits/range_access.h" 3
+
+}
+# 70 "/usr/include/c++/10.2.0/vector" 2 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/vector.tcc" 1 3
+# 59 "/usr/include/c++/10.2.0/bits/vector.tcc" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    reserve(size_type __n)
+    {
+      if (__n > this->max_size())
+ __throw_length_error(("vector::reserve"));
+      if (this->capacity() < __n)
+ {
+   const size_type __old_size = size();
+   pointer __tmp;
+
+   if (_S_use_relocate())
+     {
+       __tmp = this->_M_allocate(__n);
+       _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish,
+     __tmp, _M_get_Tp_allocator());
+     }
+   else
+
+     {
+       __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_realloc_insert(end(), 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)
+ if (__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());
+
+
+     _Temporary_value __x_copy(this, __x);
+     _M_insert_aux(__pos, std::move(__x_copy._M_val()));
+
+
+
+   }
+      else
+
+ _M_realloc_insert(begin() + (__position - cbegin()), __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);
+   const size_type __add = __n - size();
+   ;
+   this->_M_impl._M_finish =
+     std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+       __add, __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, (void)++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   _M_range_insert(end(), __first, __last,
+     std::__iterator_category(__first));
+      }
+
+  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())
+   {
+     _S_check_init_len(__len, _M_get_Tp_allocator());
+     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);
+     const size_type __attribute__((__unused__)) __n = __len - size();
+     ;
+     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>
+    auto
+    vector<_Tp, _Alloc>::
+    _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator
+    {
+      const auto __n = __position - cbegin();
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+ if (__position == cend())
+   {
+     ;
+     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+         std::move(__v));
+     ++this->_M_impl._M_finish;
+     ;
+   }
+ else
+   _M_insert_aux(begin() + __n, std::move(__v));
+      else
+ _M_realloc_insert(begin() + __n, std::move(__v));
+
+      return iterator(this->_M_impl._M_start + __n);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      auto
+      vector<_Tp, _Alloc>::
+      _M_emplace_aux(const_iterator __position, _Args&&... __args)
+      -> iterator
+      {
+ const auto __n = __position - cbegin();
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   if (__position == cend())
+     {
+       ;
+       _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
+           std::forward<_Args>(__args)...);
+       ++this->_M_impl._M_finish;
+       ;
+     }
+   else
+     {
+
+
+
+       _Temporary_value __tmp(this, std::forward<_Args>(__args)...);
+       _M_insert_aux(begin() + __n, std::move(__tmp._M_val()));
+     }
+ else
+   _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...);
+
+ return iterator(this->_M_impl._M_start + __n);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _Arg>
+      void
+      vector<_Tp, _Alloc>::
+      _M_insert_aux(iterator __position, _Arg&& __arg)
+
+
+
+
+
+
+    {
+      ;
+      _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 = std::forward<_Arg>(__arg);
+
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      void
+      vector<_Tp, _Alloc>::
+      _M_realloc_insert(iterator __position, _Args&&... __args)
+
+
+
+
+
+
+    {
+      const size_type __len =
+ _M_check_len(size_type(1), "vector::_M_realloc_insert");
+      pointer __old_start = this->_M_impl._M_start;
+      pointer __old_finish = this->_M_impl._M_finish;
+      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();
+
+
+   if (_S_use_relocate())
+     {
+       __new_finish = _S_relocate(__old_start, __position.base(),
+      __new_start, _M_get_Tp_allocator());
+
+       ++__new_finish;
+
+       __new_finish = _S_relocate(__position.base(), __old_finish,
+      __new_finish, _M_get_Tp_allocator());
+     }
+   else
+
+     {
+       __new_finish
+  = std::__uninitialized_move_if_noexcept_a
+  (__old_start, __position.base(),
+   __new_start, _M_get_Tp_allocator());
+
+       ++__new_finish;
+
+       __new_finish
+  = std::__uninitialized_move_if_noexcept_a
+  (__position.base(), __old_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;
+ }
+
+      if (!_S_use_relocate())
+
+ std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator());
+      ;
+      _M_deallocate(__old_start,
+      this->_M_impl._M_end_of_storage - __old_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)
+     {
+
+
+
+       _Temporary_value __tmp(this, __x);
+       value_type& __x_copy = __tmp._M_val();
+
+       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)
+ {
+   const size_type __size = size();
+   size_type __navail = size_type(this->_M_impl._M_end_of_storage
+      - this->_M_impl._M_finish);
+
+   if (__size > max_size() || __navail > max_size() - __size)
+     __builtin_unreachable();
+
+   if (__navail >= __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");
+       pointer __new_start(this->_M_allocate(__len));
+       if (_S_use_relocate())
+  {
+    try
+      {
+        std::__uninitialized_default_n_a(__new_start + __size,
+         __n, _M_get_Tp_allocator());
+      }
+    catch(...)
+      {
+        _M_deallocate(__new_start, __len);
+        throw;
+      }
+    _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish,
+         __new_start, _M_get_Tp_allocator());
+  }
+       else
+  {
+    pointer __destroy_from = pointer();
+    try
+      {
+        std::__uninitialized_default_n_a(__new_start + __size,
+         __n, _M_get_Tp_allocator());
+        __destroy_from = __new_start + __size;
+        std::__uninitialized_move_if_noexcept_a(
+         this->_M_impl._M_start, this->_M_impl._M_finish,
+         __new_start, _M_get_Tp_allocator());
+      }
+    catch(...)
+      {
+        if (__destroy_from)
+   std::_Destroy(__destroy_from, __destroy_from + __n,
+          _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_start + __size + __n;
+       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)
+      {
+ if (__pos == end())
+   {
+     for (; __first != __last; ++__first)
+       insert(end(), *__first);
+   }
+ else if (__first != __last)
+   {
+     vector __tmp(__first, __last, _M_get_Tp_allocator());
+     insert(__pos,
+     std::make_move_iterator(__tmp.begin()),
+     std::make_move_iterator(__tmp.end()));
+   }
+      }
+
+  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);
+      iterator __finish(_M_copy_aligned(begin(), end(), __start));
+      this->_M_deallocate();
+      this->_M_impl._M_start = __start;
+      this->_M_impl._M_finish = __finish;
+      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);
+   iterator __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;
+   this->_M_impl._M_finish = __finish;
+ }
+    }
+
+  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);
+  iterator __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;
+  this->_M_impl._M_finish = __finish;
+       }
+   }
+      }
+
+  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;
+   iterator __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;
+   this->_M_impl._M_finish = __finish;
+ }
+    }
+
+  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;
+    }
+
+
+}
+# 73 "/usr/include/c++/10.2.0/vector" 2 3
+# 5 "/home/ted/dev/openrct2/src/openrct2/ParkFile.h" 2
+
+
+# 6 "/home/ted/dev/openrct2/src/openrct2/ParkFile.h"
+struct ObjectRepositoryItem;
+
+namespace OpenRCT2
+{
+    struct IStream;
+}
+
+class ParkFileExporter
+{
+public:
+    std::vector<const ObjectRepositoryItem*> ExportObjectsList;
+
+    void Export(std::string_view path);
+    void Export(OpenRCT2::IStream& stream);
+};
+# 11 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/Cheats.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/Cheats.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/common.h" 1
+# 22 "/home/ted/dev/openrct2/src/openrct2/common.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/Diagnostic.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/Diagnostic.h"
+# 1 "/usr/include/c++/10.2.0/cstdint" 1 3
+# 32 "/usr/include/c++/10.2.0/cstdint" 3
+       
+# 33 "/usr/include/c++/10.2.0/cstdint" 3
+# 41 "/usr/include/c++/10.2.0/cstdint" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdint.h" 1 3 4
+# 9 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdint.h" 3 4
+# 1 "/usr/include/stdint.h" 1 3 4
+# 26 "/usr/include/stdint.h" 3 4
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 27 "/usr/include/stdint.h" 2 3 4
+# 1 "/usr/include/bits/types.h" 1 3 4
+# 27 "/usr/include/bits/types.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 28 "/usr/include/bits/types.h" 2 3 4
+# 1 "/usr/include/bits/timesize.h" 1 3 4
+# 29 "/usr/include/bits/types.h" 2 3 4
+
+
+
+# 31 "/usr/include/bits/types.h" 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 __int8_t __int_least8_t;
+typedef __uint8_t __uint_least8_t;
+typedef __int16_t __int_least16_t;
+typedef __uint16_t __uint_least16_t;
+typedef __int32_t __int_least32_t;
+typedef __uint32_t __uint_least32_t;
+typedef __int64_t __int_least64_t;
+typedef __uint64_t __uint_least64_t;
+
+
+
+typedef long int __quad_t;
+typedef unsigned long int __u_quad_t;
+
+
+
+
+
+
+
+typedef long int __intmax_t;
+typedef unsigned long int __uintmax_t;
+# 141 "/usr/include/bits/types.h" 3 4
+# 1 "/usr/include/bits/typesizes.h" 1 3 4
+# 142 "/usr/include/bits/types.h" 2 3 4
+# 1 "/usr/include/bits/time64.h" 1 3 4
+# 143 "/usr/include/bits/types.h" 2 3 4
+
+
+typedef unsigned long int __dev_t;
+typedef unsigned int __uid_t;
+typedef unsigned int __gid_t;
+typedef unsigned long int __ino_t;
+typedef unsigned long int __ino64_t;
+typedef unsigned int __mode_t;
+typedef unsigned long int __nlink_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef int __pid_t;
+typedef struct { int __val[2]; } __fsid_t;
+typedef long int __clock_t;
+typedef unsigned long int __rlim_t;
+typedef unsigned long int __rlim64_t;
+typedef unsigned int __id_t;
+typedef long int __time_t;
+typedef unsigned int __useconds_t;
+typedef long int __suseconds_t;
+typedef long int __suseconds64_t;
+
+typedef int __daddr_t;
+typedef int __key_t;
+
+
+typedef int __clockid_t;
+
+
+typedef void * __timer_t;
+
+
+typedef long int __blksize_t;
+
+
+
+
+typedef long int __blkcnt_t;
+typedef long int __blkcnt64_t;
+
+
+typedef unsigned long int __fsblkcnt_t;
+typedef unsigned long int __fsblkcnt64_t;
+
+
+typedef unsigned long int __fsfilcnt_t;
+typedef unsigned long int __fsfilcnt64_t;
+
+
+typedef long int __fsword_t;
+
+typedef long int __ssize_t;
+
+
+typedef long int __syscall_slong_t;
+
+typedef unsigned long int __syscall_ulong_t;
+
+
+
+typedef __off64_t __loff_t;
+typedef char *__caddr_t;
+
+
+typedef long int __intptr_t;
+
+
+typedef unsigned int __socklen_t;
+
+
+
+
+typedef int __sig_atomic_t;
+# 28 "/usr/include/stdint.h" 2 3 4
+# 1 "/usr/include/bits/wchar.h" 1 3 4
+# 29 "/usr/include/stdint.h" 2 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 30 "/usr/include/stdint.h" 2 3 4
+
+
+
+
+# 1 "/usr/include/bits/stdint-intn.h" 1 3 4
+# 24 "/usr/include/bits/stdint-intn.h" 3 4
+typedef __int8_t int8_t;
+typedef __int16_t int16_t;
+typedef __int32_t int32_t;
+typedef __int64_t int64_t;
+# 35 "/usr/include/stdint.h" 2 3 4
+
+
+# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4
+# 24 "/usr/include/bits/stdint-uintn.h" 3 4
+typedef __uint8_t uint8_t;
+typedef __uint16_t uint16_t;
+typedef __uint32_t uint32_t;
+typedef __uint64_t uint64_t;
+# 38 "/usr/include/stdint.h" 2 3 4
+
+
+
+
+
+typedef __int_least8_t int_least8_t;
+typedef __int_least16_t int_least16_t;
+typedef __int_least32_t int_least32_t;
+typedef __int_least64_t int_least64_t;
+
+
+typedef __uint_least8_t uint_least8_t;
+typedef __uint_least16_t uint_least16_t;
+typedef __uint_least32_t uint_least32_t;
+typedef __uint_least64_t uint_least64_t;
+
+
+
+
+
+typedef signed char int_fast8_t;
+
+typedef long int int_fast16_t;
+typedef long int int_fast32_t;
+typedef long int int_fast64_t;
+# 71 "/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;
+# 87 "/usr/include/stdint.h" 3 4
+typedef long int intptr_t;
+
+
+typedef unsigned long int uintptr_t;
+# 101 "/usr/include/stdint.h" 3 4
+typedef __intmax_t intmax_t;
+typedef __uintmax_t uintmax_t;
+# 10 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdint.h" 2 3 4
+# 42 "/usr/include/c++/10.2.0/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;
+
+
+
+
+
+}
+# 14 "/home/ted/dev/openrct2/src/openrct2/Diagnostic.h" 2
+
+
+# 15 "/home/ted/dev/openrct2/src/openrct2/Diagnostic.h"
+enum class DiagnosticLevel
+{
+    Fatal,
+    Error,
+    Warning,
+    Verbose,
+    Information,
+    Count
+};
+# 72 "/home/ted/dev/openrct2/src/openrct2/Diagnostic.h"
+extern bool _log_levels[static_cast<uint8_t>(DiagnosticLevel::Count)];
+
+void diagnostic_log(DiagnosticLevel diagnosticLevel, const char* format, ...);
+void diagnostic_log_with_location(
+    DiagnosticLevel diagnosticLevel, const char* file, const char* function, int32_t line, const char* format, ...);
+# 23 "/home/ted/dev/openrct2/src/openrct2/common.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/Numerics.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/Numerics.hpp"
+       
+
+# 1 "/usr/include/c++/10.2.0/cstddef" 1 3
+# 42 "/usr/include/c++/10.2.0/cstddef" 3
+       
+# 43 "/usr/include/c++/10.2.0/cstddef" 3
+
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 51 "/usr/include/c++/10.2.0/cstddef" 2 3
+
+
+# 52 "/usr/include/c++/10.2.0/cstddef" 3
+extern "C++"
+{
+
+namespace std
+{
+
+  using ::max_align_t;
+}
+# 179 "/usr/include/c++/10.2.0/cstddef" 3
+}
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/Numerics.hpp" 2
+
+# 1 "/usr/include/c++/10.2.0/limits" 1 3
+# 40 "/usr/include/c++/10.2.0/limits" 3
+       
+# 41 "/usr/include/c++/10.2.0/limits" 3
+# 158 "/usr/include/c++/10.2.0/limits" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  enum float_round_style
+  {
+    round_indeterminate = -1,
+    round_toward_zero = 0,
+    round_to_nearest = 1,
+    round_toward_infinity = 2,
+    round_toward_neg_infinity = 3
+  };
+
+
+
+
+
+
+
+  enum float_denorm_style
+  {
+
+    denorm_indeterminate = -1,
+
+    denorm_absent = 0,
+
+    denorm_present = 1
+  };
+# 202 "/usr/include/c++/10.2.0/limits" 3
+  struct __numeric_limits_base
+  {
+
+
+    static constexpr bool is_specialized = false;
+
+
+
+
+    static constexpr int digits = 0;
+
+
+    static constexpr int digits10 = 0;
+
+
+
+
+    static constexpr int max_digits10 = 0;
+
+
+
+    static constexpr bool is_signed = false;
+
+
+    static constexpr bool is_integer = false;
+
+
+
+
+    static constexpr bool is_exact = false;
+
+
+
+    static constexpr int radix = 0;
+
+
+
+    static constexpr int min_exponent = 0;
+
+
+
+    static constexpr int min_exponent10 = 0;
+
+
+
+
+    static constexpr int max_exponent = 0;
+
+
+
+    static constexpr int max_exponent10 = 0;
+
+
+    static constexpr bool has_infinity = false;
+
+
+
+    static constexpr bool has_quiet_NaN = false;
+
+
+
+    static constexpr bool has_signaling_NaN = false;
+
+
+    static constexpr float_denorm_style has_denorm = denorm_absent;
+
+
+
+    static constexpr bool has_denorm_loss = false;
+
+
+
+    static constexpr bool is_iec559 = false;
+
+
+
+
+    static constexpr bool is_bounded = false;
+# 288 "/usr/include/c++/10.2.0/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;
+  };
+# 311 "/usr/include/c++/10.2.0/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> { };
+# 383 "/usr/include/c++/10.2.0/limits" 3
+  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;
+    };
+# 796 "/usr/include/c++/10.2.0/limits" 3
+  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;
+    };
+# 1636 "/usr/include/c++/10.2.0/limits" 3
+  template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; 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 __int128 epsilon() noexcept { return 0; } static constexpr __int128 round_error() noexcept { return 0; } static constexpr __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 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 __int128 infinity() noexcept { return static_cast<__int128>(0); } static constexpr __int128 quiet_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 signaling_NaN() noexcept { return static_cast<__int128>(0); } static constexpr __int128 denorm_min() noexcept { return static_cast<__int128>(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 __int128> { static constexpr bool is_specialized = true; static constexpr unsigned __int128 min() noexcept { return 0; } static constexpr unsigned __int128 max() noexcept { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((128 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); } static constexpr unsigned __int128 lowest() noexcept { return min(); } static constexpr int max_digits10 = 0; static constexpr int digits = 128; static constexpr int digits10 = 128 * 643L / 2136; 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 __int128 epsilon() noexcept { return 0; } static constexpr unsigned __int128 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 __int128 infinity() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast<unsigned __int128>(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; };
+# 1659 "/usr/include/c++/10.2.0/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.18973149535723176502126385303097021e+4932L; }
+
+
+      static constexpr long double
+      lowest() noexcept { return -1.18973149535723176502126385303097021e+4932L; }
+
+
+      static constexpr int digits = 64;
+      static constexpr int digits10 = 18;
+
+      static constexpr int max_digits10
+  = (2 + (64) * 643L / 2136);
+
+      static constexpr bool is_signed = true;
+      static constexpr bool is_integer = false;
+      static constexpr bool is_exact = false;
+      static constexpr int radix = 2;
+
+      static constexpr long double
+      epsilon() noexcept { return 1.08420217248550443400745280086994171e-19L; }
+
+      static constexpr long double
+      round_error() noexcept { return 0.5L; }
+
+      static constexpr int min_exponent = (-16381);
+      static constexpr int min_exponent10 = (-4931);
+      static constexpr int max_exponent = 16384;
+      static constexpr int max_exponent10 = 4932;
+
+      static constexpr bool has_infinity = 1;
+      static constexpr bool has_quiet_NaN = 1;
+      static constexpr bool has_signaling_NaN = has_quiet_NaN;
+      static constexpr float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static constexpr bool has_denorm_loss
+ = false;
+
+      static constexpr long double
+      infinity() noexcept { return __builtin_huge_vall(); }
+
+      static constexpr long double
+      quiet_NaN() noexcept { return __builtin_nanl(""); }
+
+      static constexpr long double
+      signaling_NaN() noexcept { return __builtin_nansl(""); }
+
+      static constexpr long double
+      denorm_min() noexcept { return 3.64519953188247460252840593361941982e-4951L; }
+
+      static constexpr bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static constexpr bool is_bounded = true;
+      static constexpr bool is_modulo = false;
+
+      static constexpr bool traps = false;
+      static constexpr bool tinyness_before =
+      false;
+      static constexpr float_round_style round_style =
+            round_to_nearest;
+    };
+
+
+
+
+
+
+}
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/Numerics.hpp" 2
+
+
+
+# 17 "/home/ted/dev/openrct2/src/openrct2/core/Numerics.hpp"
+namespace Numerics
+{
+
+
+
+
+
+
+
+    template<typename _UIntType> static constexpr _UIntType rol(_UIntType x, size_t shift)
+    {
+        static_assert(std::is_unsigned<_UIntType>::value, "result_type must be an unsigned integral type");
+        using limits = typename std::numeric_limits<_UIntType>;
+        return ((static_cast<_UIntType>(x) << shift) | (static_cast<_UIntType>(x) >> (limits::digits - shift)));
+    }
+
+
+
+
+
+
+
+    [[maybe_unused]] static constexpr uint8_t rol4(uint8_t x, size_t shift)
+    {
+        x &= 0x0F;
+        return (x << shift | x >> (4 - shift)) & 0x0F;
+    }
+# 52 "/home/ted/dev/openrct2/src/openrct2/core/Numerics.hpp"
+    template<typename _UIntType> static constexpr _UIntType ror(_UIntType x, size_t shift)
+    {
+        static_assert(std::is_unsigned<_UIntType>::value, "result_type must be an unsigned integral type");
+        using limits = std::numeric_limits<_UIntType>;
+        return ((static_cast<_UIntType>(x) >> shift) | (static_cast<_UIntType>(x) << (limits::digits - shift)));
+    }
+
+
+
+
+
+
+
+    [[maybe_unused]] static constexpr uint8_t ror4(uint8_t x, size_t shift)
+    {
+        x &= 0x0F;
+        return (x >> shift | x << (4 - shift)) & 0x0F;
+    }
+
+}
+# 24 "/home/ted/dev/openrct2/src/openrct2/common.h" 2
+
+# 1 "/usr/include/c++/10.2.0/cassert" 1 3
+# 41 "/usr/include/c++/10.2.0/cassert" 3
+       
+# 42 "/usr/include/c++/10.2.0/cassert" 3
+
+
+# 1 "/usr/include/assert.h" 1 3 4
+# 64 "/usr/include/assert.h" 3 4
+
+# 64 "/usr/include/assert.h" 3 4
+extern "C" {
+
+
+extern void __assert_fail (const char *__assertion, const char *__file,
+      unsigned int __line, const char *__function)
+     noexcept (true) __attribute__ ((__noreturn__));
+
+
+extern void __assert_perror_fail (int __errnum, const char *__file,
+      unsigned int __line, const char *__function)
+     noexcept (true) __attribute__ ((__noreturn__));
+
+
+
+
+extern void __assert (const char *__assertion, const char *__file, int __line)
+     noexcept (true) __attribute__ ((__noreturn__));
+
+
+}
+# 45 "/usr/include/c++/10.2.0/cassert" 2 3
+# 26 "/home/ted/dev/openrct2/src/openrct2/common.h" 2
+
+
+# 1 "/usr/include/c++/10.2.0/stdexcept" 1 3
+# 36 "/usr/include/c++/10.2.0/stdexcept" 3
+       
+# 37 "/usr/include/c++/10.2.0/stdexcept" 3
+
+
+# 1 "/usr/include/c++/10.2.0/string" 1 3
+# 36 "/usr/include/c++/10.2.0/string" 3
+       
+# 37 "/usr/include/c++/10.2.0/string" 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stringfwd.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/stringfwd.h" 3
+       
+# 38 "/usr/include/c++/10.2.0/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;
+# 93 "/usr/include/c++/10.2.0/bits/stringfwd.h" 3
+  typedef basic_string<char16_t> u16string;
+
+
+  typedef basic_string<char32_t> u32string;
+
+
+
+
+
+}
+# 40 "/usr/include/c++/10.2.0/string" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/char_traits.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/postypes.h" 1 3
+# 38 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+       
+# 39 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+
+# 1 "/usr/include/c++/10.2.0/cwchar" 1 3
+# 39 "/usr/include/c++/10.2.0/cwchar" 3
+       
+# 40 "/usr/include/c++/10.2.0/cwchar" 3
+
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 27 "/usr/include/wchar.h" 3 4
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 28 "/usr/include/wchar.h" 2 3 4
+
+
+# 1 "/usr/include/bits/floatn.h" 1 3 4
+# 74 "/usr/include/bits/floatn.h" 3 4
+typedef _Complex float __cfloat128 __attribute__ ((__mode__ (__TC__)));
+# 86 "/usr/include/bits/floatn.h" 3 4
+typedef __float128 _Float128;
+# 119 "/usr/include/bits/floatn.h" 3 4
+# 1 "/usr/include/bits/floatn-common.h" 1 3 4
+# 24 "/usr/include/bits/floatn-common.h" 3 4
+# 1 "/usr/include/bits/long-double.h" 1 3 4
+# 25 "/usr/include/bits/floatn-common.h" 2 3 4
+# 214 "/usr/include/bits/floatn-common.h" 3 4
+typedef float _Float32;
+# 251 "/usr/include/bits/floatn-common.h" 3 4
+typedef double _Float64;
+# 268 "/usr/include/bits/floatn-common.h" 3 4
+typedef double _Float32x;
+# 285 "/usr/include/bits/floatn-common.h" 3 4
+typedef long double _Float64x;
+# 120 "/usr/include/bits/floatn.h" 2 3 4
+# 31 "/usr/include/wchar.h" 2 3 4
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 36 "/usr/include/wchar.h" 2 3 4
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 1 3 4
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 3 4
+typedef __builtin_va_list __gnuc_va_list;
+# 39 "/usr/include/wchar.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/wint_t.h" 1 3 4
+# 20 "/usr/include/bits/types/wint_t.h" 3 4
+typedef unsigned int wint_t;
+# 42 "/usr/include/wchar.h" 2 3 4
+# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4
+
+
+
+# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4
+# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4
+typedef struct
+{
+  int __count;
+  union
+  {
+    unsigned int __wch;
+    char __wchb[4];
+  } __value;
+} __mbstate_t;
+# 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4
+
+typedef __mbstate_t mbstate_t;
+# 43 "/usr/include/wchar.h" 2 3 4
+# 1 "/usr/include/bits/types/__FILE.h" 1 3 4
+
+
+
+struct _IO_FILE;
+typedef struct _IO_FILE __FILE;
+# 44 "/usr/include/wchar.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/FILE.h" 1 3 4
+
+
+
+struct _IO_FILE;
+
+
+typedef struct _IO_FILE FILE;
+# 47 "/usr/include/wchar.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/locale_t.h" 1 3 4
+# 22 "/usr/include/bits/types/locale_t.h" 3 4
+# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4
+# 28 "/usr/include/bits/types/__locale_t.h" 3 4
+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];
+};
+
+typedef struct __locale_struct *__locale_t;
+# 23 "/usr/include/bits/types/locale_t.h" 2 3 4
+
+typedef __locale_t locale_t;
+# 50 "/usr/include/wchar.h" 2 3 4
+# 79 "/usr/include/wchar.h" 3 4
+extern "C" {
+
+
+
+struct tm;
+
+
+
+extern wchar_t *wcscpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern wchar_t *wcscat (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+extern wchar_t *wcsncat (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true);
+
+
+extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
+   size_t __n) noexcept (true);
+
+
+
+extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+    locale_t __loc) noexcept (true);
+
+extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
+     size_t __n, locale_t __loc) noexcept (true);
+
+
+
+
+extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true);
+
+
+
+extern size_t wcsxfrm (wchar_t *__restrict __s1,
+         const wchar_t *__restrict __s2, size_t __n) noexcept (true);
+
+
+
+
+
+
+
+extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
+        locale_t __loc) noexcept (true);
+
+
+
+
+extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
+    size_t __n, locale_t __loc) noexcept (true);
+
+
+extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) __attribute__ ((__malloc__));
+
+
+
+
+extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
+     noexcept (true) __asm ("wcschr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
+     noexcept (true) __asm ("wcschr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
+     noexcept (true) __asm ("wcsrchr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
+     noexcept (true) __asm ("wcsrchr") __attribute__ ((__pure__));
+# 181 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
+     noexcept (true) __attribute__ ((__pure__));
+
+
+
+
+extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
+     noexcept (true) __attribute__ ((__pure__));
+
+
+extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
+     noexcept (true) __attribute__ ((__pure__));
+
+
+extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, const wchar_t *__accept)
+     noexcept (true) __asm ("wcspbrk") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcspbrk (const wchar_t *__wcs,
+         const wchar_t *__accept)
+     noexcept (true) __asm ("wcspbrk") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wcsstr (wchar_t *__haystack, const wchar_t *__needle)
+     noexcept (true) __asm ("wcsstr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcsstr (const wchar_t *__haystack,
+        const wchar_t *__needle)
+     noexcept (true) __asm ("wcsstr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern wchar_t *wcstok (wchar_t *__restrict __s,
+   const wchar_t *__restrict __delim,
+   wchar_t **__restrict __ptr) noexcept (true);
+
+
+extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__));
+
+
+
+
+extern "C++" wchar_t *wcswcs (wchar_t *__haystack, const wchar_t *__needle)
+     noexcept (true) __asm ("wcswcs") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wcswcs (const wchar_t *__haystack,
+        const wchar_t *__needle)
+     noexcept (true) __asm ("wcswcs") __attribute__ ((__pure__));
+# 240 "/usr/include/wchar.h" 3 4
+extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
+     noexcept (true) __attribute__ ((__pure__));
+
+
+
+
+
+extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
+     noexcept (true) __asm ("wmemchr") __attribute__ ((__pure__));
+extern "C++" const wchar_t *wmemchr (const wchar_t *__s, wchar_t __c,
+         size_t __n)
+     noexcept (true) __asm ("wmemchr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     noexcept (true) __attribute__ ((__pure__));
+
+
+extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
+    const wchar_t *__restrict __s2, size_t __n) noexcept (true);
+
+
+
+extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
+     noexcept (true);
+
+
+extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true);
+
+
+
+
+extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
+     const wchar_t *__restrict __s2, size_t __n)
+     noexcept (true);
+
+
+
+
+
+extern wint_t btowc (int __c) noexcept (true);
+
+
+
+extern int wctob (wint_t __c) noexcept (true);
+
+
+
+extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__));
+
+
+
+extern size_t mbrtowc (wchar_t *__restrict __pwc,
+         const char *__restrict __s, size_t __n,
+         mbstate_t *__restrict __p) noexcept (true);
+
+
+extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
+         mbstate_t *__restrict __ps) noexcept (true);
+
+
+extern size_t __mbrlen (const char *__restrict __s, size_t __n,
+   mbstate_t *__restrict __ps) noexcept (true);
+extern size_t mbrlen (const char *__restrict __s, size_t __n,
+        mbstate_t *__restrict __ps) noexcept (true);
+# 337 "/usr/include/wchar.h" 3 4
+extern size_t mbsrtowcs (wchar_t *__restrict __dst,
+    const char **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) noexcept (true);
+
+
+
+extern size_t wcsrtombs (char *__restrict __dst,
+    const wchar_t **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) noexcept (true);
+
+
+
+
+
+extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
+     const char **__restrict __src, size_t __nmc,
+     size_t __len, mbstate_t *__restrict __ps) noexcept (true);
+
+
+
+extern size_t wcsnrtombs (char *__restrict __dst,
+     const wchar_t **__restrict __src,
+     size_t __nwc, size_t __len,
+     mbstate_t *__restrict __ps) noexcept (true);
+
+
+
+
+
+
+extern int wcwidth (wchar_t __c) noexcept (true);
+
+
+
+extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true);
+
+
+
+
+
+extern double wcstod (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr) noexcept (true);
+
+
+
+extern float wcstof (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) noexcept (true);
+extern long double wcstold (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) noexcept (true);
+# 396 "/usr/include/wchar.h" 3 4
+extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr) noexcept (true);
+
+
+
+extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr) noexcept (true);
+
+
+
+extern _Float128 wcstof128 (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) noexcept (true);
+
+
+
+extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) noexcept (true);
+
+
+
+extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) noexcept (true);
+# 428 "/usr/include/wchar.h" 3 4
+extern long int wcstol (const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, int __base) noexcept (true);
+
+
+
+extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
+      wchar_t **__restrict __endptr, int __base)
+     noexcept (true);
+
+
+
+
+__extension__
+extern long long int wcstoll (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, int __base)
+     noexcept (true);
+
+
+
+__extension__
+extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr,
+     int __base) noexcept (true);
+
+
+
+
+
+__extension__
+extern long long int wcstoq (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr, int __base)
+     noexcept (true);
+
+
+
+__extension__
+extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
+           wchar_t **__restrict __endptr,
+           int __base) noexcept (true);
+
+
+
+
+
+
+extern long int wcstol_l (const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr, int __base,
+     locale_t __loc) noexcept (true);
+
+extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr,
+        int __base, locale_t __loc) noexcept (true);
+
+__extension__
+extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
+    wchar_t **__restrict __endptr,
+    int __base, locale_t __loc) noexcept (true);
+
+__extension__
+extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       int __base, locale_t __loc)
+     noexcept (true);
+
+extern double wcstod_l (const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, locale_t __loc)
+     noexcept (true);
+
+extern float wcstof_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, locale_t __loc)
+     noexcept (true);
+
+extern long double wcstold_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) noexcept (true);
+# 511 "/usr/include/wchar.h" 3 4
+extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       locale_t __loc) noexcept (true);
+
+
+
+extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       locale_t __loc) noexcept (true);
+
+
+
+extern _Float128 wcstof128_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) noexcept (true);
+
+
+
+extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) noexcept (true);
+
+
+
+extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         locale_t __loc) noexcept (true);
+# 551 "/usr/include/wchar.h" 3 4
+extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
+   const wchar_t *__restrict __src) noexcept (true);
+
+
+
+extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
+    const wchar_t *__restrict __src, size_t __n)
+     noexcept (true);
+# 567 "/usr/include/wchar.h" 3 4
+extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true);
+
+
+
+
+
+extern int fwide (__FILE *__fp, int __mode) noexcept (true);
+
+
+
+
+
+
+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, ...)
+     noexcept (true) ;
+
+
+
+
+
+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)
+     noexcept (true) ;
+
+
+
+
+
+
+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, ...)
+     noexcept (true) ;
+# 642 "/usr/include/wchar.h" 3 4
+extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_fwscanf")
+
+
+                                                          ;
+extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc99_wscanf")
+
+                                                          ;
+extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc99_swscanf")
+
+
+                                                          ;
+# 673 "/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)
+     noexcept (true) ;
+
+
+
+
+
+
+
+extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfwscanf")
+
+
+                                                          ;
+extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vwscanf")
+
+                                                          ;
+extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc99_vswscanf")
+
+
+                                                          ;
+# 729 "/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);
+# 784 "/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);
+# 810 "/usr/include/wchar.h" 3 4
+extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
+extern wint_t putwchar_unlocked (wchar_t __wc);
+# 820 "/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) noexcept (true);
+
+
+
+
+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) noexcept (true);
+# 860 "/usr/include/wchar.h" 3 4
+}
+# 45 "/usr/include/c++/10.2.0/cwchar" 2 3
+# 62 "/usr/include/c++/10.2.0/cwchar" 3
+namespace std
+{
+  using ::mbstate_t;
+}
+# 135 "/usr/include/c++/10.2.0/cwchar" 3
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::wint_t;
+
+  using ::btowc;
+  using ::fgetwc;
+  using ::fgetws;
+  using ::fputwc;
+  using ::fputws;
+  using ::fwide;
+  using ::fwprintf;
+  using ::fwscanf;
+  using ::getwc;
+  using ::getwchar;
+  using ::mbrlen;
+  using ::mbrtowc;
+  using ::mbsinit;
+  using ::mbsrtowcs;
+  using ::putwc;
+  using ::putwchar;
+
+  using ::swprintf;
+
+  using ::swscanf;
+  using ::ungetwc;
+  using ::vfwprintf;
+
+  using ::vfwscanf;
+
+
+  using ::vswprintf;
+
+
+  using ::vswscanf;
+
+  using ::vwprintf;
+
+  using ::vwscanf;
+
+  using ::wcrtomb;
+  using ::wcscat;
+  using ::wcscmp;
+  using ::wcscoll;
+  using ::wcscpy;
+  using ::wcscspn;
+  using ::wcsftime;
+  using ::wcslen;
+  using ::wcsncat;
+  using ::wcsncmp;
+  using ::wcsncpy;
+  using ::wcsrtombs;
+  using ::wcsspn;
+  using ::wcstod;
+
+  using ::wcstof;
+
+  using ::wcstok;
+  using ::wcstol;
+  using ::wcstoul;
+  using ::wcsxfrm;
+  using ::wctob;
+  using ::wmemcmp;
+  using ::wmemcpy;
+  using ::wmemmove;
+  using ::wmemset;
+  using ::wprintf;
+  using ::wscanf;
+  using ::wcschr;
+  using ::wcspbrk;
+  using ::wcsrchr;
+  using ::wcsstr;
+  using ::wmemchr;
+# 234 "/usr/include/c++/10.2.0/cwchar" 3
+
+}
+}
+
+
+
+
+
+
+
+namespace __gnu_cxx
+{
+
+
+
+
+
+  using ::wcstold;
+# 260 "/usr/include/c++/10.2.0/cwchar" 3
+  using ::wcstoll;
+  using ::wcstoull;
+
+}
+
+namespace std
+{
+  using ::__gnu_cxx::wcstold;
+  using ::__gnu_cxx::wcstoll;
+  using ::__gnu_cxx::wcstoull;
+}
+# 280 "/usr/include/c++/10.2.0/cwchar" 3
+namespace std
+{
+
+  using std::wcstof;
+
+
+  using std::vfwscanf;
+
+
+  using std::vswscanf;
+
+
+  using std::vwscanf;
+
+
+
+  using std::wcstold;
+  using std::wcstoll;
+  using std::wcstoull;
+
+}
+# 41 "/usr/include/c++/10.2.0/bits/postypes.h" 2 3
+# 68 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 88 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+  typedef long streamoff;
+# 98 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+  typedef ptrdiff_t streamsize;
+# 111 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+  template<typename _StateT>
+    class fpos
+    {
+    private:
+      streamoff _M_off;
+      _StateT _M_state;
+
+    public:
+
+
+
+
+      fpos()
+      : _M_off(0), _M_state() { }
+# 133 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+      fpos(streamoff __off)
+      : _M_off(__off), _M_state() { }
+
+
+      fpos(const fpos&) = default;
+      fpos& operator=(const fpos&) = default;
+      ~fpos() = default;
+
+
+
+      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;
+# 245 "/usr/include/c++/10.2.0/bits/postypes.h" 3
+  typedef fpos<mbstate_t> u16streampos;
+
+  typedef fpos<mbstate_t> u32streampos;
+
+
+
+}
+# 41 "/usr/include/c++/10.2.0/bits/char_traits.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cwchar" 1 3
+# 39 "/usr/include/c++/10.2.0/cwchar" 3
+       
+# 40 "/usr/include/c++/10.2.0/cwchar" 3
+# 42 "/usr/include/c++/10.2.0/bits/char_traits.h" 2 3
+# 50 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+# 64 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+  template<typename _CharT>
+    struct _Char_types
+    {
+      typedef unsigned long int_type;
+      typedef std::streampos pos_type;
+      typedef std::streamoff off_type;
+      typedef std::mbstate_t state_type;
+    };
+# 89 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+  template<typename _CharT>
+    struct char_traits
+    {
+      typedef _CharT char_type;
+      typedef typename _Char_types<_CharT>::int_type int_type;
+      typedef typename _Char_types<_CharT>::pos_type pos_type;
+      typedef typename _Char_types<_CharT>::off_type off_type;
+      typedef typename _Char_types<_CharT>::state_type state_type;
+
+
+
+
+      static constexpr 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 constexpr int
+      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static constexpr std::size_t
+      length(const char_type* __s);
+
+      static constexpr 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>
+    constexpr 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>
+    constexpr 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>
+    constexpr 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)
+    {
+      if (__n == 0)
+ return __s1;
+# 205 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+      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")))
+{
+
+# 302 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+  template<class _CharT>
+    struct char_traits : public __gnu_cxx::char_traits<_CharT>
+    { };
+
+
+
+  template<>
+    struct char_traits<char>
+    {
+      typedef char char_type;
+      typedef int int_type;
+      typedef streampos pos_type;
+      typedef streamoff off_type;
+      typedef mbstate_t state_type;
+
+
+
+
+      static void
+      assign(char_type& __c1, const char_type& __c2) noexcept
+      { __c1 = __c2; }
+
+      static constexpr bool
+      eq(const char_type& __c1, const char_type& __c2) noexcept
+      { return __c1 == __c2; }
+
+      static constexpr bool
+      lt(const char_type& __c1, const char_type& __c2) noexcept
+      {
+
+ return (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; }
+  };
+# 680 "/usr/include/c++/10.2.0/bits/char_traits.h" 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 __c == eof() ? int_type(0xfffd) : 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; }
+    };
+# 938 "/usr/include/c++/10.2.0/bits/char_traits.h" 3
+
+}
+# 41 "/usr/include/c++/10.2.0/string" 2 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/localefwd.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/localefwd.h" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/localefwd.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3
+# 39 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
+       
+# 40 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
+
+# 1 "/usr/include/c++/10.2.0/clocale" 1 3
+# 39 "/usr/include/c++/10.2.0/clocale" 3
+       
+# 40 "/usr/include/c++/10.2.0/clocale" 3
+
+
+# 1 "/usr/include/locale.h" 1 3 4
+# 28 "/usr/include/locale.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 29 "/usr/include/locale.h" 2 3 4
+# 1 "/usr/include/bits/locale.h" 1 3 4
+# 30 "/usr/include/locale.h" 2 3 4
+
+extern "C" {
+# 51 "/usr/include/locale.h" 3 4
+struct lconv
+{
+
+
+  char *decimal_point;
+  char *thousands_sep;
+
+
+
+
+
+  char *grouping;
+
+
+
+
+
+  char *int_curr_symbol;
+  char *currency_symbol;
+  char *mon_decimal_point;
+  char *mon_thousands_sep;
+  char *mon_grouping;
+  char *positive_sign;
+  char *negative_sign;
+  char int_frac_digits;
+  char frac_digits;
+
+  char p_cs_precedes;
+
+  char p_sep_by_space;
+
+  char n_cs_precedes;
+
+  char n_sep_by_space;
+
+
+
+
+
+
+  char p_sign_posn;
+  char n_sign_posn;
+
+
+  char int_p_cs_precedes;
+
+  char int_p_sep_by_space;
+
+  char int_n_cs_precedes;
+
+  char int_n_sep_by_space;
+
+
+
+
+
+
+  char int_p_sign_posn;
+  char int_n_sign_posn;
+# 118 "/usr/include/locale.h" 3 4
+};
+
+
+
+extern char *setlocale (int __category, const char *__locale) noexcept (true);
+
+
+extern struct lconv *localeconv (void) noexcept (true);
+# 141 "/usr/include/locale.h" 3 4
+extern locale_t newlocale (int __category_mask, const char *__locale,
+      locale_t __base) noexcept (true);
+# 176 "/usr/include/locale.h" 3 4
+extern locale_t duplocale (locale_t __dataset) noexcept (true);
+
+
+
+extern void freelocale (locale_t __dataset) noexcept (true);
+
+
+
+
+
+
+extern locale_t uselocale (locale_t __dataset) noexcept (true);
+
+
+
+
+
+
+
+}
+# 43 "/usr/include/c++/10.2.0/clocale" 2 3
+# 51 "/usr/include/c++/10.2.0/clocale" 3
+namespace std
+{
+  using ::lconv;
+  using ::setlocale;
+  using ::localeconv;
+}
+# 42 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3
+
+
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+  extern "C" __typeof(uselocale) __uselocale;
+
+
+}
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  typedef __locale_t __c_locale;
+
+
+
+
+
+  inline int
+  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
+     char* __out,
+     const int __size __attribute__ ((__unused__)),
+     const char* __fmt, ...)
+  {
+
+    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
+# 88 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++locale.h" 3
+    __builtin_va_list __args;
+    __builtin_va_start(__args, __fmt);
+
+
+    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+
+
+
+
+    __builtin_va_end(__args);
+
+
+    __gnu_cxx::__uselocale(__old);
+
+
+
+
+
+
+
+    return __ret;
+  }
+
+
+}
+# 41 "/usr/include/c++/10.2.0/bits/localefwd.h" 2 3
+# 1 "/usr/include/c++/10.2.0/iosfwd" 1 3
+# 36 "/usr/include/c++/10.2.0/iosfwd" 3
+       
+# 37 "/usr/include/c++/10.2.0/iosfwd" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 74 "/usr/include/c++/10.2.0/iosfwd" 3
+  class ios_base;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ios;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_streambuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_istream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ostream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_iostream;
+
+
+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 "/usr/include/c++/10.2.0/bits/localefwd.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cctype" 1 3
+# 39 "/usr/include/c++/10.2.0/cctype" 3
+       
+# 40 "/usr/include/c++/10.2.0/cctype" 3
+
+
+# 1 "/usr/include/ctype.h" 1 3 4
+# 28 "/usr/include/ctype.h" 3 4
+extern "C" {
+# 39 "/usr/include/ctype.h" 3 4
+# 1 "/usr/include/bits/endian.h" 1 3 4
+# 35 "/usr/include/bits/endian.h" 3 4
+# 1 "/usr/include/bits/endianness.h" 1 3 4
+# 36 "/usr/include/bits/endian.h" 2 3 4
+# 40 "/usr/include/ctype.h" 2 3 4
+
+
+
+
+
+
+enum
+{
+  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
+  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
+  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
+  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
+  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
+  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
+  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
+  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
+  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
+  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
+  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
+  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
+};
+# 79 "/usr/include/ctype.h" 3 4
+extern const unsigned short int **__ctype_b_loc (void)
+     noexcept (true) __attribute__ ((__const__));
+extern const __int32_t **__ctype_tolower_loc (void)
+     noexcept (true) __attribute__ ((__const__));
+extern const __int32_t **__ctype_toupper_loc (void)
+     noexcept (true) __attribute__ ((__const__));
+# 108 "/usr/include/ctype.h" 3 4
+extern int isalnum (int) noexcept (true);
+extern int isalpha (int) noexcept (true);
+extern int iscntrl (int) noexcept (true);
+extern int isdigit (int) noexcept (true);
+extern int islower (int) noexcept (true);
+extern int isgraph (int) noexcept (true);
+extern int isprint (int) noexcept (true);
+extern int ispunct (int) noexcept (true);
+extern int isspace (int) noexcept (true);
+extern int isupper (int) noexcept (true);
+extern int isxdigit (int) noexcept (true);
+
+
+
+extern int tolower (int __c) noexcept (true);
+
+
+extern int toupper (int __c) noexcept (true);
+
+
+
+
+extern int isblank (int) noexcept (true);
+
+
+
+
+extern int isctype (int __c, int __mask) noexcept (true);
+
+
+
+
+
+
+extern int isascii (int __c) noexcept (true);
+
+
+
+extern int toascii (int __c) noexcept (true);
+
+
+
+extern int _toupper (int) noexcept (true);
+extern int _tolower (int) noexcept (true);
+# 251 "/usr/include/ctype.h" 3 4
+extern int isalnum_l (int, locale_t) noexcept (true);
+extern int isalpha_l (int, locale_t) noexcept (true);
+extern int iscntrl_l (int, locale_t) noexcept (true);
+extern int isdigit_l (int, locale_t) noexcept (true);
+extern int islower_l (int, locale_t) noexcept (true);
+extern int isgraph_l (int, locale_t) noexcept (true);
+extern int isprint_l (int, locale_t) noexcept (true);
+extern int ispunct_l (int, locale_t) noexcept (true);
+extern int isspace_l (int, locale_t) noexcept (true);
+extern int isupper_l (int, locale_t) noexcept (true);
+extern int isxdigit_l (int, locale_t) noexcept (true);
+
+extern int isblank_l (int, locale_t) noexcept (true);
+
+
+
+extern int __tolower_l (int __c, locale_t __l) noexcept (true);
+extern int tolower_l (int __c, locale_t __l) noexcept (true);
+
+
+extern int __toupper_l (int __c, locale_t __l) noexcept (true);
+extern int toupper_l (int __c, locale_t __l) noexcept (true);
+# 327 "/usr/include/ctype.h" 3 4
+}
+# 43 "/usr/include/c++/10.2.0/cctype" 2 3
+# 62 "/usr/include/c++/10.2.0/cctype" 3
+namespace std
+{
+  using ::isalnum;
+  using ::isalpha;
+  using ::iscntrl;
+  using ::isdigit;
+  using ::isgraph;
+  using ::islower;
+  using ::isprint;
+  using ::ispunct;
+  using ::isspace;
+  using ::isupper;
+  using ::isxdigit;
+  using ::tolower;
+  using ::toupper;
+}
+
+
+
+
+
+
+
+namespace std
+{
+  using ::isblank;
+}
+# 43 "/usr/include/c++/10.2.0/bits/localefwd.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 55 "/usr/include/c++/10.2.0/bits/localefwd.h" 3
+  class locale;
+
+  template<typename _Facet>
+    bool
+    has_facet(const locale&) throw();
+
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale&);
+
+
+  template<typename _CharT>
+    bool
+    isspace(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isprint(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    iscntrl(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isupper(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    islower(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalpha(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    ispunct(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isxdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalnum(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isgraph(_CharT, const locale&);
+
+
+  template<typename _CharT>
+    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<> class codecvt<char16_t, char, mbstate_t>;
+  template<> class codecvt<char32_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 "/usr/include/c++/10.2.0/string" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/ostream_insert.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/ostream_insert.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/ostream_insert.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/cxxabi_forced.h" 1 3
+# 34 "/usr/include/c++/10.2.0/bits/cxxabi_forced.h" 3
+       
+# 35 "/usr/include/c++/10.2.0/bits/cxxabi_forced.h" 3
+
+#pragma GCC visibility push(default)
+
+
+namespace __cxxabiv1
+{
+
+
+
+
+
+
+
+  class __forced_unwind
+  {
+    virtual ~__forced_unwind() throw();
+
+
+    virtual void __pure_dummy() = 0;
+  };
+}
+
+
+#pragma GCC visibility pop
+# 37 "/usr/include/c++/10.2.0/bits/ostream_insert.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+      const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+      if (__put != __n)
+ __out.setstate(__ios_base::badbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const _CharT __c = __out.fill();
+      for (; __n > 0; --__n)
+ {
+   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+   if (_Traits::eq_int_type(__put, _Traits::eof()))
+     {
+       __out.setstate(__ios_base::badbit);
+       break;
+     }
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+       const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      typename __ostream_type::sentry __cerb(__out);
+      if (__cerb)
+ {
+   try
+     {
+       const streamsize __w = __out.width();
+       if (__w > __n)
+  {
+    const bool __left = ((__out.flags()
+     & __ios_base::adjustfield)
+           == __ios_base::left);
+    if (!__left)
+      __ostream_fill(__out, __w - __n);
+    if (__out.good())
+      __ostream_write(__out, __s, __n);
+    if (__left && __out.good())
+      __ostream_fill(__out, __w - __n);
+  }
+       else
+  __ostream_write(__out, __s, __n);
+       __out.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(__ios_base::badbit); }
+ }
+      return __out;
+    }
+
+
+
+
+  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
+
+
+  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
+          streamsize);
+
+
+
+
+}
+# 45 "/usr/include/c++/10.2.0/string" 2 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_function.h" 1 3
+# 63 "/usr/include/c++/10.2.0/bits/stl_function.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 104 "/usr/include/c++/10.2.0/bits/stl_function.h" 3
+  template<typename _Arg, typename _Result>
+    struct unary_function
+    {
+
+      typedef _Arg argument_type;
+
+
+      typedef _Result result_type;
+    };
+
+
+
+
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    struct binary_function
+    {
+
+      typedef _Arg1 first_argument_type;
+
+
+      typedef _Arg2 second_argument_type;
+
+
+      typedef _Result result_type;
+    };
+# 144 "/usr/include/c++/10.2.0/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;
+    };
+# 330 "/usr/include/c++/10.2.0/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<typename _Tp>
+    struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+
+
+ if (__builtin_is_constant_evaluated())
+
+
+
+   return __x > __y;
+
+ return (long unsigned int)__x > (long unsigned int)__y;
+      }
+    };
+
+
+  template<typename _Tp>
+    struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+
+
+ if (__builtin_is_constant_evaluated())
+
+
+
+   return __x < __y;
+
+ return (long unsigned int)__x < (long unsigned int)__y;
+      }
+    };
+
+
+  template<typename _Tp>
+    struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+
+
+ if (__builtin_is_constant_evaluated())
+
+
+
+   return __x >= __y;
+
+ return (long unsigned int)__x >= (long unsigned int)__y;
+      }
+    };
+
+
+  template<typename _Tp>
+    struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
+    {
+      constexpr bool
+      operator()(_Tp* __x, _Tp* __y) const noexcept
+      {
+
+
+ if (__builtin_is_constant_evaluated())
+
+
+
+   return __x <= __y;
+
+ return (long unsigned int)__x <= (long unsigned int)__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 _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+
+      typedef __is_transparent is_transparent;
+
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
+
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return greater<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
+ : false_type { };
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+
+
+  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 _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+
+      typedef __is_transparent is_transparent;
+
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
+
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return less<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
+ : false_type { };
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+
+
+  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 _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+
+      typedef __is_transparent is_transparent;
+
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
+
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return greater_equal<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
+ : false_type { };
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+
+
+  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 _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
+   __ptr_cmp<_Tp, _Up>{});
+ }
+
+      template<typename _Tp, typename _Up>
+ constexpr bool
+ operator()(_Tp* __t, _Up* __u) const noexcept
+ { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
+
+      typedef __is_transparent is_transparent;
+
+    private:
+      template <typename _Tp, typename _Up>
+ static constexpr decltype(auto)
+ _S_cmp(_Tp&& __t, _Up&& __u, false_type)
+ { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
+
+      template <typename _Tp, typename _Up>
+ static constexpr bool
+ _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
+ {
+   return less_equal<const volatile void*>{}(
+       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
+       static_cast<const volatile void*>(std::forward<_Up>(__u)));
+ }
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded2 : true_type { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded2<_Tp, _Up, __void_t<
+   decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
+ : false_type { };
+
+
+      template<typename _Tp, typename _Up, typename = void>
+ struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
+
+
+      template<typename _Tp, typename _Up>
+ struct __not_overloaded<_Tp, _Up, __void_t<
+   decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
+ : false_type { };
+
+      template<typename _Tp, typename _Up>
+ using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
+       is_convertible<_Tp, const volatile void*>,
+       is_convertible<_Up, const volatile void*>>;
+    };
+# 774 "/usr/include/c++/10.2.0/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;
+    };
+# 1002 "/usr/include/c++/10.2.0/bits/stl_function.h" 3
+  template<typename _Predicate>
+    class unary_negate
+    : public unary_function<typename _Predicate::argument_type, bool>
+    {
+    protected:
+      _Predicate _M_pred;
+
+    public:
+      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); }
+# 1079 "/usr/include/c++/10.2.0/bits/stl_function.h" 3
+  template<typename _Arg, typename _Result>
+    class pointer_to_unary_function : public unary_function<_Arg, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg);
+
+    public:
+      pointer_to_unary_function() { }
+
+      explicit
+      pointer_to_unary_function(_Result (*__x)(_Arg))
+      : _M_ptr(__x) { }
+
+      _Result
+      operator()(_Arg __x) const
+      { return _M_ptr(__x); }
+    };
+
+
+  template<typename _Arg, typename _Result>
+    inline pointer_to_unary_function<_Arg, _Result>
+    ptr_fun(_Result (*__x)(_Arg))
+    { return pointer_to_unary_function<_Arg, _Result>(__x); }
+
+
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    class pointer_to_binary_function
+    : public binary_function<_Arg1, _Arg2, _Result>
+    {
+    protected:
+      _Result (*_M_ptr)(_Arg1, _Arg2);
+
+    public:
+      pointer_to_binary_function() { }
+
+      explicit
+      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
+      : _M_ptr(__x) { }
+
+      _Result
+      operator()(_Arg1 __x, _Arg2 __y) const
+      { return _M_ptr(__x, __y); }
+    };
+
+
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
+    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
+    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
+
+
+  template<typename _Tp>
+    struct _Identity
+    : public unary_function<_Tp, _Tp>
+    {
+      _Tp&
+      operator()(_Tp& __x) const
+      { return __x; }
+
+      const _Tp&
+      operator()(const _Tp& __x) const
+      { return __x; }
+    };
+
+
+  template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };
+
+  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; }
+    };
+# 1202 "/usr/include/c++/10.2.0/bits/stl_function.h" 3
+  template<typename _Ret, typename _Tp>
+    class mem_fun_t : public unary_function<_Tp*, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp* __p) const
+      { return (__p->*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)();
+    };
+
+
+
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp* __p) const
+      { return (__p->*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp>
+    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_ref_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp& __r) const
+      { return (__r.*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)();
+  };
+
+
+
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp& __r) const
+      { return (__r.*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)())
+    { return mem_fun_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)())
+    { return mem_fun_ref_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+
+
+
+}
+
+
+# 1 "/usr/include/c++/10.2.0/backward/binders.h" 1 3
+# 60 "/usr/include/c++/10.2.0/backward/binders.h" 3
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 107 "/usr/include/c++/10.2.0/backward/binders.h" 3
+  template<typename _Operation>
+    class binder1st
+    : public unary_function<typename _Operation::second_argument_type,
+       typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::first_argument_type value;
+
+    public:
+      binder1st(const _Operation& __x,
+  const typename _Operation::first_argument_type& __y)
+      : op(__x), value(__y) { }
+
+      typename _Operation::result_type
+      operator()(const typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+
+
+
+      typename _Operation::result_type
+      operator()(typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+    } __attribute__ ((__deprecated__));
+
+
+  template<typename _Operation, typename _Tp>
+    inline binder1st<_Operation>
+    bind1st(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::first_argument_type _Arg1_type;
+      return binder1st<_Operation>(__fn, _Arg1_type(__x));
+    }
+
+
+  template<typename _Operation>
+    class binder2nd
+    : public unary_function<typename _Operation::first_argument_type,
+       typename _Operation::result_type>
+    {
+    protected:
+      _Operation op;
+      typename _Operation::second_argument_type value;
+
+    public:
+      binder2nd(const _Operation& __x,
+  const typename _Operation::second_argument_type& __y)
+      : op(__x), value(__y) { }
+
+      typename _Operation::result_type
+      operator()(const typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+
+
+
+      typename _Operation::result_type
+      operator()(typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+    } __attribute__ ((__deprecated__));
+
+
+  template<typename _Operation, typename _Tp>
+    inline binder2nd<_Operation>
+    bind2nd(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::second_argument_type _Arg2_type;
+      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
+    }
+
+
+
+}
+
+#pragma GCC diagnostic pop
+# 1393 "/usr/include/c++/10.2.0/bits/stl_function.h" 2 3
+# 49 "/usr/include/c++/10.2.0/string" 2 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/basic_string.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+
+# 1 "/usr/include/c++/10.2.0/ext/atomicity.h" 1 3
+# 32 "/usr/include/c++/10.2.0/ext/atomicity.h" 3
+       
+# 33 "/usr/include/c++/10.2.0/ext/atomicity.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 1 3
+# 30 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 3
+#pragma GCC visibility push(default)
+# 148 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3
+# 35 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+# 1 "/usr/include/pthread.h" 1 3 4
+# 22 "/usr/include/pthread.h" 3 4
+# 1 "/usr/include/sched.h" 1 3 4
+# 29 "/usr/include/sched.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 30 "/usr/include/sched.h" 2 3 4
+
+# 1 "/usr/include/bits/types/time_t.h" 1 3 4
+
+
+
+
+
+
+typedef __time_t time_t;
+# 32 "/usr/include/sched.h" 2 3 4
+# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4
+# 10 "/usr/include/bits/types/struct_timespec.h" 3 4
+struct timespec
+{
+  __time_t tv_sec;
+
+
+
+  __syscall_slong_t tv_nsec;
+# 26 "/usr/include/bits/types/struct_timespec.h" 3 4
+};
+# 33 "/usr/include/sched.h" 2 3 4
+
+
+
+
+
+typedef __pid_t pid_t;
+
+
+
+
+# 1 "/usr/include/bits/sched.h" 1 3 4
+# 76 "/usr/include/bits/sched.h" 3 4
+# 1 "/usr/include/bits/types/struct_sched_param.h" 1 3 4
+# 23 "/usr/include/bits/types/struct_sched_param.h" 3 4
+struct sched_param
+{
+  int sched_priority;
+};
+# 77 "/usr/include/bits/sched.h" 2 3 4
+
+extern "C" {
+
+
+
+extern int clone (int (*__fn) (void *__arg), void *__child_stack,
+    int __flags, void *__arg, ...) noexcept (true);
+
+
+extern int unshare (int __flags) noexcept (true);
+
+
+extern int sched_getcpu (void) noexcept (true);
+
+
+extern int getcpu (unsigned int *, unsigned int *) noexcept (true);
+
+
+extern int setns (int __fd, int __nstype) noexcept (true);
+
+
+}
+# 44 "/usr/include/sched.h" 2 3 4
+# 1 "/usr/include/bits/cpu-set.h" 1 3 4
+# 32 "/usr/include/bits/cpu-set.h" 3 4
+typedef unsigned long int __cpu_mask;
+
+
+
+
+
+
+typedef struct
+{
+  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
+} cpu_set_t;
+# 115 "/usr/include/bits/cpu-set.h" 3 4
+extern "C" {
+
+extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
+     noexcept (true);
+extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) ;
+extern void __sched_cpufree (cpu_set_t *__set) noexcept (true);
+
+}
+# 45 "/usr/include/sched.h" 2 3 4
+
+
+
+
+
+
+extern "C" {
+
+
+extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
+     noexcept (true);
+
+
+extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true);
+
+
+extern int sched_setscheduler (__pid_t __pid, int __policy,
+          const struct sched_param *__param) noexcept (true);
+
+
+extern int sched_getscheduler (__pid_t __pid) noexcept (true);
+
+
+extern int sched_yield (void) noexcept (true);
+
+
+extern int sched_get_priority_max (int __algorithm) noexcept (true);
+
+
+extern int sched_get_priority_min (int __algorithm) noexcept (true);
+
+
+extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true);
+# 121 "/usr/include/sched.h" 3 4
+extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
+         const cpu_set_t *__cpuset) noexcept (true);
+
+
+extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
+         cpu_set_t *__cpuset) noexcept (true);
+
+
+}
+# 23 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/time.h" 1 3 4
+# 29 "/usr/include/time.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 30 "/usr/include/time.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/time.h" 1 3 4
+# 73 "/usr/include/bits/time.h" 3 4
+# 1 "/usr/include/bits/timex.h" 1 3 4
+# 22 "/usr/include/bits/timex.h" 3 4
+# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4
+
+
+
+
+
+
+
+struct timeval
+{
+  __time_t tv_sec;
+  __suseconds_t tv_usec;
+};
+# 23 "/usr/include/bits/timex.h" 2 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;
+};
+# 74 "/usr/include/bits/time.h" 2 3 4
+
+extern "C" {
+
+
+extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true);
+
+}
+# 34 "/usr/include/time.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/types/clock_t.h" 1 3 4
+
+
+
+
+
+
+typedef __clock_t clock_t;
+# 38 "/usr/include/time.h" 2 3 4
+
+# 1 "/usr/include/bits/types/struct_tm.h" 1 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;
+
+
+
+
+};
+# 40 "/usr/include/time.h" 2 3 4
+
+
+
+
+
+
+# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4
+
+
+
+
+
+
+typedef __clockid_t clockid_t;
+# 47 "/usr/include/time.h" 2 3 4
+# 1 "/usr/include/bits/types/timer_t.h" 1 3 4
+
+
+
+
+
+
+typedef __timer_t timer_t;
+# 48 "/usr/include/time.h" 2 3 4
+# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4
+
+
+
+
+
+
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+# 49 "/usr/include/time.h" 2 3 4
+struct sigevent;
+# 68 "/usr/include/time.h" 3 4
+extern "C" {
+
+
+
+extern clock_t clock (void) noexcept (true);
+
+
+extern time_t time (time_t *__timer) noexcept (true);
+
+
+extern double difftime (time_t __time1, time_t __time0)
+     noexcept (true) __attribute__ ((__const__));
+
+
+extern time_t mktime (struct tm *__tp) noexcept (true);
+
+
+
+
+
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+   const char *__restrict __format,
+   const struct tm *__restrict __tp) noexcept (true);
+
+
+
+
+extern char *strptime (const char *__restrict __s,
+         const char *__restrict __fmt, struct tm *__tp)
+     noexcept (true);
+
+
+
+
+
+
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+     const char *__restrict __format,
+     const struct tm *__restrict __tp,
+     locale_t __loc) noexcept (true);
+
+
+
+extern char *strptime_l (const char *__restrict __s,
+    const char *__restrict __fmt, struct tm *__tp,
+    locale_t __loc) noexcept (true);
+
+
+
+
+
+extern struct tm *gmtime (const time_t *__timer) noexcept (true);
+
+
+
+extern struct tm *localtime (const time_t *__timer) noexcept (true);
+
+
+
+
+extern struct tm *gmtime_r (const time_t *__restrict __timer,
+       struct tm *__restrict __tp) noexcept (true);
+
+
+
+extern struct tm *localtime_r (const time_t *__restrict __timer,
+          struct tm *__restrict __tp) noexcept (true);
+
+
+
+
+extern char *asctime (const struct tm *__tp) noexcept (true);
+
+
+extern char *ctime (const time_t *__timer) noexcept (true);
+
+
+
+
+
+
+extern char *asctime_r (const struct tm *__restrict __tp,
+   char *__restrict __buf) noexcept (true);
+
+
+extern char *ctime_r (const time_t *__restrict __timer,
+        char *__restrict __buf) noexcept (true);
+
+
+
+
+extern char *__tzname[2];
+extern int __daylight;
+extern long int __timezone;
+
+
+
+
+extern char *tzname[2];
+
+
+
+extern void tzset (void) noexcept (true);
+
+
+
+extern int daylight;
+extern long int timezone;
+# 190 "/usr/include/time.h" 3 4
+extern time_t timegm (struct tm *__tp) noexcept (true);
+
+
+extern time_t timelocal (struct tm *__tp) noexcept (true);
+
+
+extern int dysize (int __year) noexcept (true) __attribute__ ((__const__));
+# 205 "/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) noexcept (true);
+
+
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) noexcept (true);
+
+
+extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
+     noexcept (true);
+
+
+
+
+
+
+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) noexcept (true);
+
+
+
+
+extern int timer_create (clockid_t __clock_id,
+    struct sigevent *__restrict __evp,
+    timer_t *__restrict __timerid) noexcept (true);
+
+
+extern int timer_delete (timer_t __timerid) noexcept (true);
+
+
+extern int timer_settime (timer_t __timerid, int __flags,
+     const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue) noexcept (true);
+
+
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     noexcept (true);
+
+
+extern int timer_getoverrun (timer_t __timerid) noexcept (true);
+
+
+
+
+
+extern int timespec_get (struct timespec *__ts, int __base)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+# 274 "/usr/include/time.h" 3 4
+extern int getdate_err;
+# 283 "/usr/include/time.h" 3 4
+extern struct tm *getdate (const char *__string);
+# 297 "/usr/include/time.h" 3 4
+extern int getdate_r (const char *__restrict __string,
+        struct tm *__restrict __resbufp);
+
+
+}
+# 24 "/usr/include/pthread.h" 2 3 4
+
+
+# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
+# 23 "/usr/include/bits/pthreadtypes.h" 3 4
+# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4
+# 44 "/usr/include/bits/thread-shared-types.h" 3 4
+# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4
+# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4
+# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4
+
+
+
+
+typedef struct __pthread_internal_list
+{
+  struct __pthread_internal_list *__prev;
+  struct __pthread_internal_list *__next;
+} __pthread_list_t;
+
+typedef struct __pthread_internal_slist
+{
+  struct __pthread_internal_slist *__next;
+} __pthread_slist_t;
+# 74 "/usr/include/bits/thread-shared-types.h" 3 4
+# 1 "/usr/include/bits/struct_mutex.h" 1 3 4
+# 22 "/usr/include/bits/struct_mutex.h" 3 4
+struct __pthread_mutex_s
+{
+  int __lock;
+  unsigned int __count;
+  int __owner;
+
+  unsigned int __nusers;
+
+
+
+  int __kind;
+
+  short __spins;
+  short __elision;
+  __pthread_list_t __list;
+# 53 "/usr/include/bits/struct_mutex.h" 3 4
+};
+# 75 "/usr/include/bits/thread-shared-types.h" 2 3 4
+# 87 "/usr/include/bits/thread-shared-types.h" 3 4
+# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4
+# 23 "/usr/include/bits/struct_rwlock.h" 3 4
+struct __pthread_rwlock_arch_t
+{
+  unsigned int __readers;
+  unsigned int __writers;
+  unsigned int __wrphase_futex;
+  unsigned int __writers_futex;
+  unsigned int __pad3;
+  unsigned int __pad4;
+
+  int __cur_writer;
+  int __shared;
+  signed char __rwelision;
+
+
+
+
+  unsigned char __pad1[7];
+
+
+  unsigned long int __pad2;
+
+
+  unsigned int __flags;
+# 55 "/usr/include/bits/struct_rwlock.h" 3 4
+};
+# 88 "/usr/include/bits/thread-shared-types.h" 2 3 4
+
+
+
+
+struct __pthread_cond_s
+{
+  __extension__ union
+  {
+    __extension__ unsigned long long int __wseq;
+    struct
+    {
+      unsigned int __low;
+      unsigned int __high;
+    } __wseq32;
+  };
+  __extension__ union
+  {
+    __extension__ unsigned long long int __g1_start;
+    struct
+    {
+      unsigned int __low;
+      unsigned int __high;
+    } __g1_start32;
+  };
+  unsigned int __g_refs[2] ;
+  unsigned int __g_size[2];
+  unsigned int __g1_orig_size;
+  unsigned int __wrefs;
+  unsigned int __g_signals[2];
+};
+
+typedef unsigned int __tss_t;
+typedef unsigned long int __thrd_t;
+
+typedef struct
+{
+  int __data ;
+} __once_flag;
+# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
+
+
+
+typedef unsigned long int pthread_t;
+
+
+
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_mutexattr_t;
+
+
+
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_condattr_t;
+
+
+
+typedef unsigned int pthread_key_t;
+
+
+
+typedef int pthread_once_t;
+
+
+union pthread_attr_t
+{
+  char __size[56];
+  long int __align;
+};
+
+typedef union pthread_attr_t pthread_attr_t;
+
+
+
+
+typedef union
+{
+  struct __pthread_mutex_s __data;
+  char __size[40];
+  long int __align;
+} pthread_mutex_t;
+
+
+typedef union
+{
+  struct __pthread_cond_s __data;
+  char __size[48];
+  __extension__ long long int __align;
+} pthread_cond_t;
+
+
+
+
+
+typedef union
+{
+  struct __pthread_rwlock_arch_t __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[4];
+  int __align;
+} pthread_barrierattr_t;
+# 27 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/bits/setjmp.h" 1 3 4
+# 26 "/usr/include/bits/setjmp.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 27 "/usr/include/bits/setjmp.h" 2 3 4
+
+
+
+
+typedef long int __jmp_buf[8];
+# 28 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 29 "/usr/include/pthread.h" 2 3 4
+
+# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4
+
+
+
+
+typedef struct
+{
+  unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
+} __sigset_t;
+# 31 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/bits/types/struct___jmp_buf_tag.h" 1 3 4
+# 26 "/usr/include/bits/types/struct___jmp_buf_tag.h" 3 4
+struct __jmp_buf_tag
+  {
+
+
+
+
+    __jmp_buf __jmpbuf;
+    int __mask_was_saved;
+    __sigset_t __saved_mask;
+  };
+# 32 "/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
+};
+# 102 "/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
+};
+# 122 "/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
+
+};
+# 157 "/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
+
+};
+# 195 "/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) noexcept (true) __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) noexcept (true);
+
+
+
+
+
+
+
+extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
+     const struct timespec *__abstime);
+# 240 "/usr/include/pthread.h" 3 4
+extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return,
+                                 clockid_t __clockid,
+     const struct timespec *__abstime);
+
+
+
+
+
+
+extern int pthread_detach (pthread_t __th) noexcept (true);
+
+
+
+extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__));
+
+
+extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
+  noexcept (true) __attribute__ ((__const__));
+
+
+
+
+
+
+
+extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_destroy (pthread_attr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
+     int *__detachstate)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
+     int __detachstate)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
+          size_t *__guardsize)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
+          size_t __guardsize)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
+           struct sched_param *__restrict __param)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
+           const struct sched_param *__restrict
+           __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
+     __attr, int *__restrict __policy)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
+      __attr, int *__restrict __inherit)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
+      int __inherit)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
+      int *__restrict __scope)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
+          __attr, void **__restrict __stackaddr)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
+
+
+
+
+
+extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
+          void *__stackaddr)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
+
+
+extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
+          __attr, size_t *__restrict __stacksize)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
+          size_t __stacksize)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
+      void **__restrict __stackaddr,
+      size_t *__restrict __stacksize)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
+      size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     const cpu_set_t *__cpuset)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     cpu_set_t *__cpuset)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+extern int pthread_getattr_default_np (pthread_attr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr,
+           const __sigset_t *sigmask);
+
+
+
+
+extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr,
+           __sigset_t *sigmask);
+
+
+
+
+
+
+
+extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+
+extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
+      const struct sched_param *__param)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getschedparam (pthread_t __target_thread,
+      int *__restrict __policy,
+      struct sched_param *__restrict __param)
+     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));
+
+
+extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
+     noexcept (true);
+
+
+
+
+extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
+          size_t __buflen)
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+extern int pthread_getconcurrency (void) noexcept (true);
+
+
+extern int pthread_setconcurrency (int __level) noexcept (true);
+
+
+
+
+
+
+
+extern int pthread_yield (void) noexcept (true);
+
+
+
+
+extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
+       const cpu_set_t *__cpuset)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
+       cpu_set_t *__cpuset)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+# 486 "/usr/include/pthread.h" 3 4
+extern int pthread_once (pthread_once_t *__once_control,
+    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
+# 498 "/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);
+
+
+
+
+struct __cancel_jmp_buf_tag
+{
+  __jmp_buf __cancel_jmp_buf;
+  int __mask_was_saved;
+};
+
+typedef struct
+{
+  struct __cancel_jmp_buf_tag __cancel_jmp_buf[1];
+  void *__pad[4];
+} __pthread_unwind_buf_t __attribute__ ((__aligned__));
+# 534 "/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); }
+};
+# 750 "/usr/include/pthread.h" 3 4
+extern int __sigsetjmp (struct __jmp_buf_tag __env[1],
+   int __savemask) noexcept (true);
+
+
+
+
+
+
+extern int pthread_mutex_init (pthread_mutex_t *__mutex,
+          const pthread_mutexattr_t *__mutexattr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
+        const struct timespec *__restrict
+        __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex,
+        clockid_t __clockid,
+        const struct timespec *__restrict
+        __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
+      __restrict __mutex,
+      int *__restrict __prioceiling)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
+      int __prioceiling,
+      int *__restrict __old_ceiling)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+# 822 "/usr/include/pthread.h" 3 4
+extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
+      __restrict __attr,
+      int *__restrict __pshared)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
+      int __pshared)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
+          __attr, int *__restrict __kind)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
+       __restrict __attr,
+       int *__restrict __protocol)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
+       int __protocol)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
+          __restrict __attr,
+          int *__restrict __prioceiling)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
+          int __prioceiling)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
+     int *__robustness)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int pthread_mutexattr_getrobust_np (const pthread_mutexattr_t *__attr,
+        int *__robustness)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
+     int __robustness)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
+        int __robustness)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+# 904 "/usr/include/pthread.h" 3 4
+extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
+    const pthread_rwlockattr_t *__restrict
+    __attr) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
+  noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock,
+           clockid_t __clockid,
+           const struct timespec *__restrict
+           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
+           const struct timespec *__restrict
+           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock,
+           clockid_t __clockid,
+           const struct timespec *__restrict
+           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pshared)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
+       int __pshared)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pref)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
+       int __pref) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
+         const pthread_condattr_t *__restrict __cond_attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_destroy (pthread_cond_t *__cond)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_signal (pthread_cond_t *__cond)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_broadcast (pthread_cond_t *__cond)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
+         pthread_mutex_t *__restrict __mutex)
+     __attribute__ ((__nonnull__ (1, 2)));
+# 1030 "/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)));
+# 1043 "/usr/include/pthread.h" 3 4
+extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond,
+       pthread_mutex_t *__restrict __mutex,
+       __clockid_t __clock_id,
+       const struct timespec *__restrict __abstime)
+     __attribute__ ((__nonnull__ (1, 2, 4)));
+
+
+
+
+
+extern int pthread_condattr_init (pthread_condattr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_getpshared (const pthread_condattr_t *
+     __restrict __attr,
+     int *__restrict __pshared)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
+     int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_condattr_getclock (const pthread_condattr_t *
+          __restrict __attr,
+          __clockid_t *__restrict __clock_id)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
+          __clockid_t __clock_id)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+# 1089 "/usr/include/pthread.h" 3 4
+extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_lock (pthread_spinlock_t *__lock)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
+     const pthread_barrierattr_t *__restrict
+     __attr, unsigned int __count)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
+        __restrict __attr,
+        int *__restrict __pshared)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
+        int __pshared)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+# 1156 "/usr/include/pthread.h" 3 4
+extern int pthread_key_create (pthread_key_t *__key,
+          void (*__destr_function) (void *))
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_key_delete (pthread_key_t __key) noexcept (true);
+
+
+extern void *pthread_getspecific (pthread_key_t __key) noexcept (true);
+
+
+extern int pthread_setspecific (pthread_key_t __key,
+    const void *__pointer) noexcept (true) ;
+
+
+
+
+extern int pthread_getcpuclockid (pthread_t __thread_id,
+      __clockid_t *__clock_id)
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+# 1190 "/usr/include/pthread.h" 3 4
+extern int pthread_atfork (void (*__prepare) (void),
+      void (*__parent) (void),
+      void (*__child) (void)) noexcept (true);
+# 1204 "/usr/include/pthread.h" 3 4
+}
+# 36 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3
+# 47 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+typedef pthread_t __gthread_t;
+typedef pthread_key_t __gthread_key_t;
+typedef pthread_once_t __gthread_once_t;
+typedef pthread_mutex_t __gthread_mutex_t;
+typedef pthread_mutex_t __gthread_recursive_mutex_t;
+typedef pthread_cond_t __gthread_cond_t;
+typedef struct timespec __gthread_time_t;
+# 102 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once"), __copy__ (pthread_once)));
+static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific"), __copy__ (pthread_getspecific)));
+static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific"), __copy__ (pthread_setspecific)));
+
+static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create"), __copy__ (pthread_create)));
+static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join"), __copy__ (pthread_join)));
+static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal"), __copy__ (pthread_equal)));
+static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self"), __copy__ (pthread_self)));
+static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach"), __copy__ (pthread_detach)));
+
+static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel"), __copy__ (pthread_cancel)));
+
+static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield"), __copy__ (sched_yield)));
+
+static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock"), __copy__ (pthread_mutex_lock)));
+static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock"), __copy__ (pthread_mutex_trylock)));
+
+static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock"), __copy__ (pthread_mutex_timedlock)));
+
+static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock"), __copy__ (pthread_mutex_unlock)));
+static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init"), __copy__ (pthread_mutex_init)));
+static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy"), __copy__ (pthread_mutex_destroy)));
+
+static __typeof(pthread_cond_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init"), __copy__ (pthread_cond_init)));
+static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast"), __copy__ (pthread_cond_broadcast)));
+static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal"), __copy__ (pthread_cond_signal)));
+static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait"), __copy__ (pthread_cond_wait)));
+static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait"), __copy__ (pthread_cond_timedwait)));
+static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy"), __copy__ (pthread_cond_destroy)));
+
+static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create"), __copy__ (pthread_key_create)));
+static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete"), __copy__ (pthread_key_delete)));
+static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init"), __copy__ (pthread_mutexattr_init)));
+static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype"), __copy__ (pthread_mutexattr_settype)));
+static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy"), __copy__ (pthread_mutexattr_destroy)));
+# 237 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create"), __copy__ (pthread_key_create)));
+# 247 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_active_p (void)
+{
+  static void *const __gthread_active_ptr
+    = __extension__ (void *) &__gthrw___pthread_key_create;
+  return __gthread_active_ptr != 0;
+}
+# 659 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
+    void *__args)
+{
+  return __gthrw_pthread_create (__threadid, __null, __func, __args);
+}
+
+static inline int
+__gthread_join (__gthread_t __threadid, void **__value_ptr)
+{
+  return __gthrw_pthread_join (__threadid, __value_ptr);
+}
+
+static inline int
+__gthread_detach (__gthread_t __threadid)
+{
+  return __gthrw_pthread_detach (__threadid);
+}
+
+static inline int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+  return __gthrw_pthread_equal (__t1, __t2);
+}
+
+static inline __gthread_t
+__gthread_self (void)
+{
+  return __gthrw_pthread_self ();
+}
+
+static inline int
+__gthread_yield (void)
+{
+  return __gthrw_sched_yield ();
+}
+
+static inline int
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_once (__once, __func);
+  else
+    return -1;
+}
+
+static inline int
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
+{
+  return __gthrw_pthread_key_create (__key, __dtor);
+}
+
+static inline int
+__gthread_key_delete (__gthread_key_t __key)
+{
+  return __gthrw_pthread_key_delete (__key);
+}
+
+static inline void *
+__gthread_getspecific (__gthread_key_t __key)
+{
+  return __gthrw_pthread_getspecific (__key);
+}
+
+static inline int
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
+{
+  return __gthrw_pthread_setspecific (__key, __ptr);
+}
+
+static inline void
+__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    __gthrw_pthread_mutex_init (__mutex, __null);
+}
+
+static inline int
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_destroy (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_lock (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_trylock (__mutex);
+  else
+    return 0;
+}
+
+
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
+      const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+
+static inline int
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_unlock (__mutex);
+  else
+    return 0;
+}
+# 808 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_lock (__mutex);
+}
+
+static inline int
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_trylock (__mutex);
+}
+
+
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+         const __gthread_time_t *__abs_timeout)
+{
+  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
+}
+
+
+static inline int
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_unlock (__mutex);
+}
+
+static inline int
+__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_destroy (__mutex);
+}
+# 850 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_broadcast (__cond);
+}
+
+static inline int
+__gthread_cond_signal (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_signal (__cond);
+}
+
+static inline int
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
+{
+  return __gthrw_pthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
+     const __gthread_time_t *__abs_timeout)
+{
+  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
+}
+
+static inline int
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+          __gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_destroy (__gthread_cond_t* __cond)
+{
+  return __gthrw_pthread_cond_destroy (__cond);
+}
+# 149 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/gthr.h" 2 3
+
+
+#pragma GCC visibility pop
+# 36 "/usr/include/c++/10.2.0/ext/atomicity.h" 2 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3
+# 32 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/atomic_word.h" 3
+typedef int _Atomic_word;
+# 37 "/usr/include/c++/10.2.0/ext/atomicity.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  inline _Atomic_word
+  __attribute__((__always_inline__))
+  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
+  { return __atomic_fetch_add(__mem, __val, 4); }
+
+  inline void
+  __attribute__((__always_inline__))
+  __atomic_add(volatile _Atomic_word* __mem, int __val)
+  { __atomic_fetch_add(__mem, __val, 4); }
+# 64 "/usr/include/c++/10.2.0/ext/atomicity.h" 3
+  inline _Atomic_word
+  __attribute__((__always_inline__))
+  __exchange_and_add_single(_Atomic_word* __mem, int __val)
+  {
+    _Atomic_word __result = *__mem;
+    *__mem += __val;
+    return __result;
+  }
+
+  inline void
+  __attribute__((__always_inline__))
+  __atomic_add_single(_Atomic_word* __mem, int __val)
+  { *__mem += __val; }
+
+  inline _Atomic_word
+  __attribute__ ((__always_inline__))
+  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      return __exchange_and_add(__mem, __val);
+
+    return __exchange_and_add_single(__mem, __val);
+  }
+
+  inline void
+  __attribute__ ((__always_inline__))
+  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      {
+ __atomic_add(__mem, __val);
+ return;
+      }
+
+    __atomic_add_single(__mem, __val);
+  }
+
+
+}
+# 40 "/usr/include/c++/10.2.0/bits/basic_string.h" 2 3
+# 52 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+namespace __cxx11 {
+# 76 "/usr/include/c++/10.2.0/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);
+
+    protected:
+
+
+
+
+      typedef const_iterator __const_iterator;
+
+
+    private:
+# 150 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      struct _Alloc_hider : allocator_type
+      {
+
+
+
+
+ _Alloc_hider(pointer __dat, const _Alloc& __a)
+ : allocator_type(__a), _M_p(__dat) { }
+
+ _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
+ : allocator_type(std::move(__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:
+# 309 "/usr/include/c++/10.2.0/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, (void)++__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&);
+
+      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) noexcept
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_set_length(0); }
+
+
+
+
+
+      basic_string(const basic_string& __str)
+      : _M_dataplus(_M_local_data(),
+      _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
+      { _M_construct(__str._M_data(), __str._M_data() + __str.length()); }
+# 461 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string(const basic_string& __str, size_type __pos,
+     const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ const _CharT* __start = __str._M_data()
+   + __str._M_check(__pos, "basic_string::basic_string");
+ _M_construct(__start, __start + __str._M_limit(__pos, npos));
+      }
+
+
+
+
+
+
+
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n)
+      : _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));
+      }
+# 492 "/usr/include/c++/10.2.0/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));
+      }
+# 510 "/usr/include/c++/10.2.0/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); }
+# 525 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      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); }
+# 540 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
+      : _M_dataplus(_M_local_data(), __a)
+      { _M_construct(__n, __c); }
+# 552 "/usr/include/c++/10.2.0/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)
+      noexcept(_Alloc_traits::_S_always_equal())
+      : _M_dataplus(_M_local_data(), __a)
+      {
+ if (__str._M_is_local())
+   {
+     traits_type::copy(_M_local_buf, __str._M_local_buf,
+         _S_local_capacity + 1);
+     _M_length(__str.length());
+     __str._M_set_length(0);
+   }
+ else if (_Alloc_traits::_S_always_equal()
+     || __str.get_allocator() == __a)
+   {
+     _M_data(__str._M_data());
+     _M_length(__str.length());
+     _M_capacity(__str._M_allocated_capacity);
+     __str._M_data(__str._M_local_buf);
+     __str._M_set_length(0);
+   }
+ else
+   _M_construct(__str.begin(), __str.end());
+      }
+# 620 "/usr/include/c++/10.2.0/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); }
+# 657 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      ~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); }
+# 685 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      operator=(_CharT __c)
+      {
+ this->assign(1, __c);
+ return *this;
+      }
+# 702 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      operator=(basic_string&& __str)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+ if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
+     && !_Alloc_traits::_S_always_equal()
+     && _M_get_allocator() != __str._M_get_allocator())
+   {
+
+     _M_destroy(_M_allocated_capacity);
+     _M_data(_M_local_data());
+     _M_set_length(0);
+   }
+
+ std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());
+
+ if (__str._M_is_local())
+   {
+
+     if (__str.size())
+       this->_S_copy(_M_data(), __str._M_data(), __str.size());
+     _M_set_length(__str.size());
+   }
+ else if (_Alloc_traits::_S_propagate_on_move_assign()
+     || _Alloc_traits::_S_always_equal()
+     || _M_get_allocator() == __str._M_get_allocator())
+   {
+
+     pointer __data = nullptr;
+     size_type __capacity;
+     if (!_M_is_local())
+       {
+  if (_Alloc_traits::_S_always_equal())
+    {
+
+      __data = _M_data();
+      __capacity = _M_allocated_capacity;
+    }
+  else
+    _M_destroy(_M_allocated_capacity);
+       }
+
+     _M_data(__str._M_data());
+     _M_length(__str.length());
+     _M_capacity(__str._M_allocated_capacity);
+     if (__data)
+       {
+  __str._M_data(__data);
+  __str._M_capacity(__capacity);
+       }
+     else
+       __str._M_data(__str._M_local_buf);
+   }
+ else
+   assign(__str);
+ __str.clear();
+ return *this;
+      }
+
+
+
+
+
+      basic_string&
+      operator=(initializer_list<_CharT> __l)
+      {
+ this->assign(__l.begin(), __l.size());
+ return *this;
+      }
+# 796 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      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; }
+# 925 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      void
+      resize(size_type __n, _CharT __c);
+# 938 "/usr/include/c++/10.2.0/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;
+      }
+# 987 "/usr/include/c++/10.2.0/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; }
+# 1016 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      const_reference
+      operator[] (size_type __pos) const noexcept
+      {
+ ;
+ return _M_data()[__pos];
+      }
+# 1033 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      reference
+      operator[](size_type __pos)
+      {
+
+
+ ;
+
+ ;
+ return _M_data()[__pos];
+      }
+# 1054 "/usr/include/c++/10.2.0/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];
+      }
+# 1075 "/usr/include/c++/10.2.0/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);
+      }
+# 1138 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      operator+=(const basic_string& __str)
+      { return this->append(__str); }
+
+
+
+
+
+
+      basic_string&
+      operator+=(const _CharT* __s)
+      { return this->append(__s); }
+
+
+
+
+
+
+      basic_string&
+      operator+=(_CharT __c)
+      {
+ this->push_back(__c);
+ return *this;
+      }
+
+
+
+
+
+
+
+      basic_string&
+      operator+=(initializer_list<_CharT> __l)
+      { return this->append(__l.begin(), __l.size()); }
+# 1191 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      append(const basic_string& __str)
+      { return _M_append(__str._M_data(), __str.size()); }
+# 1208 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      append(const basic_string& __str, size_type __pos, size_type __n = npos)
+      { 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);
+      }
+# 1250 "/usr/include/c++/10.2.0/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()); }
+# 1274 "/usr/include/c++/10.2.0/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); }
+# 1319 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      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)
+      {
+
+ if (_Alloc_traits::_S_propagate_on_copy_assign())
+   {
+     if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
+  && _M_get_allocator() != __str._M_get_allocator())
+       {
+
+
+  if (__str.size() <= _S_local_capacity)
+    {
+      _M_destroy(_M_allocated_capacity);
+      _M_data(_M_local_data());
+      _M_set_length(0);
+    }
+  else
+    {
+      const auto __len = __str.size();
+      auto __alloc = __str._M_get_allocator();
+
+      auto __ptr = _Alloc_traits::allocate(__alloc, __len + 1);
+      _M_destroy(_M_allocated_capacity);
+      _M_data(__ptr);
+      _M_capacity(__len);
+      _M_set_length(__len);
+    }
+       }
+     std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
+   }
+
+ this->_M_assign(__str);
+ return *this;
+      }
+# 1379 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(basic_string&& __str)
+      noexcept(_Alloc_traits::_S_nothrow_move())
+      {
+
+
+ return *this = std::move(__str);
+      }
+# 1402 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(const basic_string& __str, size_type __pos, size_type __n = npos)
+      { return _M_replace(size_type(0), this->size(), __str._M_data()
+     + __str._M_check(__pos, "basic_string::assign"),
+     __str._M_limit(__pos, __n)); }
+# 1418 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s, size_type __n)
+      {
+ ;
+ return _M_replace(size_type(0), this->size(), __s, __n);
+      }
+# 1434 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s)
+      {
+ ;
+ return _M_replace(size_type(0), this->size(), __s,
+     traits_type::length(__s));
+      }
+# 1451 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      assign(size_type __n, _CharT __c)
+      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
+# 1464 "/usr/include/c++/10.2.0/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()); }
+# 1533 "/usr/include/c++/10.2.0/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);
+      }
+# 1575 "/usr/include/c++/10.2.0/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);
+ }
+# 1611 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      iterator
+      insert(const_iterator __p, initializer_list<_CharT> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+# 1638 "/usr/include/c++/10.2.0/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()); }
+# 1661 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str,
+      size_type __pos2, size_type __n = npos)
+      { return this->replace(__pos1, size_type(0), __str._M_data()
+        + __str._M_check(__pos2, "basic_string::insert"),
+        __str._M_limit(__pos2, __n)); }
+# 1684 "/usr/include/c++/10.2.0/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); }
+# 1703 "/usr/include/c++/10.2.0/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));
+      }
+# 1727 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, size_type __n, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
+         size_type(0), __n, __c); }
+# 1745 "/usr/include/c++/10.2.0/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);
+      }
+# 1805 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      erase(size_type __pos = 0, size_type __n = npos)
+      {
+ _M_check(__pos, "basic_string::erase");
+ if (__n == npos)
+   this->_M_set_length(__pos);
+ else if (__n != 0)
+   this->_M_erase(__pos, _M_limit(__pos, __n));
+ return *this;
+      }
+# 1824 "/usr/include/c++/10.2.0/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);
+      }
+# 1843 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      iterator
+      erase(__const_iterator __first, __const_iterator __last)
+      {
+
+                        ;
+        const size_type __pos = __first - begin();
+ if (__last == end())
+   this->_M_set_length(__pos);
+ else
+   this->_M_erase(__pos, __last - __first);
+ return iterator(this->_M_data() + __pos);
+      }
+
+
+
+
+
+
+
+      void
+      pop_back() noexcept
+      {
+ ;
+ _M_erase(size() - 1, 1);
+      }
+# 1887 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n, const basic_string& __str)
+      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
+# 1909 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2 = npos)
+      { return this->replace(__pos1, __n1, __str._M_data()
+        + __str._M_check(__pos2, "basic_string::replace"),
+        __str._M_limit(__pos2, __n2)); }
+# 1934 "/usr/include/c++/10.2.0/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);
+      }
+# 1959 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s)
+      {
+ ;
+ return this->replace(__pos, __n1, __s, traits_type::length(__s));
+      }
+# 1983 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
+         _M_limit(__pos, __n1), __n2, __c); }
+# 2001 "/usr/include/c++/10.2.0/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()); }
+# 2021 "/usr/include/c++/10.2.0/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);
+      }
+# 2043 "/usr/include/c++/10.2.0/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));
+      }
+# 2064 "/usr/include/c++/10.2.0/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);
+      }
+# 2089 "/usr/include/c++/10.2.0/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());
+ }
+# 2121 "/usr/include/c++/10.2.0/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);
+      }
+# 2180 "/usr/include/c++/10.2.0/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.size()); }
+# 2240 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+    private:
+      template<class _Integer>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _Integer __n, _Integer __val, __true_type)
+        { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }
+
+      template<class _InputIterator>
+ basic_string&
+ _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
+       _InputIterator __k1, _InputIterator __k2,
+       __false_type);
+
+      basic_string&
+      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+       _CharT __c);
+
+      basic_string&
+      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
+   const size_type __len2);
+
+      basic_string&
+      _M_append(const _CharT* __s, size_type __n);
+
+    public:
+# 2278 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
+# 2288 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      void
+      swap(basic_string& __s) noexcept;
+# 2298 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      const _CharT*
+      c_str() const noexcept
+      { return _M_data(); }
+# 2310 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      const _CharT*
+      data() const noexcept
+      { return _M_data(); }
+# 2329 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_get_allocator(); }
+# 2345 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+# 2359 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find(const basic_string& __str, size_type __pos = 0) const
+      noexcept
+      { return this->find(__str.data(), __pos, __str.size()); }
+# 2391 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const noexcept
+      {
+ ;
+ return this->find(__s, __pos, traits_type::length(__s));
+      }
+# 2408 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find(_CharT __c, size_type __pos = 0) const noexcept;
+# 2421 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      rfind(const basic_string& __str, size_type __pos = npos) const
+      noexcept
+      { return this->rfind(__str.data(), __pos, __str.size()); }
+# 2455 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+# 2469 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->rfind(__s, __pos, traits_type::length(__s));
+      }
+# 2486 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const noexcept;
+# 2500 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_of(const basic_string& __str, size_type __pos = 0) const
+      noexcept
+      { return this->find_first_of(__str.data(), __pos, __str.size()); }
+# 2535 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+# 2549 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos = 0) const
+      noexcept
+      {
+ ;
+ return this->find_first_of(__s, __pos, traits_type::length(__s));
+      }
+# 2569 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
+      { return this->find(__c, __pos); }
+# 2584 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_of(const basic_string& __str, size_type __pos = npos) const
+      noexcept
+      { return this->find_last_of(__str.data(), __pos, __str.size()); }
+# 2619 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+      noexcept;
+# 2633 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos = npos) const
+      noexcept
+      {
+ ;
+ return this->find_last_of(__s, __pos, traits_type::length(__s));
+      }
+# 2653 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
+      { return this->rfind(__c, __pos); }
+# 2667 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
+      noexcept
+      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
+# 2702 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos,
+   size_type __n) const noexcept;
+# 2716 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+      noexcept
+      {
+ ;
+ return this->find_first_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2734 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const
+      noexcept;
+# 2749 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
+      noexcept
+      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
+# 2784 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos,
+         size_type __n) const noexcept;
+# 2798 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+      noexcept
+      {
+ ;
+ return this->find_last_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2816 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const
+      noexcept;
+# 2832 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      basic_string
+      substr(size_type __pos = 0, size_type __n = npos) const
+      { return basic_string(*this,
+       _M_check(__pos, "basic_string::substr"), __n); }
+# 2851 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(const basic_string& __str) const
+      {
+ const size_type __size = this->size();
+ const size_type __osize = __str.size();
+ const size_type __len = std::min(__size, __osize);
+
+ int __r = traits_type::compare(_M_data(), __str.data(), __len);
+ if (!__r)
+   __r = _S_compare(__size, __osize);
+ return __r;
+      }
+# 2944 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n, const basic_string& __str) const;
+# 2970 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2 = npos) const;
+# 2988 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(const _CharT* __s) const noexcept;
+# 3012 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
+# 3039 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2) const;
+# 3070 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+      template<typename, typename, typename> friend class basic_stringbuf;
+    };
+}
+# 6020 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str(__lhs);
+      __str.append(__size_type(1), __rhs);
+      return __str;
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return std::move(__lhs.append(__rhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    { return std::move(__rhs.insert(0, __lhs)); }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
+       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
+    {
+
+      using _Alloc_traits = allocator_traits<_Alloc>;
+      bool __use_rhs = false;
+      if (typename _Alloc_traits::is_always_equal{})
+ __use_rhs = true;
+      else if (__lhs.get_allocator() == __rhs.get_allocator())
+ __use_rhs = true;
+      if (__use_rhs)
+
+ {
+   const auto __size = __lhs.size() + __rhs.size();
+   if (__size > __lhs.capacity() && __size <= __rhs.capacity())
+     return std::move(__rhs.insert(0, __lhs));
+ }
+      return 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)); }
+# 6151 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { 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) noexcept
+    { 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 basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+# 6214 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  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; }
+# 6227 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { 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); }
+# 6265 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { 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; }
+# 6303 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { 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; }
+# 6341 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { 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; }
+# 6379 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept
+    { 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; }
+# 6418 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline void
+    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
+  basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    noexcept(noexcept(__lhs.swap(__rhs)))
+    { __lhs.swap(__rhs); }
+# 6438 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is,
+        basic_string<_CharT, _Traits, _Alloc>& __str);
+
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
+# 6456 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+        const basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+
+
+      return __ostream_insert(__os, __str.data(), __str.size());
+    }
+# 6479 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
+# 6496 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return 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 "/usr/include/c++/10.2.0/ext/string_conversions.h" 1 3
+# 32 "/usr/include/c++/10.2.0/ext/string_conversions.h" 3
+       
+# 33 "/usr/include/c++/10.2.0/ext/string_conversions.h" 3
+# 41 "/usr/include/c++/10.2.0/ext/string_conversions.h" 3
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 75 "/usr/include/c++/10.2.0/cstdlib" 3
+# 1 "/usr/include/stdlib.h" 1 3 4
+# 25 "/usr/include/stdlib.h" 3 4
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 26 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 32 "/usr/include/stdlib.h" 2 3 4
+
+extern "C" {
+
+
+
+
+
+# 1 "/usr/include/bits/waitflags.h" 1 3 4
+# 40 "/usr/include/stdlib.h" 2 3 4
+# 1 "/usr/include/bits/waitstatus.h" 1 3 4
+# 41 "/usr/include/stdlib.h" 2 3 4
+# 58 "/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;
+# 97 "/usr/include/stdlib.h" 3 4
+extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ;
+
+
+
+extern double atof (const char *__nptr)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern int atoi (const char *__nptr)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+extern long int atol (const char *__nptr)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+__extension__ extern long long int atoll (const char *__nptr)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern double strtod (const char *__restrict __nptr,
+        char **__restrict __endptr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern float strtof (const char *__restrict __nptr,
+       char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+extern long double strtold (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+# 140 "/usr/include/stdlib.h" 3 4
+extern _Float32 strtof32 (const char *__restrict __nptr,
+     char **__restrict __endptr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern _Float64 strtof64 (const char *__restrict __nptr,
+     char **__restrict __endptr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern _Float128 strtof128 (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern _Float32x strtof32x (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern _Float64x strtof64x (const char *__restrict __nptr,
+       char **__restrict __endptr)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+# 176 "/usr/include/stdlib.h" 3 4
+extern long int strtol (const char *__restrict __nptr,
+   char **__restrict __endptr, int __base)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+extern unsigned long int strtoul (const char *__restrict __nptr,
+      char **__restrict __endptr, int __base)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+__extension__
+extern long long int strtoq (const char *__restrict __nptr,
+        char **__restrict __endptr, int __base)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtouq (const char *__restrict __nptr,
+           char **__restrict __endptr, int __base)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+__extension__
+extern long long int strtoll (const char *__restrict __nptr,
+         char **__restrict __endptr, int __base)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+__extension__
+extern unsigned long long int strtoull (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int strfromd (char *__dest, size_t __size, const char *__format,
+       double __f)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+
+extern int strfromf (char *__dest, size_t __size, const char *__format,
+       float __f)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+
+extern int strfroml (char *__dest, size_t __size, const char *__format,
+       long double __f)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+# 232 "/usr/include/stdlib.h" 3 4
+extern int strfromf32 (char *__dest, size_t __size, const char * __format,
+         _Float32 __f)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+
+
+
+extern int strfromf64 (char *__dest, size_t __size, const char * __format,
+         _Float64 __f)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+
+
+
+extern int strfromf128 (char *__dest, size_t __size, const char * __format,
+   _Float128 __f)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+
+
+
+extern int strfromf32x (char *__dest, size_t __size, const char * __format,
+   _Float32x __f)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+
+
+
+extern int strfromf64x (char *__dest, size_t __size, const char * __format,
+   _Float64x __f)
+     noexcept (true) __attribute__ ((__nonnull__ (3)));
+# 274 "/usr/include/stdlib.h" 3 4
+extern long int strtol_l (const char *__restrict __nptr,
+     char **__restrict __endptr, int __base,
+     locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4)));
+
+extern unsigned long int strtoul_l (const char *__restrict __nptr,
+        char **__restrict __endptr,
+        int __base, locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 4)));
+
+__extension__
+extern long long int strtoll_l (const char *__restrict __nptr,
+    char **__restrict __endptr, int __base,
+    locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 4)));
+
+__extension__
+extern unsigned long long int strtoull_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       int __base, locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 4)));
+
+extern double strtod_l (const char *__restrict __nptr,
+   char **__restrict __endptr, locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+extern float strtof_l (const char *__restrict __nptr,
+         char **__restrict __endptr, locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+extern long double strtold_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+# 316 "/usr/include/stdlib.h" 3 4
+extern _Float32 strtof32_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern _Float64 strtof64_l (const char *__restrict __nptr,
+       char **__restrict __endptr,
+       locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern _Float128 strtof128_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern _Float32x strtof32x_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern _Float64x strtof64x_l (const char *__restrict __nptr,
+         char **__restrict __endptr,
+         locale_t __loc)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
+# 385 "/usr/include/stdlib.h" 3 4
+extern char *l64a (long int __n) noexcept (true) ;
+
+
+extern long int a64l (const char *__s)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+# 1 "/usr/include/sys/types.h" 1 3 4
+# 27 "/usr/include/sys/types.h" 3 4
+extern "C" {
+
+
+
+
+
+typedef __u_char u_char;
+typedef __u_short u_short;
+typedef __u_int u_int;
+typedef __u_long u_long;
+typedef __quad_t quad_t;
+typedef __u_quad_t u_quad_t;
+typedef __fsid_t fsid_t;
+
+
+typedef __loff_t loff_t;
+
+
+
+
+typedef __ino_t ino_t;
+
+
+
+
+
+
+typedef __ino64_t ino64_t;
+
+
+
+
+typedef __dev_t dev_t;
+
+
+
+
+typedef __gid_t gid_t;
+
+
+
+
+typedef __mode_t mode_t;
+
+
+
+
+typedef __nlink_t nlink_t;
+
+
+
+
+typedef __uid_t uid_t;
+
+
+
+
+
+typedef __off_t off_t;
+
+
+
+
+
+
+typedef __off64_t off64_t;
+# 103 "/usr/include/sys/types.h" 3 4
+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;
+# 134 "/usr/include/sys/types.h" 3 4
+typedef __useconds_t useconds_t;
+
+
+
+typedef __suseconds_t suseconds_t;
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 145 "/usr/include/sys/types.h" 2 3 4
+
+
+
+typedef unsigned long int ulong;
+typedef unsigned short int ushort;
+typedef unsigned int uint;
+
+
+
+
+
+
+
+typedef __uint8_t u_int8_t;
+typedef __uint16_t u_int16_t;
+typedef __uint32_t u_int32_t;
+typedef __uint64_t u_int64_t;
+
+
+typedef int register_t __attribute__ ((__mode__ (__word__)));
+# 176 "/usr/include/sys/types.h" 3 4
+# 1 "/usr/include/endian.h" 1 3 4
+# 35 "/usr/include/endian.h" 3 4
+# 1 "/usr/include/bits/byteswap.h" 1 3 4
+# 33 "/usr/include/bits/byteswap.h" 3 4
+static __inline __uint16_t
+__bswap_16 (__uint16_t __bsx)
+{
+
+  return __builtin_bswap16 (__bsx);
+
+
+
+}
+
+
+
+
+
+
+static __inline __uint32_t
+__bswap_32 (__uint32_t __bsx)
+{
+
+  return __builtin_bswap32 (__bsx);
+
+
+
+}
+# 69 "/usr/include/bits/byteswap.h" 3 4
+__extension__ static __inline __uint64_t
+__bswap_64 (__uint64_t __bsx)
+{
+
+  return __builtin_bswap64 (__bsx);
+
+
+
+}
+# 36 "/usr/include/endian.h" 2 3 4
+# 1 "/usr/include/bits/uintn-identity.h" 1 3 4
+# 32 "/usr/include/bits/uintn-identity.h" 3 4
+static __inline __uint16_t
+__uint16_identity (__uint16_t __x)
+{
+  return __x;
+}
+
+static __inline __uint32_t
+__uint32_identity (__uint32_t __x)
+{
+  return __x;
+}
+
+static __inline __uint64_t
+__uint64_identity (__uint64_t __x)
+{
+  return __x;
+}
+# 37 "/usr/include/endian.h" 2 3 4
+# 177 "/usr/include/sys/types.h" 2 3 4
+
+
+# 1 "/usr/include/sys/select.h" 1 3 4
+# 30 "/usr/include/sys/select.h" 3 4
+# 1 "/usr/include/bits/select.h" 1 3 4
+# 31 "/usr/include/sys/select.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4
+
+
+
+
+
+
+typedef __sigset_t sigset_t;
+# 34 "/usr/include/sys/select.h" 2 3 4
+# 49 "/usr/include/sys/select.h" 3 4
+typedef long int __fd_mask;
+# 59 "/usr/include/sys/select.h" 3 4
+typedef struct
+  {
+
+
+
+    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
+
+
+
+
+
+  } fd_set;
+
+
+
+
+
+
+typedef __fd_mask fd_mask;
+# 91 "/usr/include/sys/select.h" 3 4
+extern "C" {
+# 101 "/usr/include/sys/select.h" 3 4
+extern int select (int __nfds, fd_set *__restrict __readfds,
+     fd_set *__restrict __writefds,
+     fd_set *__restrict __exceptfds,
+     struct timeval *__restrict __timeout);
+# 113 "/usr/include/sys/select.h" 3 4
+extern int pselect (int __nfds, fd_set *__restrict __readfds,
+      fd_set *__restrict __writefds,
+      fd_set *__restrict __exceptfds,
+      const struct timespec *__restrict __timeout,
+      const __sigset_t *__restrict __sigmask);
+# 126 "/usr/include/sys/select.h" 3 4
+}
+# 180 "/usr/include/sys/types.h" 2 3 4
+
+
+
+
+
+typedef __blksize_t blksize_t;
+
+
+
+
+
+
+typedef __blkcnt_t blkcnt_t;
+
+
+
+typedef __fsblkcnt_t fsblkcnt_t;
+
+
+
+typedef __fsfilcnt_t fsfilcnt_t;
+# 219 "/usr/include/sys/types.h" 3 4
+typedef __blkcnt64_t blkcnt64_t;
+typedef __fsblkcnt64_t fsblkcnt64_t;
+typedef __fsfilcnt64_t fsfilcnt64_t;
+# 230 "/usr/include/sys/types.h" 3 4
+}
+# 395 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+
+extern long int random (void) noexcept (true);
+
+
+extern void srandom (unsigned int __seed) noexcept (true);
+
+
+
+
+
+extern char *initstate (unsigned int __seed, char *__statebuf,
+   size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern char *setstate (char *__statebuf) noexcept (true) __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) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int srandom_r (unsigned int __seed, struct random_data *__buf)
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
+   size_t __statelen,
+   struct random_data *__restrict __buf)
+     noexcept (true) __attribute__ ((__nonnull__ (2, 4)));
+
+extern int setstate_r (char *__restrict __statebuf,
+         struct random_data *__restrict __buf)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern int rand (void) noexcept (true);
+
+extern void srand (unsigned int __seed) noexcept (true);
+
+
+
+extern int rand_r (unsigned int *__seed) noexcept (true);
+
+
+
+
+
+
+
+extern double drand48 (void) noexcept (true);
+extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern long int lrand48 (void) noexcept (true);
+extern long int nrand48 (unsigned short int __xsubi[3])
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern long int mrand48 (void) noexcept (true);
+extern long int jrand48 (unsigned short int __xsubi[3])
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern void srand48 (long int __seedval) noexcept (true);
+extern unsigned short int *seed48 (unsigned short int __seed16v[3])
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+extern void lcong48 (unsigned short int __param[7]) noexcept (true) __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) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+extern int erand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int lrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+extern int nrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int mrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+extern int jrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+extern int seed48_r (unsigned short int __seed16v[3],
+       struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int lcong48_r (unsigned short int __param[7],
+        struct drand48_data *__buffer)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__))
+     __attribute__ ((__alloc_size__ (1))) ;
+
+extern void *calloc (size_t __nmemb, size_t __size)
+     noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (1, 2))) ;
+
+
+
+
+
+
+extern void *realloc (void *__ptr, size_t __size)
+     noexcept (true) __attribute__ ((__warn_unused_result__)) __attribute__ ((__alloc_size__ (2)));
+
+
+
+
+
+
+
+extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
+     noexcept (true) __attribute__ ((__warn_unused_result__))
+     __attribute__ ((__alloc_size__ (2, 3)));
+
+
+
+extern void free (void *__ptr) noexcept (true);
+
+
+# 1 "/usr/include/alloca.h" 1 3 4
+# 24 "/usr/include/alloca.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 25 "/usr/include/alloca.h" 2 3 4
+
+extern "C" {
+
+
+
+
+
+extern void *alloca (size_t __size) noexcept (true);
+
+
+
+
+
+}
+# 569 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__))
+     __attribute__ ((__alloc_size__ (1))) ;
+
+
+
+
+extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+extern void *aligned_alloc (size_t __alignment, size_t __size)
+     noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_size__ (2))) ;
+
+
+
+extern void abort (void) noexcept (true) __attribute__ ((__noreturn__));
+
+
+
+extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern "C++" int at_quick_exit (void (*__func) (void))
+     noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
+# 610 "/usr/include/stdlib.h" 3 4
+extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__));
+
+
+
+
+
+extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__));
+
+
+
+
+
+extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__));
+
+
+
+
+extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+extern char *secure_getenv (const char *__name)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int setenv (const char *__name, const char *__value, int __replace)
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int clearenv (void) noexcept (true);
+# 675 "/usr/include/stdlib.h" 3 4
+extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1)));
+# 688 "/usr/include/stdlib.h" 3 4
+extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
+# 698 "/usr/include/stdlib.h" 3 4
+extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
+# 710 "/usr/include/stdlib.h" 3 4
+extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
+# 720 "/usr/include/stdlib.h" 3 4
+extern int mkstemps64 (char *__template, int __suffixlen)
+     __attribute__ ((__nonnull__ (1))) ;
+# 731 "/usr/include/stdlib.h" 3 4
+extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+# 742 "/usr/include/stdlib.h" 3 4
+extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+# 752 "/usr/include/stdlib.h" 3 4
+extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
+# 762 "/usr/include/stdlib.h" 3 4
+extern int mkostemps (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+# 774 "/usr/include/stdlib.h" 3 4
+extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) ;
+# 784 "/usr/include/stdlib.h" 3 4
+extern int system (const char *__command) ;
+
+
+
+
+
+extern char *canonicalize_file_name (const char *__name)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+# 800 "/usr/include/stdlib.h" 3 4
+extern char *realpath (const char *__restrict __name,
+         char *__restrict __resolved) noexcept (true) ;
+
+
+
+
+
+
+typedef int (*__compar_fn_t) (const void *, const void *);
+
+
+typedef __compar_fn_t comparison_fn_t;
+
+
+
+typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
+
+
+
+
+extern void *bsearch (const void *__key, const void *__base,
+        size_t __nmemb, size_t __size, __compar_fn_t __compar)
+     __attribute__ ((__nonnull__ (1, 2, 5))) ;
+
+
+
+
+
+
+
+extern void qsort (void *__base, size_t __nmemb, size_t __size,
+     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
+
+extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
+       __compar_d_fn_t __compar, void *__arg)
+  __attribute__ ((__nonnull__ (1, 4)));
+
+
+
+
+extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ;
+extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ;
+
+
+__extension__ extern long long int llabs (long long int __x)
+     noexcept (true) __attribute__ ((__const__)) ;
+
+
+
+
+
+
+extern div_t div (int __numer, int __denom)
+     noexcept (true) __attribute__ ((__const__)) ;
+extern ldiv_t ldiv (long int __numer, long int __denom)
+     noexcept (true) __attribute__ ((__const__)) ;
+
+
+__extension__ extern lldiv_t lldiv (long long int __numer,
+        long long int __denom)
+     noexcept (true) __attribute__ ((__const__)) ;
+# 872 "/usr/include/stdlib.h" 3 4
+extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;
+
+
+
+
+extern char *gcvt (double __value, int __ndigit, char *__buf)
+     noexcept (true) __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern char *qecvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qfcvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;
+extern char *qgcvt (long double __value, int __ndigit, char *__buf)
+     noexcept (true) __attribute__ ((__nonnull__ (3))) ;
+
+
+
+
+extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) noexcept (true) __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) noexcept (true) __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)
+     noexcept (true) __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)
+     noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5)));
+
+
+
+
+
+extern int mblen (const char *__s, size_t __n) noexcept (true);
+
+
+extern int mbtowc (wchar_t *__restrict __pwc,
+     const char *__restrict __s, size_t __n) noexcept (true);
+
+
+extern int wctomb (char *__s, wchar_t __wchar) noexcept (true);
+
+
+
+extern size_t mbstowcs (wchar_t *__restrict __pwcs,
+   const char *__restrict __s, size_t __n) noexcept (true)
+    __attribute__ ((__access__ (__read_only__, 2)));
+
+extern size_t wcstombs (char *__restrict __s,
+   const wchar_t *__restrict __pwcs, size_t __n)
+     noexcept (true)
+  __attribute__ ((__access__ (__write_only__, 1, 3))) __attribute__ ((__access__ (__read_only__, 2)));
+
+
+
+
+
+
+extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+# 958 "/usr/include/stdlib.h" 3 4
+extern int getsubopt (char **__restrict __optionp,
+        char *const *__restrict __tokens,
+        char **__restrict __valuep)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ;
+
+
+
+
+
+
+
+extern int posix_openpt (int __oflag) ;
+
+
+
+
+
+
+
+extern int grantpt (int __fd) noexcept (true);
+
+
+
+extern int unlockpt (int __fd) noexcept (true);
+
+
+
+
+extern char *ptsname (int __fd) noexcept (true) ;
+
+
+
+
+
+
+extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
+     noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+extern int getpt (void);
+
+
+
+
+
+
+extern int getloadavg (double __loadavg[], int __nelem)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+# 1014 "/usr/include/stdlib.h" 3 4
+# 1 "/usr/include/bits/stdlib-float.h" 1 3 4
+# 1015 "/usr/include/stdlib.h" 2 3 4
+# 1026 "/usr/include/stdlib.h" 3 4
+}
+# 76 "/usr/include/c++/10.2.0/cstdlib" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/std_abs.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/std_abs.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/std_abs.h" 3
+# 46 "/usr/include/c++/10.2.0/bits/std_abs.h" 3
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::abs;
+
+
+  inline long
+  abs(long __i) { return __builtin_labs(__i); }
+
+
+
+  inline long long
+  abs(long long __x) { return __builtin_llabs (__x); }
+# 70 "/usr/include/c++/10.2.0/bits/std_abs.h" 3
+  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); }
+
+
+
+  inline constexpr __int128
+  abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
+# 101 "/usr/include/c++/10.2.0/bits/std_abs.h" 3
+  inline constexpr
+  __float128
+  abs(__float128 __x)
+  { return __x < 0 ? -__x : __x; }
+
+
+
+}
+}
+# 78 "/usr/include/c++/10.2.0/cstdlib" 2 3
+# 121 "/usr/include/c++/10.2.0/cstdlib" 3
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::div_t;
+  using ::ldiv_t;
+
+  using ::abort;
+
+
+
+  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 ldiv_t
+  div(long __i, long __j) { return ldiv(__i, __j); }
+
+
+
+
+}
+# 195 "/usr/include/c++/10.2.0/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;
+# 227 "/usr/include/c++/10.2.0/cstdlib" 3
+  using ::atoll;
+  using ::strtoll;
+  using ::strtoull;
+
+  using ::strtof;
+  using ::strtold;
+
+
+}
+
+namespace std
+{
+
+  using ::__gnu_cxx::lldiv_t;
+
+  using ::__gnu_cxx::_Exit;
+
+  using ::__gnu_cxx::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;
+}
+
+
+
+}
+# 42 "/usr/include/c++/10.2.0/ext/string_conversions.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cwchar" 1 3
+# 39 "/usr/include/c++/10.2.0/cwchar" 3
+       
+# 40 "/usr/include/c++/10.2.0/cwchar" 3
+# 43 "/usr/include/c++/10.2.0/ext/string_conversions.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdio" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+
+
+# 1 "/usr/include/stdio.h" 1 3 4
+# 27 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 28 "/usr/include/stdio.h" 2 3 4
+
+extern "C" {
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 34 "/usr/include/stdio.h" 2 3 4
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 1 3 4
+# 37 "/usr/include/stdio.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4
+# 10 "/usr/include/bits/types/__fpos_t.h" 3 4
+typedef struct _G_fpos_t
+{
+  __off_t __pos;
+  __mbstate_t __state;
+} __fpos_t;
+# 40 "/usr/include/stdio.h" 2 3 4
+# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4
+# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4
+typedef struct _G_fpos64_t
+{
+  __off64_t __pos;
+  __mbstate_t __state;
+} __fpos64_t;
+# 41 "/usr/include/stdio.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4
+# 35 "/usr/include/bits/types/struct_FILE.h" 3 4
+struct _IO_FILE;
+struct _IO_marker;
+struct _IO_codecvt;
+struct _IO_wide_data;
+
+
+
+
+typedef void _IO_lock_t;
+
+
+
+
+
+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;
+
+
+
+
+
+
+
+  __off64_t _offset;
+
+  struct _IO_codecvt *_codecvt;
+  struct _IO_wide_data *_wide_data;
+  struct _IO_FILE *_freeres_list;
+  void *_freeres_buf;
+  size_t __pad5;
+  int _mode;
+
+  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
+};
+# 44 "/usr/include/stdio.h" 2 3 4
+
+
+# 1 "/usr/include/bits/types/cookie_io_functions_t.h" 1 3 4
+# 27 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4
+typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf,
+                                          size_t __nbytes);
+
+
+
+
+
+
+
+typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf,
+                                           size_t __nbytes);
+
+
+
+
+
+
+
+typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w);
+
+
+typedef int cookie_close_function_t (void *__cookie);
+
+
+
+
+
+
+typedef struct _IO_cookie_io_functions_t
+{
+  cookie_read_function_t *read;
+  cookie_write_function_t *write;
+  cookie_seek_function_t *seek;
+  cookie_close_function_t *close;
+} cookie_io_functions_t;
+# 47 "/usr/include/stdio.h" 2 3 4
+
+
+
+
+
+typedef __gnuc_va_list va_list;
+# 84 "/usr/include/stdio.h" 3 4
+typedef __fpos_t fpos_t;
+
+
+
+
+typedef __fpos64_t fpos64_t;
+# 133 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
+# 134 "/usr/include/stdio.h" 2 3 4
+
+
+
+extern FILE *stdin;
+extern FILE *stdout;
+extern FILE *stderr;
+
+
+
+
+
+
+extern int remove (const char *__filename) noexcept (true);
+
+extern int rename (const char *__old, const char *__new) noexcept (true);
+
+
+
+extern int renameat (int __oldfd, const char *__old, int __newfd,
+       const char *__new) noexcept (true);
+# 164 "/usr/include/stdio.h" 3 4
+extern int renameat2 (int __oldfd, const char *__old, int __newfd,
+        const char *__new, unsigned int __flags) noexcept (true);
+
+
+
+
+
+
+
+extern FILE *tmpfile (void) ;
+# 183 "/usr/include/stdio.h" 3 4
+extern FILE *tmpfile64 (void) ;
+
+
+
+extern char *tmpnam (char *__s) noexcept (true) ;
+
+
+
+
+extern char *tmpnam_r (char *__s) noexcept (true) ;
+# 204 "/usr/include/stdio.h" 3 4
+extern char *tempnam (const char *__dir, const char *__pfx)
+     noexcept (true) __attribute__ ((__malloc__)) ;
+
+
+
+
+
+
+
+extern int fclose (FILE *__stream);
+
+
+
+
+extern int fflush (FILE *__stream);
+# 227 "/usr/include/stdio.h" 3 4
+extern int fflush_unlocked (FILE *__stream);
+# 237 "/usr/include/stdio.h" 3 4
+extern int fcloseall (void);
+# 246 "/usr/include/stdio.h" 3 4
+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) ;
+# 270 "/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) noexcept (true) ;
+
+
+
+
+
+extern FILE *fopencookie (void *__restrict __magic_cookie,
+     const char *__restrict __modes,
+     cookie_io_functions_t __io_funcs) noexcept (true) ;
+
+
+
+
+extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
+  noexcept (true) ;
+
+
+
+
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) ;
+
+
+
+
+
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true);
+
+
+
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+      int __modes, size_t __n) noexcept (true);
+
+
+
+
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+         size_t __size) noexcept (true);
+
+
+extern void setlinebuf (FILE *__stream) noexcept (true);
+
+
+
+
+
+
+
+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, ...) noexcept (true);
+
+
+
+
+
+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) noexcept (true);
+
+
+
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+       const char *__restrict __format, ...)
+     noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4)));
+
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+        const char *__restrict __format, __gnuc_va_list __arg)
+     noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0)));
+
+
+
+
+
+extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
+        __gnuc_va_list __arg)
+     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ;
+extern int __asprintf (char **__restrict __ptr,
+         const char *__restrict __fmt, ...)
+     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ;
+extern int asprintf (char **__restrict __ptr,
+       const char *__restrict __fmt, ...)
+     noexcept (true) __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, ...) noexcept (true);
+# 410 "/usr/include/stdio.h" 3 4
+extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc99_fscanf")
+
+                               ;
+extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc99_scanf")
+                              ;
+extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc99_sscanf")
+
+                      ;
+# 435 "/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)
+     noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0)));
+
+
+
+
+
+extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vfscanf")
+
+
+
+     __attribute__ ((__format__ (__scanf__, 2, 0))) ;
+extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc99_vscanf")
+
+     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
+extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc99_vsscanf")
+
+
+
+     __attribute__ ((__format__ (__scanf__, 2, 0)));
+# 489 "/usr/include/stdio.h" 3 4
+extern int fgetc (FILE *__stream);
+extern int getc (FILE *__stream);
+
+
+
+
+
+extern int getchar (void);
+
+
+
+
+
+
+extern int getc_unlocked (FILE *__stream);
+extern int getchar_unlocked (void);
+# 514 "/usr/include/stdio.h" 3 4
+extern int fgetc_unlocked (FILE *__stream);
+# 525 "/usr/include/stdio.h" 3 4
+extern int fputc (int __c, FILE *__stream);
+extern int putc (int __c, FILE *__stream);
+
+
+
+
+
+extern int putchar (int __c);
+# 541 "/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)
+     __attribute__ ((__access__ (__write_only__, 1, 2)));
+# 591 "/usr/include/stdio.h" 3 4
+extern char *fgets_unlocked (char *__restrict __s, int __n,
+        FILE *__restrict __stream)
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+# 608 "/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);
+# 667 "/usr/include/stdio.h" 3 4
+extern int fputs_unlocked (const char *__restrict __s,
+      FILE *__restrict __stream);
+# 678 "/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);
+# 712 "/usr/include/stdio.h" 3 4
+extern int fseeko (FILE *__stream, __off_t __off, int __whence);
+
+
+
+
+extern __off_t ftello (FILE *__stream) ;
+# 736 "/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);
+# 755 "/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) noexcept (true);
+
+extern int feof (FILE *__stream) noexcept (true) ;
+
+extern int ferror (FILE *__stream) noexcept (true) ;
+
+
+
+extern void clearerr_unlocked (FILE *__stream) noexcept (true);
+extern int feof_unlocked (FILE *__stream) noexcept (true) ;
+extern int ferror_unlocked (FILE *__stream) noexcept (true) ;
+
+
+
+
+
+
+
+extern void perror (const char *__s);
+
+
+
+
+extern int fileno (FILE *__stream) noexcept (true) ;
+
+
+
+
+extern int fileno_unlocked (FILE *__stream) noexcept (true) ;
+# 799 "/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) noexcept (true);
+
+
+
+
+
+extern char *cuserid (char *__s);
+
+
+
+
+struct obstack;
+
+
+extern int obstack_printf (struct obstack *__restrict __obstack,
+      const char *__restrict __format, ...)
+     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int obstack_vprintf (struct obstack *__restrict __obstack,
+       const char *__restrict __format,
+       __gnuc_va_list __args)
+     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0)));
+
+
+
+
+
+
+
+extern void flockfile (FILE *__stream) noexcept (true);
+
+
+
+extern int ftrylockfile (FILE *__stream) noexcept (true) ;
+
+
+extern void funlockfile (FILE *__stream) noexcept (true);
+# 857 "/usr/include/stdio.h" 3 4
+extern int __uflow (FILE *);
+extern int __overflow (FILE *, int);
+# 874 "/usr/include/stdio.h" 3 4
+}
+# 43 "/usr/include/c++/10.2.0/cstdio" 2 3
+# 96 "/usr/include/c++/10.2.0/cstdio" 3
+namespace std
+{
+  using ::FILE;
+  using ::fpos_t;
+
+  using ::clearerr;
+  using ::fclose;
+  using ::feof;
+  using ::ferror;
+  using ::fflush;
+  using ::fgetc;
+  using ::fgetpos;
+  using ::fgets;
+  using ::fopen;
+  using ::fprintf;
+  using ::fputc;
+  using ::fputs;
+  using ::fread;
+  using ::freopen;
+  using ::fscanf;
+  using ::fseek;
+  using ::fsetpos;
+  using ::ftell;
+  using ::fwrite;
+  using ::getc;
+  using ::getchar;
+
+
+
+
+  using ::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 "/usr/include/c++/10.2.0/cstdio" 3
+namespace __gnu_cxx
+{
+# 175 "/usr/include/c++/10.2.0/cstdio" 3
+  using ::snprintf;
+  using ::vfscanf;
+  using ::vscanf;
+  using ::vsnprintf;
+  using ::vsscanf;
+
+}
+
+namespace std
+{
+  using ::__gnu_cxx::snprintf;
+  using ::__gnu_cxx::vfscanf;
+  using ::__gnu_cxx::vscanf;
+  using ::__gnu_cxx::vsnprintf;
+  using ::__gnu_cxx::vsscanf;
+}
+# 44 "/usr/include/c++/10.2.0/ext/string_conversions.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cerrno" 1 3
+# 39 "/usr/include/c++/10.2.0/cerrno" 3
+       
+# 40 "/usr/include/c++/10.2.0/cerrno" 3
+
+
+# 1 "/usr/include/errno.h" 1 3 4
+# 28 "/usr/include/errno.h" 3 4
+# 1 "/usr/include/bits/errno.h" 1 3 4
+# 26 "/usr/include/bits/errno.h" 3 4
+# 1 "/usr/include/linux/errno.h" 1 3 4
+# 1 "/usr/include/asm/errno.h" 1 3 4
+# 1 "/usr/include/asm-generic/errno.h" 1 3 4
+
+
+
+
+# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
+# 6 "/usr/include/asm-generic/errno.h" 2 3 4
+# 2 "/usr/include/asm/errno.h" 2 3 4
+# 2 "/usr/include/linux/errno.h" 2 3 4
+# 27 "/usr/include/bits/errno.h" 2 3 4
+# 29 "/usr/include/errno.h" 2 3 4
+
+
+
+
+
+extern "C" {
+
+
+extern int *__errno_location (void) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+
+
+
+extern char *program_invocation_name;
+extern char *program_invocation_short_name;
+
+# 1 "/usr/include/bits/types/error_t.h" 1 3 4
+# 22 "/usr/include/bits/types/error_t.h" 3 4
+typedef int error_t;
+# 49 "/usr/include/errno.h" 2 3 4
+
+
+
+}
+# 43 "/usr/include/c++/10.2.0/cerrno" 2 3
+# 45 "/usr/include/c++/10.2.0/ext/string_conversions.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _TRet, typename _Ret = _TRet, typename _CharT,
+    typename... _Base>
+    _Ret
+    __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
+    const char* __name, const _CharT* __str, std::size_t* __idx,
+    _Base... __base)
+    {
+      _Ret __ret;
+
+      _CharT* __endptr;
+
+      struct _Save_errno {
+ _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; }
+ ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; }
+ int _M_errno;
+      } const __save_errno;
+
+      struct _Range_chk {
+   static bool
+   _S_chk(_TRet, std::false_type) { return false; }
+
+   static bool
+   _S_chk(_TRet __val, std::true_type)
+   {
+     return __val < _TRet(__numeric_traits<int>::__min)
+       || __val > _TRet(__numeric_traits<int>::__max);
+   }
+      };
+
+      const _TRet __tmp = __convf(__str, &__endptr, __base...);
+
+      if (__endptr == __str)
+ std::__throw_invalid_argument(__name);
+      else if ((*__errno_location ()) == 34
+   || _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{}))
+ 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);
+    }
+
+
+}
+# 6536 "/usr/include/c++/10.2.0/bits/basic_string.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/charconv.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/charconv.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/charconv.h" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __detail
+{
+
+  template<typename _Tp>
+    constexpr unsigned
+    __to_chars_len(_Tp __value, int __base = 10) noexcept
+    {
+      static_assert(is_integral<_Tp>::value, "implementation bug");
+      static_assert(is_unsigned<_Tp>::value, "implementation bug");
+
+      unsigned __n = 1;
+      const unsigned __b2 = __base * __base;
+      const unsigned __b3 = __b2 * __base;
+      const unsigned long __b4 = __b3 * __base;
+      for (;;)
+ {
+   if (__value < (unsigned)__base) return __n;
+   if (__value < __b2) return __n + 1;
+   if (__value < __b3) return __n + 2;
+   if (__value < __b4) return __n + 3;
+   __value /= __b4;
+   __n += 4;
+ }
+    }
+
+
+
+
+  template<typename _Tp>
+    void
+    __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept
+    {
+      static_assert(is_integral<_Tp>::value, "implementation bug");
+      static_assert(is_unsigned<_Tp>::value, "implementation bug");
+
+      static constexpr char __digits[201] =
+ "0001020304050607080910111213141516171819"
+ "2021222324252627282930313233343536373839"
+ "4041424344454647484950515253545556575859"
+ "6061626364656667686970717273747576777879"
+ "8081828384858687888990919293949596979899";
+      unsigned __pos = __len - 1;
+      while (__val >= 100)
+ {
+   auto const __num = (__val % 100) * 2;
+   __val /= 100;
+   __first[__pos] = __digits[__num + 1];
+   __first[__pos - 1] = __digits[__num];
+   __pos -= 2;
+ }
+      if (__val >= 10)
+ {
+   auto const __num = __val * 2;
+   __first[1] = __digits[__num + 1];
+   __first[0] = __digits[__num];
+ }
+      else
+ __first[0] = '0' + __val;
+    }
+
+}
+
+}
+# 6537 "/usr/include/c++/10.2.0/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)
+  {
+    const bool __neg = __val < 0;
+    const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val;
+    const auto __len = __detail::__to_chars_len(__uval);
+    string __str(__neg + __len, '-');
+    __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
+    return __str;
+  }
+
+  inline string
+  to_string(unsigned __val)
+  {
+    string __str(__detail::__to_chars_len(__val), '\0');
+    __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
+    return __str;
+  }
+
+  inline string
+  to_string(long __val)
+  {
+    const bool __neg = __val < 0;
+    const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val;
+    const auto __len = __detail::__to_chars_len(__uval);
+    string __str(__neg + __len, '-');
+    __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
+    return __str;
+  }
+
+  inline string
+  to_string(unsigned long __val)
+  {
+    string __str(__detail::__to_chars_len(__val), '\0');
+    __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
+    return __str;
+  }
+
+  inline string
+  to_string(long long __val)
+  {
+    const bool __neg = __val < 0;
+    const unsigned long long __uval
+      = __neg ? (unsigned long long)~__val + 1ull : __val;
+    const auto __len = __detail::__to_chars_len(__uval);
+    string __str(__neg + __len, '-');
+    __detail::__to_chars_10_impl(&__str[__neg], __len, __uval);
+    return __str;
+  }
+
+  inline string
+  to_string(unsigned long long __val)
+  {
+    string __str(__detail::__to_chars_len(__val), '\0');
+    __detail::__to_chars_10_impl(&__str[0], __str.size(), __val);
+    return __str;
+  }
+
+
+
+
+  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);
+  }
+
+
+
+}
+
+}
+
+
+
+
+
+
+
+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
+    { };
+# 6846 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+  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
+  {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+    __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}; }
+# 6904 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+    __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}; }
+
+#pragma GCC diagnostic pop
+  }
+  }
+# 6936 "/usr/include/c++/10.2.0/bits/basic_string.h" 3
+
+}
+# 56 "/usr/include/c++/10.2.0/string" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/basic_string.tcc" 1 3
+# 42 "/usr/include/c++/10.2.0/bits/basic_string.tcc" 3
+       
+# 43 "/usr/include/c++/10.2.0/bits/basic_string.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::npos;
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    swap(basic_string& __s) noexcept
+    {
+      if (this == &__s)
+ return;
+
+      _Alloc_traits::_S_on_swap(_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_set_length(__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, this->get_allocator());
+ 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())
+ {
+   pointer __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())
+ {
+   pointer __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;
+    }
+# 1158 "/usr/include/c++/10.2.0/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;
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_CharT>::other _Char_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
+      const __size_type __len = _Traits::length(__lhs);
+      __string_type __str(_Alloc_traits::_S_select_on_copy(
+          __rhs.get_allocator()));
+      __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;
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_CharT>::other _Char_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;
+      __string_type __str(_Alloc_traits::_S_select_on_copy(
+          __rhs.get_allocator()));
+      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
+    noexcept
+    {
+      ;
+      const size_type __size = this->size();
+
+      if (__n == 0)
+ return __pos <= __size ? __pos : npos;
+      if (__pos >= __size)
+ return npos;
+
+      const _CharT __elem0 = __s[0];
+      const _CharT* const __data = data();
+      const _CharT* __first = __data + __pos;
+      const _CharT* const __last = __data + __size;
+      size_type __len = __size - __pos;
+
+      while (__len >= __n)
+ {
+
+   __first = traits_type::find(__first, __len - __n + 1, __elem0);
+   if (!__first)
+     return npos;
+
+
+
+   if (traits_type::compare(__first, __s, __n) == 0)
+     return __first - __data;
+   __len = __last - ++__first;
+ }
+      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
+    noexcept
+    {
+      ;
+      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
+    noexcept
+    {
+      ;
+      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
+    noexcept
+    {
+      ;
+      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
+    noexcept
+    {
+      ;
+      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
+    noexcept
+    {
+      ;
+      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 noexcept
+    {
+      ;
+      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;
+    }
+# 1618 "/usr/include/c++/10.2.0/bits/basic_string.tcc" 3
+  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&);
+
+
+
+
+}
+# 57 "/usr/include/c++/10.2.0/string" 2 3
+# 40 "/usr/include/c++/10.2.0/stdexcept" 2 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 "/usr/include/c++/10.2.0/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(logic_error&&) noexcept;
+    logic_error& operator=(logic_error&&) noexcept;
+
+
+
+    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*) ;
+    domain_error(const domain_error&) = default;
+    domain_error& operator=(const domain_error&) = default;
+    domain_error(domain_error&&) = default;
+    domain_error& operator=(domain_error&&) = default;
+
+    virtual ~domain_error() noexcept;
+  };
+
+
+  class invalid_argument : public logic_error
+  {
+  public:
+    explicit invalid_argument(const string& __arg) ;
+
+    explicit invalid_argument(const char*) ;
+    invalid_argument(const invalid_argument&) = default;
+    invalid_argument& operator=(const invalid_argument&) = default;
+    invalid_argument(invalid_argument&&) = default;
+    invalid_argument& operator=(invalid_argument&&) = default;
+
+    virtual ~invalid_argument() noexcept;
+  };
+
+
+
+  class length_error : public logic_error
+  {
+  public:
+    explicit length_error(const string& __arg) ;
+
+    explicit length_error(const char*) ;
+    length_error(const length_error&) = default;
+    length_error& operator=(const length_error&) = default;
+    length_error(length_error&&) = default;
+    length_error& operator=(length_error&&) = default;
+
+    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*) ;
+    out_of_range(const out_of_range&) = default;
+    out_of_range& operator=(const out_of_range&) = default;
+    out_of_range(out_of_range&&) = default;
+    out_of_range& operator=(out_of_range&&) = default;
+
+    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(runtime_error&&) noexcept;
+    runtime_error& operator=(runtime_error&&) noexcept;
+
+
+
+    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*) ;
+    range_error(const range_error&) = default;
+    range_error& operator=(const range_error&) = default;
+    range_error(range_error&&) = default;
+    range_error& operator=(range_error&&) = default;
+
+    virtual ~range_error() noexcept;
+  };
+
+
+  class overflow_error : public runtime_error
+  {
+  public:
+    explicit overflow_error(const string& __arg) ;
+
+    explicit overflow_error(const char*) ;
+    overflow_error(const overflow_error&) = default;
+    overflow_error& operator=(const overflow_error&) = default;
+    overflow_error(overflow_error&&) = default;
+    overflow_error& operator=(overflow_error&&) = default;
+
+    virtual ~overflow_error() noexcept;
+  };
+
+
+  class underflow_error : public runtime_error
+  {
+  public:
+    explicit underflow_error(const string& __arg) ;
+
+    explicit underflow_error(const char*) ;
+    underflow_error(const underflow_error&) = default;
+    underflow_error& operator=(const underflow_error&) = default;
+    underflow_error(underflow_error&&) = default;
+    underflow_error& operator=(underflow_error&&) = default;
+
+    virtual ~underflow_error() noexcept;
+  };
+
+
+
+
+}
+# 29 "/home/ted/dev/openrct2/src/openrct2/common.h" 2
+
+
+# 30 "/home/ted/dev/openrct2/src/openrct2/common.h"
+using namespace Numerics;
+
+using utf8 = char;
+using utf8string = utf8*;
+using const_utf8string = const utf8*;
+
+
+
+
+
+
+
+using codepoint_t = uint32_t;
+using colour_t = uint8_t;
+
+const constexpr auto rol8 = rol<uint8_t>;
+const constexpr auto ror8 = ror<uint8_t>;
+const constexpr auto rol16 = rol<uint16_t>;
+const constexpr auto ror16 = ror<uint16_t>;
+const constexpr auto rol32 = rol<uint32_t>;
+const constexpr auto ror32 = ror<uint32_t>;
+const constexpr auto rol64 = rol<uint64_t>;
+const constexpr auto ror64 = ror<uint64_t>;
+
+namespace
+{
+    [[maybe_unused]] constexpr bool is_power_of_2(int v)
+    {
+        return v && ((v & (v - 1)) == 0);
+    }
+
+
+    [[maybe_unused]] constexpr int floor2(const int x, const int y)
+    {
+        if (!is_power_of_2(y))
+            throw std::logic_error("floor2 should only operate on power of 2");
+        return x & ~(y - 1);
+    }
+
+
+    [[maybe_unused]] constexpr int ceil2(const int x, const int y)
+    {
+        if (!is_power_of_2(y))
+            throw std::logic_error("ceil2 should only operate on power of 2");
+        return (x + y - 1) & ~(y - 1);
+    }
+}
+
+
+
+
+
+# 1 "/usr/include/unistd.h" 1 3 4
+# 27 "/usr/include/unistd.h" 3 4
+
+# 27 "/usr/include/unistd.h" 3 4
+extern "C" {
+# 202 "/usr/include/unistd.h" 3 4
+# 1 "/usr/include/bits/posix_opt.h" 1 3 4
+# 203 "/usr/include/unistd.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/environments.h" 1 3 4
+# 22 "/usr/include/bits/environments.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 23 "/usr/include/bits/environments.h" 2 3 4
+# 207 "/usr/include/unistd.h" 2 3 4
+# 226 "/usr/include/unistd.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 227 "/usr/include/unistd.h" 2 3 4
+# 274 "/usr/include/unistd.h" 3 4
+typedef __socklen_t socklen_t;
+# 287 "/usr/include/unistd.h" 3 4
+extern int access (const char *__name, int __type) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int euidaccess (const char *__name, int __type)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int eaccess (const char *__name, int __type)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int faccessat (int __fd, const char *__file, int __type, int __flag)
+     noexcept (true) __attribute__ ((__nonnull__ (2))) ;
+# 334 "/usr/include/unistd.h" 3 4
+extern __off_t lseek (int __fd, __off_t __offset, int __whence) noexcept (true);
+# 345 "/usr/include/unistd.h" 3 4
+extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
+     noexcept (true);
+
+
+
+
+
+
+extern int close (int __fd);
+
+
+
+
+
+
+extern ssize_t read (int __fd, void *__buf, size_t __nbytes)
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+
+extern ssize_t write (int __fd, const void *__buf, size_t __n)
+    __attribute__ ((__access__ (__read_only__, 2, 3)));
+# 378 "/usr/include/unistd.h" 3 4
+extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
+        __off_t __offset)
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+
+
+extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
+         __off_t __offset)
+    __attribute__ ((__access__ (__read_only__, 2, 3)));
+# 411 "/usr/include/unistd.h" 3 4
+extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
+   __off64_t __offset)
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
+    __off64_t __offset)
+    __attribute__ ((__access__ (__read_only__, 2, 3)));
+
+
+
+
+
+
+
+extern int pipe (int __pipedes[2]) noexcept (true) ;
+
+
+
+
+extern int pipe2 (int __pipedes[2], int __flags) noexcept (true) ;
+# 441 "/usr/include/unistd.h" 3 4
+extern unsigned int alarm (unsigned int __seconds) noexcept (true);
+# 453 "/usr/include/unistd.h" 3 4
+extern unsigned int sleep (unsigned int __seconds);
+
+
+
+
+
+
+
+extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
+     noexcept (true);
+
+
+
+
+
+
+extern int usleep (__useconds_t __useconds);
+# 478 "/usr/include/unistd.h" 3 4
+extern int pause (void);
+
+
+
+extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern int fchown (int __fd, __uid_t __owner, __gid_t __group) noexcept (true) ;
+
+
+
+
+extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+extern int fchownat (int __fd, const char *__file, __uid_t __owner,
+       __gid_t __group, int __flag)
+     noexcept (true) __attribute__ ((__nonnull__ (2))) ;
+
+
+
+extern int chdir (const char *__path) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern int fchdir (int __fd) noexcept (true) ;
+# 520 "/usr/include/unistd.h" 3 4
+extern char *getcwd (char *__buf, size_t __size) noexcept (true)
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+
+extern char *get_current_dir_name (void) noexcept (true);
+
+
+
+
+
+
+
+extern char *getwd (char *__buf)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__))
+    __attribute__ ((__access__ (__write_only__, 1)));
+
+
+
+
+extern int dup (int __fd) noexcept (true) ;
+
+
+extern int dup2 (int __fd, int __fd2) noexcept (true);
+
+
+
+
+extern int dup3 (int __fd, int __fd2, int __flags) noexcept (true);
+
+
+
+extern char **__environ;
+
+extern char **environ;
+
+
+
+
+
+extern int execve (const char *__path, char *const __argv[],
+     char *const __envp[]) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern int execv (const char *__path, char *const __argv[])
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int execle (const char *__path, const char *__arg, ...)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int execl (const char *__path, const char *__arg, ...)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int execvp (const char *__file, char *const __argv[])
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int execlp (const char *__file, const char *__arg, ...)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int execvpe (const char *__file, char *const __argv[],
+      char *const __envp[])
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern int nice (int __inc) noexcept (true) ;
+
+
+
+
+extern void _exit (int __status) __attribute__ ((__noreturn__));
+
+
+
+
+
+# 1 "/usr/include/bits/confname.h" 1 3 4
+# 24 "/usr/include/bits/confname.h" 3 4
+enum
+  {
+    _PC_LINK_MAX,
+
+    _PC_MAX_CANON,
+
+    _PC_MAX_INPUT,
+
+    _PC_NAME_MAX,
+
+    _PC_PATH_MAX,
+
+    _PC_PIPE_BUF,
+
+    _PC_CHOWN_RESTRICTED,
+
+    _PC_NO_TRUNC,
+
+    _PC_VDISABLE,
+
+    _PC_SYNC_IO,
+
+    _PC_ASYNC_IO,
+
+    _PC_PRIO_IO,
+
+    _PC_SOCK_MAXBUF,
+
+    _PC_FILESIZEBITS,
+
+    _PC_REC_INCR_XFER_SIZE,
+
+    _PC_REC_MAX_XFER_SIZE,
+
+    _PC_REC_MIN_XFER_SIZE,
+
+    _PC_REC_XFER_ALIGN,
+
+    _PC_ALLOC_SIZE_MIN,
+
+    _PC_SYMLINK_MAX,
+
+    _PC_2_SYMLINKS
+
+  };
+
+
+enum
+  {
+    _SC_ARG_MAX,
+
+    _SC_CHILD_MAX,
+
+    _SC_CLK_TCK,
+
+    _SC_NGROUPS_MAX,
+
+    _SC_OPEN_MAX,
+
+    _SC_STREAM_MAX,
+
+    _SC_TZNAME_MAX,
+
+    _SC_JOB_CONTROL,
+
+    _SC_SAVED_IDS,
+
+    _SC_REALTIME_SIGNALS,
+
+    _SC_PRIORITY_SCHEDULING,
+
+    _SC_TIMERS,
+
+    _SC_ASYNCHRONOUS_IO,
+
+    _SC_PRIORITIZED_IO,
+
+    _SC_SYNCHRONIZED_IO,
+
+    _SC_FSYNC,
+
+    _SC_MAPPED_FILES,
+
+    _SC_MEMLOCK,
+
+    _SC_MEMLOCK_RANGE,
+
+    _SC_MEMORY_PROTECTION,
+
+    _SC_MESSAGE_PASSING,
+
+    _SC_SEMAPHORES,
+
+    _SC_SHARED_MEMORY_OBJECTS,
+
+    _SC_AIO_LISTIO_MAX,
+
+    _SC_AIO_MAX,
+
+    _SC_AIO_PRIO_DELTA_MAX,
+
+    _SC_DELAYTIMER_MAX,
+
+    _SC_MQ_OPEN_MAX,
+
+    _SC_MQ_PRIO_MAX,
+
+    _SC_VERSION,
+
+    _SC_PAGESIZE,
+
+
+    _SC_RTSIG_MAX,
+
+    _SC_SEM_NSEMS_MAX,
+
+    _SC_SEM_VALUE_MAX,
+
+    _SC_SIGQUEUE_MAX,
+
+    _SC_TIMER_MAX,
+
+
+
+
+    _SC_BC_BASE_MAX,
+
+    _SC_BC_DIM_MAX,
+
+    _SC_BC_SCALE_MAX,
+
+    _SC_BC_STRING_MAX,
+
+    _SC_COLL_WEIGHTS_MAX,
+
+    _SC_EQUIV_CLASS_MAX,
+
+    _SC_EXPR_NEST_MAX,
+
+    _SC_LINE_MAX,
+
+    _SC_RE_DUP_MAX,
+
+    _SC_CHARCLASS_NAME_MAX,
+
+
+    _SC_2_VERSION,
+
+    _SC_2_C_BIND,
+
+    _SC_2_C_DEV,
+
+    _SC_2_FORT_DEV,
+
+    _SC_2_FORT_RUN,
+
+    _SC_2_SW_DEV,
+
+    _SC_2_LOCALEDEF,
+
+
+    _SC_PII,
+
+    _SC_PII_XTI,
+
+    _SC_PII_SOCKET,
+
+    _SC_PII_INTERNET,
+
+    _SC_PII_OSI,
+
+    _SC_POLL,
+
+    _SC_SELECT,
+
+    _SC_UIO_MAXIOV,
+
+    _SC_IOV_MAX = _SC_UIO_MAXIOV,
+
+    _SC_PII_INTERNET_STREAM,
+
+    _SC_PII_INTERNET_DGRAM,
+
+    _SC_PII_OSI_COTS,
+
+    _SC_PII_OSI_CLTS,
+
+    _SC_PII_OSI_M,
+
+    _SC_T_IOV_MAX,
+
+
+
+    _SC_THREADS,
+
+    _SC_THREAD_SAFE_FUNCTIONS,
+
+    _SC_GETGR_R_SIZE_MAX,
+
+    _SC_GETPW_R_SIZE_MAX,
+
+    _SC_LOGIN_NAME_MAX,
+
+    _SC_TTY_NAME_MAX,
+
+    _SC_THREAD_DESTRUCTOR_ITERATIONS,
+
+    _SC_THREAD_KEYS_MAX,
+
+    _SC_THREAD_STACK_MIN,
+
+    _SC_THREAD_THREADS_MAX,
+
+    _SC_THREAD_ATTR_STACKADDR,
+
+    _SC_THREAD_ATTR_STACKSIZE,
+
+    _SC_THREAD_PRIORITY_SCHEDULING,
+
+    _SC_THREAD_PRIO_INHERIT,
+
+    _SC_THREAD_PRIO_PROTECT,
+
+    _SC_THREAD_PROCESS_SHARED,
+
+
+    _SC_NPROCESSORS_CONF,
+
+    _SC_NPROCESSORS_ONLN,
+
+    _SC_PHYS_PAGES,
+
+    _SC_AVPHYS_PAGES,
+
+    _SC_ATEXIT_MAX,
+
+    _SC_PASS_MAX,
+
+
+    _SC_XOPEN_VERSION,
+
+    _SC_XOPEN_XCU_VERSION,
+
+    _SC_XOPEN_UNIX,
+
+    _SC_XOPEN_CRYPT,
+
+    _SC_XOPEN_ENH_I18N,
+
+    _SC_XOPEN_SHM,
+
+
+    _SC_2_CHAR_TERM,
+
+    _SC_2_C_VERSION,
+
+    _SC_2_UPE,
+
+
+    _SC_XOPEN_XPG2,
+
+    _SC_XOPEN_XPG3,
+
+    _SC_XOPEN_XPG4,
+
+
+    _SC_CHAR_BIT,
+
+    _SC_CHAR_MAX,
+
+    _SC_CHAR_MIN,
+
+    _SC_INT_MAX,
+
+    _SC_INT_MIN,
+
+    _SC_LONG_BIT,
+
+    _SC_WORD_BIT,
+
+    _SC_MB_LEN_MAX,
+
+    _SC_NZERO,
+
+    _SC_SSIZE_MAX,
+
+    _SC_SCHAR_MAX,
+
+    _SC_SCHAR_MIN,
+
+    _SC_SHRT_MAX,
+
+    _SC_SHRT_MIN,
+
+    _SC_UCHAR_MAX,
+
+    _SC_UINT_MAX,
+
+    _SC_ULONG_MAX,
+
+    _SC_USHRT_MAX,
+
+
+    _SC_NL_ARGMAX,
+
+    _SC_NL_LANGMAX,
+
+    _SC_NL_MSGMAX,
+
+    _SC_NL_NMAX,
+
+    _SC_NL_SETMAX,
+
+    _SC_NL_TEXTMAX,
+
+
+    _SC_XBS5_ILP32_OFF32,
+
+    _SC_XBS5_ILP32_OFFBIG,
+
+    _SC_XBS5_LP64_OFF64,
+
+    _SC_XBS5_LPBIG_OFFBIG,
+
+
+    _SC_XOPEN_LEGACY,
+
+    _SC_XOPEN_REALTIME,
+
+    _SC_XOPEN_REALTIME_THREADS,
+
+
+    _SC_ADVISORY_INFO,
+
+    _SC_BARRIERS,
+
+    _SC_BASE,
+
+    _SC_C_LANG_SUPPORT,
+
+    _SC_C_LANG_SUPPORT_R,
+
+    _SC_CLOCK_SELECTION,
+
+    _SC_CPUTIME,
+
+    _SC_THREAD_CPUTIME,
+
+    _SC_DEVICE_IO,
+
+    _SC_DEVICE_SPECIFIC,
+
+    _SC_DEVICE_SPECIFIC_R,
+
+    _SC_FD_MGMT,
+
+    _SC_FIFO,
+
+    _SC_PIPE,
+
+    _SC_FILE_ATTRIBUTES,
+
+    _SC_FILE_LOCKING,
+
+    _SC_FILE_SYSTEM,
+
+    _SC_MONOTONIC_CLOCK,
+
+    _SC_MULTI_PROCESS,
+
+    _SC_SINGLE_PROCESS,
+
+    _SC_NETWORKING,
+
+    _SC_READER_WRITER_LOCKS,
+
+    _SC_SPIN_LOCKS,
+
+    _SC_REGEXP,
+
+    _SC_REGEX_VERSION,
+
+    _SC_SHELL,
+
+    _SC_SIGNALS,
+
+    _SC_SPAWN,
+
+    _SC_SPORADIC_SERVER,
+
+    _SC_THREAD_SPORADIC_SERVER,
+
+    _SC_SYSTEM_DATABASE,
+
+    _SC_SYSTEM_DATABASE_R,
+
+    _SC_TIMEOUTS,
+
+    _SC_TYPED_MEMORY_OBJECTS,
+
+    _SC_USER_GROUPS,
+
+    _SC_USER_GROUPS_R,
+
+    _SC_2_PBS,
+
+    _SC_2_PBS_ACCOUNTING,
+
+    _SC_2_PBS_LOCATE,
+
+    _SC_2_PBS_MESSAGE,
+
+    _SC_2_PBS_TRACK,
+
+    _SC_SYMLOOP_MAX,
+
+    _SC_STREAMS,
+
+    _SC_2_PBS_CHECKPOINT,
+
+
+    _SC_V6_ILP32_OFF32,
+
+    _SC_V6_ILP32_OFFBIG,
+
+    _SC_V6_LP64_OFF64,
+
+    _SC_V6_LPBIG_OFFBIG,
+
+
+    _SC_HOST_NAME_MAX,
+
+    _SC_TRACE,
+
+    _SC_TRACE_EVENT_FILTER,
+
+    _SC_TRACE_INHERIT,
+
+    _SC_TRACE_LOG,
+
+
+    _SC_LEVEL1_ICACHE_SIZE,
+
+    _SC_LEVEL1_ICACHE_ASSOC,
+
+    _SC_LEVEL1_ICACHE_LINESIZE,
+
+    _SC_LEVEL1_DCACHE_SIZE,
+
+    _SC_LEVEL1_DCACHE_ASSOC,
+
+    _SC_LEVEL1_DCACHE_LINESIZE,
+
+    _SC_LEVEL2_CACHE_SIZE,
+
+    _SC_LEVEL2_CACHE_ASSOC,
+
+    _SC_LEVEL2_CACHE_LINESIZE,
+
+    _SC_LEVEL3_CACHE_SIZE,
+
+    _SC_LEVEL3_CACHE_ASSOC,
+
+    _SC_LEVEL3_CACHE_LINESIZE,
+
+    _SC_LEVEL4_CACHE_SIZE,
+
+    _SC_LEVEL4_CACHE_ASSOC,
+
+    _SC_LEVEL4_CACHE_LINESIZE,
+
+
+
+    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
+
+    _SC_RAW_SOCKETS,
+
+
+    _SC_V7_ILP32_OFF32,
+
+    _SC_V7_ILP32_OFFBIG,
+
+    _SC_V7_LP64_OFF64,
+
+    _SC_V7_LPBIG_OFFBIG,
+
+
+    _SC_SS_REPL_MAX,
+
+
+    _SC_TRACE_EVENT_NAME_MAX,
+
+    _SC_TRACE_NAME_MAX,
+
+    _SC_TRACE_SYS_MAX,
+
+    _SC_TRACE_USER_EVENT_MAX,
+
+
+    _SC_XOPEN_STREAMS,
+
+
+    _SC_THREAD_ROBUST_PRIO_INHERIT,
+
+    _SC_THREAD_ROBUST_PRIO_PROTECT
+
+  };
+
+
+enum
+  {
+    _CS_PATH,
+
+
+    _CS_V6_WIDTH_RESTRICTED_ENVS,
+
+
+
+    _CS_GNU_LIBC_VERSION,
+
+    _CS_GNU_LIBPTHREAD_VERSION,
+
+
+    _CS_V5_WIDTH_RESTRICTED_ENVS,
+
+
+
+    _CS_V7_WIDTH_RESTRICTED_ENVS,
+
+
+
+    _CS_LFS_CFLAGS = 1000,
+
+    _CS_LFS_LDFLAGS,
+
+    _CS_LFS_LIBS,
+
+    _CS_LFS_LINTFLAGS,
+
+    _CS_LFS64_CFLAGS,
+
+    _CS_LFS64_LDFLAGS,
+
+    _CS_LFS64_LIBS,
+
+    _CS_LFS64_LINTFLAGS,
+
+
+    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
+
+    _CS_XBS5_ILP32_OFF32_LDFLAGS,
+
+    _CS_XBS5_ILP32_OFF32_LIBS,
+
+    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
+
+    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
+
+    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
+
+    _CS_XBS5_ILP32_OFFBIG_LIBS,
+
+    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
+
+    _CS_XBS5_LP64_OFF64_CFLAGS,
+
+    _CS_XBS5_LP64_OFF64_LDFLAGS,
+
+    _CS_XBS5_LP64_OFF64_LIBS,
+
+    _CS_XBS5_LP64_OFF64_LINTFLAGS,
+
+    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
+
+    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
+
+    _CS_XBS5_LPBIG_OFFBIG_LIBS,
+
+    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
+
+
+    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFF32_LIBS,
+
+    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
+
+    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
+
+    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
+
+    _CS_POSIX_V6_LP64_OFF64_LIBS,
+
+    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
+
+
+    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFF32_LIBS,
+
+    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
+
+    _CS_POSIX_V7_LP64_OFF64_CFLAGS,
+
+    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
+
+    _CS_POSIX_V7_LP64_OFF64_LIBS,
+
+    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,
+
+
+    _CS_V6_ENV,
+
+    _CS_V7_ENV
+
+  };
+# 621 "/usr/include/unistd.h" 2 3 4
+
+
+extern long int pathconf (const char *__path, int __name)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern long int fpathconf (int __fd, int __name) noexcept (true);
+
+
+extern long int sysconf (int __name) noexcept (true);
+
+
+
+extern size_t confstr (int __name, char *__buf, size_t __len) noexcept (true)
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+extern __pid_t getpid (void) noexcept (true);
+
+
+extern __pid_t getppid (void) noexcept (true);
+
+
+extern __pid_t getpgrp (void) noexcept (true);
+
+
+extern __pid_t __getpgid (__pid_t __pid) noexcept (true);
+
+extern __pid_t getpgid (__pid_t __pid) noexcept (true);
+
+
+
+
+
+
+extern int setpgid (__pid_t __pid, __pid_t __pgid) noexcept (true);
+# 672 "/usr/include/unistd.h" 3 4
+extern int setpgrp (void) noexcept (true);
+
+
+
+
+
+
+extern __pid_t setsid (void) noexcept (true);
+
+
+
+extern __pid_t getsid (__pid_t __pid) noexcept (true);
+
+
+
+extern __uid_t getuid (void) noexcept (true);
+
+
+extern __uid_t geteuid (void) noexcept (true);
+
+
+extern __gid_t getgid (void) noexcept (true);
+
+
+extern __gid_t getegid (void) noexcept (true);
+
+
+
+
+extern int getgroups (int __size, __gid_t __list[]) noexcept (true)
+    __attribute__ ((__access__ (__write_only__, 2, 1)));
+
+
+extern int group_member (__gid_t __gid) noexcept (true);
+
+
+
+
+
+
+extern int setuid (__uid_t __uid) noexcept (true) ;
+
+
+
+
+extern int setreuid (__uid_t __ruid, __uid_t __euid) noexcept (true) ;
+
+
+
+
+extern int seteuid (__uid_t __uid) noexcept (true) ;
+
+
+
+
+
+
+extern int setgid (__gid_t __gid) noexcept (true) ;
+
+
+
+
+extern int setregid (__gid_t __rgid, __gid_t __egid) noexcept (true) ;
+
+
+
+
+extern int setegid (__gid_t __gid) noexcept (true) ;
+
+
+
+
+
+extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
+     noexcept (true);
+
+
+
+extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
+     noexcept (true);
+
+
+
+extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
+     noexcept (true) ;
+
+
+
+extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
+     noexcept (true) ;
+
+
+
+
+
+
+extern __pid_t fork (void) noexcept (true);
+
+
+
+
+
+
+
+extern __pid_t vfork (void) noexcept (true);
+
+
+
+
+
+extern char *ttyname (int __fd) noexcept (true);
+
+
+
+extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
+     noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+extern int isatty (int __fd) noexcept (true);
+
+
+
+
+extern int ttyslot (void) noexcept (true);
+
+
+
+
+extern int link (const char *__from, const char *__to)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;
+
+
+
+
+extern int linkat (int __fromfd, const char *__from, int __tofd,
+     const char *__to, int __flags)
+     noexcept (true) __attribute__ ((__nonnull__ (2, 4))) ;
+
+
+
+
+extern int symlink (const char *__from, const char *__to)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;
+
+
+
+
+extern ssize_t readlink (const char *__restrict __path,
+    char *__restrict __buf, size_t __len)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+
+extern int symlinkat (const char *__from, int __tofd,
+        const char *__to) noexcept (true) __attribute__ ((__nonnull__ (1, 3))) ;
+
+
+extern ssize_t readlinkat (int __fd, const char *__restrict __path,
+      char *__restrict __buf, size_t __len)
+     noexcept (true) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__access__ (__write_only__, 3, 4)));
+
+
+
+extern int unlink (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int unlinkat (int __fd, const char *__name, int __flag)
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern int rmdir (const char *__path) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern __pid_t tcgetpgrp (int __fd) noexcept (true);
+
+
+extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) noexcept (true);
+
+
+
+
+
+
+extern char *getlogin (void);
+
+
+
+
+
+
+
+extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+extern int setlogin (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+# 1 "/usr/include/bits/getopt_posix.h" 1 3 4
+# 27 "/usr/include/bits/getopt_posix.h" 3 4
+# 1 "/usr/include/bits/getopt_core.h" 1 3 4
+# 28 "/usr/include/bits/getopt_core.h" 3 4
+extern "C" {
+
+
+
+
+
+
+
+extern char *optarg;
+# 50 "/usr/include/bits/getopt_core.h" 3 4
+extern int optind;
+
+
+
+
+extern int opterr;
+
+
+
+extern int optopt;
+# 91 "/usr/include/bits/getopt_core.h" 3 4
+extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
+       noexcept (true) __attribute__ ((__nonnull__ (2, 3)));
+
+}
+# 28 "/usr/include/bits/getopt_posix.h" 2 3 4
+
+extern "C" {
+# 49 "/usr/include/bits/getopt_posix.h" 3 4
+}
+# 884 "/usr/include/unistd.h" 2 3 4
+
+
+
+
+
+
+
+extern int gethostname (char *__name, size_t __len) noexcept (true) __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+
+
+extern int sethostname (const char *__name, size_t __len)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__read_only__, 1, 2)));
+
+
+
+extern int sethostid (long int __id) noexcept (true) ;
+
+
+
+
+
+extern int getdomainname (char *__name, size_t __len)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__write_only__, 1, 2)));
+extern int setdomainname (const char *__name, size_t __len)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__access__ (__read_only__, 1, 2)));
+
+
+
+
+extern int vhangup (void) noexcept (true);
+
+
+extern int revoke (const char *__file) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+
+
+
+
+extern int profil (unsigned short int *__sample_buffer, size_t __size,
+     size_t __offset, unsigned int __scale)
+     noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int acct (const char *__name) noexcept (true);
+
+
+
+extern char *getusershell (void) noexcept (true);
+extern void endusershell (void) noexcept (true);
+extern void setusershell (void) noexcept (true);
+
+
+
+
+
+extern int daemon (int __nochdir, int __noclose) noexcept (true) ;
+
+
+
+
+
+
+extern int chroot (const char *__path) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+
+
+
+extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int fsync (int __fd);
+
+
+
+
+
+extern int syncfs (int __fd) noexcept (true);
+
+
+
+
+
+
+extern long int gethostid (void);
+
+
+extern void sync (void) noexcept (true);
+
+
+
+
+
+extern int getpagesize (void) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern int getdtablesize (void) noexcept (true);
+# 1005 "/usr/include/unistd.h" 3 4
+extern int truncate (const char *__file, __off_t __length)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+# 1017 "/usr/include/unistd.h" 3 4
+extern int truncate64 (const char *__file, __off64_t __length)
+     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
+# 1028 "/usr/include/unistd.h" 3 4
+extern int ftruncate (int __fd, __off_t __length) noexcept (true) ;
+# 1038 "/usr/include/unistd.h" 3 4
+extern int ftruncate64 (int __fd, __off64_t __length) noexcept (true) ;
+# 1049 "/usr/include/unistd.h" 3 4
+extern int brk (void *__addr) noexcept (true) ;
+
+
+
+
+
+extern void *sbrk (intptr_t __delta) noexcept (true);
+# 1070 "/usr/include/unistd.h" 3 4
+extern long int syscall (long int __sysno, ...) noexcept (true);
+# 1093 "/usr/include/unistd.h" 3 4
+extern int lockf (int __fd, int __cmd, __off_t __len) ;
+# 1103 "/usr/include/unistd.h" 3 4
+extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
+# 1121 "/usr/include/unistd.h" 3 4
+ssize_t copy_file_range (int __infd, __off64_t *__pinoff,
+    int __outfd, __off64_t *__poutoff,
+    size_t __length, unsigned int __flags);
+
+
+
+
+
+extern int fdatasync (int __fildes);
+# 1138 "/usr/include/unistd.h" 3 4
+extern char *crypt (const char *__key, const char *__salt)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+
+extern void swab (const void *__restrict __from, void *__restrict __to,
+    ssize_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2)))
+    __attribute__ ((__access__ (__read_only__, 1, 3)))
+    __attribute__ ((__access__ (__write_only__, 2, 3)));
+# 1177 "/usr/include/unistd.h" 3 4
+int getentropy (void *__buffer, size_t __length)
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+# 1187 "/usr/include/unistd.h" 3 4
+# 1 "/usr/include/bits/unistd_ext.h" 1 3 4
+# 34 "/usr/include/bits/unistd_ext.h" 3 4
+extern __pid_t gettid (void) noexcept (true);
+# 1188 "/usr/include/unistd.h" 2 3 4
+
+}
+# 83 "/home/ted/dev/openrct2/src/openrct2/common.h" 2
+# 113 "/home/ted/dev/openrct2/src/openrct2/common.h"
+
+# 113 "/home/ted/dev/openrct2/src/openrct2/common.h"
+using datetime64 = uint64_t;
+
+constexpr const datetime64 DATETIME64_MIN = 0;
+
+
+using fixed8_1dp = uint8_t;
+using fixed8_2dp = uint8_t;
+using fixed16_1dp = int16_t;
+using fixed16_2dp = int16_t;
+using fixed32_1dp = int32_t;
+using fixed32_2dp = int32_t;
+using fixed64_1dp = int64_t;
+
+
+using money8 = fixed8_1dp;
+using money16 = fixed16_1dp;
+using money32 = fixed32_1dp;
+using money64 = fixed64_1dp;
+# 145 "/home/ted/dev/openrct2/src/openrct2/common.h"
+using EMPTY_ARGS_VOID_POINTER = void();
+using rct_string_id = uint16_t;
+
+constexpr uint16_t SPRITE_INDEX_NULL = 0xFFFF;
+# 14 "/home/ted/dev/openrct2/src/openrct2/Cheats.h" 2
+
+extern bool gCheatsSandboxMode;
+extern bool gCheatsDisableClearanceChecks;
+extern bool gCheatsDisableSupportLimits;
+extern bool gCheatsShowAllOperatingModes;
+extern bool gCheatsShowVehiclesFromOtherTrackTypes;
+extern bool gCheatsFastLiftHill;
+extern bool gCheatsDisableBrakesFailure;
+extern bool gCheatsDisableAllBreakdowns;
+extern bool gCheatsBuildInPauseMode;
+extern bool gCheatsIgnoreRideIntensity;
+extern bool gCheatsDisableVandalism;
+extern bool gCheatsDisableLittering;
+extern bool gCheatsNeverendingMarketing;
+extern bool gCheatsFreezeWeather;
+extern bool gCheatsDisableTrainLengthLimit;
+extern bool gCheatsDisablePlantAging;
+extern bool gCheatsDisableRideValueAging;
+extern bool gCheatsEnableChainLiftOnAllTrack;
+extern bool gCheatsAllowArbitraryRideTypeChanges;
+extern bool gCheatsIgnoreResearchStatus;
+extern bool gCheatsEnableAllDrawableTrackPieces;
+extern bool gCheatsAllowTrackPlaceInvalidHeights;
+
+enum class CheatType : int32_t
+{
+    SandboxMode,
+    DisableClearanceChecks,
+    DisableSupportLimits,
+    ShowAllOperatingModes,
+    ShowVehiclesFromOtherTrackTypes,
+    DisableTrainLengthLimit,
+    EnableChainLiftOnAllTrack,
+    FastLiftHill,
+    DisableBrakesFailure,
+    DisableAllBreakdowns,
+    UnlockAllPrices,
+    BuildInPauseMode,
+    IgnoreRideIntensity,
+    DisableVandalism,
+    DisableLittering,
+    NoMoney,
+    AddMoney,
+    SetMoney,
+    ClearLoan,
+    SetGuestParameter,
+    GenerateGuests,
+    RemoveAllGuests,
+    GiveAllGuests,
+    SetGrassLength,
+    WaterPlants,
+    DisablePlantAging,
+    FixVandalism,
+    RemoveLitter,
+    SetStaffSpeed,
+    RenewRides,
+    MakeDestructible,
+    FixRides,
+    ResetCrashStatus,
+    TenMinuteInspections,
+    WinScenario,
+    ForceWeather,
+    FreezeWeather,
+    OpenClosePark,
+    HaveFun,
+    SetForcedParkRating,
+    NeverEndingMarketing,
+    AllowArbitraryRideTypeChanges,
+    OwnAllLand,
+    DisableRideValueAging,
+    IgnoreResearchStatus,
+    EnableAllDrawableTrackPieces,
+    CreateDucks,
+    RemoveDucks,
+    AllowTrackPlaceInvalidHeights,
+    Count,
+};
+
+enum
+{
+    GUEST_PARAMETER_HAPPINESS,
+    GUEST_PARAMETER_ENERGY,
+    GUEST_PARAMETER_HUNGER,
+    GUEST_PARAMETER_THIRST,
+    GUEST_PARAMETER_NAUSEA,
+    GUEST_PARAMETER_NAUSEA_TOLERANCE,
+    GUEST_PARAMETER_TOILET,
+    GUEST_PARAMETER_PREFERRED_RIDE_INTENSITY
+};
+
+enum
+{
+    OBJECT_MONEY,
+    OBJECT_PARK_MAP,
+    OBJECT_BALLOON,
+    OBJECT_UMBRELLA
+};
+# 119 "/home/ted/dev/openrct2/src/openrct2/Cheats.h"
+void CheatsReset();
+const char* CheatsGetName(CheatType cheatType);
+void CheatsSet(CheatType cheatType, int32_t param1 = 0, int32_t param2 = 0);
+void CheatsSerialise(class DataSerialiser& ds);
+# 13 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/Context.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/Context.h"
+       
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/Location.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/world/Location.hpp"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/world/Location.hpp" 2
+
+# 1 "/usr/include/c++/10.2.0/algorithm" 1 3
+# 58 "/usr/include/c++/10.2.0/algorithm" 3
+       
+# 59 "/usr/include/c++/10.2.0/algorithm" 3
+
+# 1 "/usr/include/c++/10.2.0/utility" 1 3
+# 58 "/usr/include/c++/10.2.0/utility" 3
+       
+# 59 "/usr/include/c++/10.2.0/utility" 3
+# 69 "/usr/include/c++/10.2.0/utility" 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_relops.h" 1 3
+# 67 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+
+# 67 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  namespace rel_ops
+  {
+# 85 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator!=(const _Tp& __x, const _Tp& __y)
+      { return !(__x == __y); }
+# 98 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>(const _Tp& __x, const _Tp& __y)
+      { return __y < __x; }
+# 111 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator<=(const _Tp& __x, const _Tp& __y)
+      { return !(__y < __x); }
+# 124 "/usr/include/c++/10.2.0/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>=(const _Tp& __x, const _Tp& __y)
+      { return !(__x < __y); }
+  }
+
+
+}
+# 70 "/usr/include/c++/10.2.0/utility" 2 3
+# 82 "/usr/include/c++/10.2.0/utility" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Tp>
+    struct tuple_size;
+
+
+
+
+
+  template<typename _Tp,
+    typename _Up = typename remove_cv<_Tp>::type,
+    typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
+    size_t = tuple_size<_Tp>::value>
+    using __enable_if_has_tuple_size = _Tp;
+
+  template<typename _Tp>
+    struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
+    : public tuple_size<_Tp> { };
+
+  template<typename _Tp>
+    struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
+    : public tuple_size<_Tp> { };
+
+  template<typename _Tp>
+    struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
+    : public tuple_size<_Tp> { };
+
+
+  template<std::size_t __i, typename _Tp>
+    struct tuple_element;
+
+
+  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 _T1, typename _T2>
+    struct __is_tuple_like_impl<std::pair<_T1, _T2>> : true_type
+    { };
+
+
+  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<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp1&&
+        __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<const _Tp1>(__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<typename _Tp1, typename _Tp2>
+        static constexpr const _Tp2&&
+        __const_move_get(const std::pair<_Tp1, _Tp2>&& __pair) noexcept
+        { return std::forward<const _Tp2>(__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<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_move_get(std::move(__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 const _Tp&&
+    get(const 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>
+    constexpr const _Tp&&
+    get(const 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 { };
+# 307 "/usr/include/c++/10.2.0/utility" 3
+  template<size_t _Num>
+    struct _Build_index_tuple
+    {
+
+
+
+
+
+
+      using __type = _Index_tuple<__integer_pack(_Num)...>;
+
+    };
+
+
+
+
+
+
+  template<typename _Tp, _Tp... _Idx>
+    struct integer_sequence
+    {
+      typedef _Tp value_type;
+      static constexpr size_t size() noexcept { return sizeof...(_Idx); }
+    };
+
+
+  template<typename _Tp, _Tp _Num>
+    using make_integer_sequence
+
+
+
+      = integer_sequence<_Tp, __integer_pack(_Num)...>;
+
+
+
+
+
+  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)>;
+# 473 "/usr/include/c++/10.2.0/utility" 3
+
+}
+# 61 "/usr/include/c++/10.2.0/algorithm" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_algo.h" 1 3
+# 59 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 60 "/usr/include/c++/10.2.0/bits/stl_algo.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+# 42 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 199 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+  template<typename _IIter, typename _Predicate>
+   
+    bool
+    all_of(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Predicate>
+   
+    bool
+    any_of(_IIter, _IIter, _Predicate);
+
+
+  template<typename _FIter, typename _Tp>
+   
+    bool
+    binary_search(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+   
+    bool
+    binary_search(_FIter, _FIter, const _Tp&, _Compare);
+# 232 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+  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);
+# 625 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+  template<typename _RAIter, typename _UGenerator>
+    void
+    shuffle(_RAIter, _RAIter, _UGenerator&&);
+
+
+  template<typename _RAIter>
+   
+    void
+    sort_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+   
+    void
+    sort_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    stable_partition(_BIter, _BIter, _Predicate);
+# 658 "/usr/include/c++/10.2.0/bits/algorithmfwd.h" 3
+  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 "/usr/include/c++/10.2.0/bits/stl_algo.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_heap.h" 1 3
+# 62 "/usr/include/c++/10.2.0/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)
+    {
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      return std::__is_heap_until(__first, __n, __comp) == __n;
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare,
+    typename _Distance>
+   
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
+    {
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      return std::__is_heap_until(__first, __n, __cmp) == __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, std::move(__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);
+    }
+# 158 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+     
+
+     
+      ;
+      ;
+      ;
+
+      __gnu_cxx::__ops::_Iter_less_val __comp;
+      _ValueType __value = std::move(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), std::move(__value), __comp);
+    }
+# 194 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+     
+
+      ;
+      ;
+      ;
+
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
+ __cmp(std::move(__comp));
+      _ValueType __value = std::move(*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), std::move(__value), __cmp);
+    }
+
+  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;
+ }
+      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
+ __cmp(std::move(__comp));
+      std::__push_heap(__first, __holeIndex, __topIndex,
+         std::move(__value), __cmp);
+    }
+
+  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);
+    }
+# 279 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+      ;
+      ;
+
+      if (__last - __first > 1)
+ {
+   --__last;
+   __gnu_cxx::__ops::_Iter_less_iter __comp;
+   std::__pop_heap(__first, __last, __last, __comp);
+ }
+    }
+# 313 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    pop_heap(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+      ;
+      ;
+
+      if (__last - __first > 1)
+ {
+   typedef __decltype(__comp) _Cmp;
+   __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+   --__last;
+   std::__pop_heap(__first, __last, __last, __cmp);
+ }
+    }
+
+  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--;
+ }
+    }
+# 371 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      std::__make_heap(__first, __last, __comp);
+    }
+# 398 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      std::__make_heap(__first, __last, __cmp);
+    }
+
+  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);
+ }
+    }
+# 436 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+      ;
+
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      std::__sort_heap(__first, __last, __comp);
+    }
+# 464 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+      ;
+
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      std::__sort_heap(__first, __last, __cmp);
+    }
+# 493 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      __gnu_cxx::__ops::_Iter_less_iter __comp;
+      return __first +
+ std::__is_heap_until(__first, std::distance(__first, __last), __comp);
+    }
+# 522 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline _RandomAccessIterator
+    is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      return __first
+ + std::__is_heap_until(__first, std::distance(__first, __last), __cmp);
+    }
+# 547 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+   
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::is_heap_until(__first, __last) == __last; }
+# 561 "/usr/include/c++/10.2.0/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+   
+    inline bool
+    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+
+      const auto __dist = std::distance(__first, __last);
+      typedef __decltype(__comp) _Cmp;
+      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
+      return std::__is_heap_until(__first, __dist, __cmp) == __dist;
+    }
+
+
+
+}
+# 62 "/usr/include/c++/10.2.0/bits/stl_algo.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_tempbuf.h" 1 3
+# 62 "/usr/include/c++/10.2.0/bits/stl_tempbuf.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  namespace __detail
+  {
+    template<typename _Tp>
+      inline void
+      __return_temporary_buffer(_Tp* __p,
+    size_t __len __attribute__((__unused__)))
+      {
+
+ ::operator delete(__p, __len * sizeof(_Tp));
+
+
+
+      }
+  }
+# 98 "/usr/include/c++/10.2.0/bits/stl_tempbuf.h" 3
+  template<typename _Tp>
+    pair<_Tp*, ptrdiff_t>
+    get_temporary_buffer(ptrdiff_t __len) noexcept
+    {
+      const ptrdiff_t __max =
+ __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
+      if (__len > __max)
+ __len = __max;
+
+      while (__len > 0)
+ {
+   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
+       std::nothrow));
+   if (__tmp != 0)
+     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
+   __len /= 2;
+ }
+      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
+    }
+# 125 "/usr/include/c++/10.2.0/bits/stl_tempbuf.h" 3
+  template<typename _Tp>
+    inline void
+    return_temporary_buffer(_Tp* __p)
+    { ::operator delete(__p); }
+
+
+
+
+
+
+  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 __seed, size_type __original_len);
+
+      ~_Temporary_buffer()
+      {
+ std::_Destroy(_M_buffer, _M_buffer + _M_len);
+ std::__detail::__return_temporary_buffer(_M_buffer, _M_len);
+      }
+
+    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) { }
+    };
+# 243 "/usr/include/c++/10.2.0/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 __seed, size_type __original_len)
+    : _M_original_len(__original_len), _M_len(0), _M_buffer(0)
+    {
+      std::pair<pointer, size_type> __p(
+  std::get_temporary_buffer<value_type>(_M_original_len));
+
+      if (__p.first)
+ {
+   try
+     {
+       std::__uninitialized_construct_buf(__p.first, __p.first + __p.second,
+       __seed);
+       _M_buffer = __p.first;
+       _M_len = __p.second;
+     }
+   catch(...)
+     {
+       std::__detail::__return_temporary_buffer(__p.first, __p.second);
+       throw;
+     }
+ }
+    }
+
+
+}
+# 63 "/usr/include/c++/10.2.0/bits/stl_algo.h" 2 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 1 3
+# 40 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 57 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 3
+  namespace __detail
+  {
+
+    template<typename _Tp>
+      inline bool
+      _Power_of_2(_Tp __x)
+      {
+ return ((__x - 1) & __x) == 0;
+      }
+  }
+
+
+
+
+
+
+  template<typename _IntType = int>
+    class uniform_int_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+      "template argument must be an integral type");
+
+    public:
+
+      typedef _IntType result_type;
+
+      struct param_type
+      {
+ typedef uniform_int_distribution<_IntType> distribution_type;
+
+ param_type() : param_type(0) { }
+
+ explicit
+ param_type(_IntType __a,
+     _IntType __b = 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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _IntType _M_a;
+ _IntType _M_b;
+      };
+
+    public:
+
+
+
+      uniform_int_distribution() : uniform_int_distribution(0) { }
+
+
+
+
+      explicit
+      uniform_int_distribution(_IntType __a,
+          _IntType __b = 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>
+    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)
+   {
+# 287 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 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)
+   {
+# 371 "/usr/include/c++/10.2.0/bits/uniform_int_dist.h" 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();
+      }
+
+
+
+
+}
+# 67 "/usr/include/c++/10.2.0/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_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, (void) ++__first)
+ if (!__pred(__first))
+   break;
+      return __first;
+    }
+# 138 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    _ForwardIterator1
+    __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __predicate)
+    {
+
+      if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+
+
+      _ForwardIterator2 __p1(__first2);
+      if (++__p1 == __last2)
+ return std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+
+      _ForwardIterator1 __current = __first1;
+
+      for (;;)
+ {
+   __first1 =
+     std::__find_if(__first1, __last1,
+  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));
+
+   if (__first1 == __last1)
+     return __last1;
+
+   _ForwardIterator2 __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;
+ }
+    }
+# 364 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+   
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __gnu_cxx::__ops::__iter_equal_to_iter());
+    }
+# 413 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+   
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __comp)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __gnu_cxx::__ops::__iter_comp_iter(__comp));
+    }
+# 449 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline bool
+    all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == std::find_if_not(__first, __last, __pred); }
+# 467 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline bool
+    none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return __last == std::find_if(__first, __last, __pred); }
+# 486 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline bool
+    any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    { return !std::none_of(__first, __last, __pred); }
+# 502 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline _InputIterator
+    find_if_not(_InputIterator __first, _InputIterator __last,
+  _Predicate __pred)
+    {
+
+     
+     
+
+      ;
+      return std::__find_if_not(__first, __last,
+    __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 527 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline bool
+    is_partitioned(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+      __first = std::find_if_not(__first, __last, __pred);
+      if (__first == __last)
+ return true;
+      ++__first;
+      return std::none_of(__first, __last, __pred);
+    }
+# 549 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+   
+    _ForwardIterator
+    partition_point(_ForwardIterator __first, _ForwardIterator __last,
+      _Predicate __pred)
+    {
+
+     
+     
+
+
+
+      ;
+
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+      _DistanceType __len = std::distance(__first, __last);
+
+      while (__len > 0)
+ {
+   _DistanceType __half = __len >> 1;
+   _ForwardIterator __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;
+    }
+# 616 "/usr/include/c++/10.2.0/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));
+    }
+# 649 "/usr/include/c++/10.2.0/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));
+    }
+# 684 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+   
+    _OutputIterator
+    copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+   
+    _OutputIterator
+    __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result)
+    {
+      if (__n > 0)
+ {
+   while (true)
+     {
+       *__result = *__first;
+       ++__result;
+       if (--__n > 0)
+  ++__first;
+       else
+  break;
+     }
+ }
+      return __result;
+    }
+
+  template<typename _CharT, typename _Size>
+    __enable_if_t<__is_char<_CharT>::__value, _CharT*>
+    __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT>>,
+        _Size, _CharT*);
+
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+   
+    _OutputIterator
+    __copy_n(_InputIterator __first, _Size __n,
+      _OutputIterator __result, input_iterator_tag)
+    {
+      return std::__niter_wrap(__result,
+          __copy_n_a(__first, __n,
+       std::__niter_base(__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); }
+# 765 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Size, typename _OutputIterator>
+   
+    inline _OutputIterator
+    copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      return std::__copy_n(__first, __n, __result,
+      std::__iterator_category(__first));
+    }
+# 796 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator1,
+    typename _OutputIterator2, typename _Predicate>
+   
+    pair<_OutputIterator1, _OutputIterator2>
+    partition_copy(_InputIterator __first, _InputIterator __last,
+     _OutputIterator1 __out_true, _OutputIterator2 __out_false,
+     _Predicate __pred)
+    {
+
+     
+     
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   {
+     *__out_true = *__first;
+     ++__out_true;
+   }
+ else
+   {
+     *__out_false = *__first;
+     ++__out_false;
+   }
+
+      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
+    }
+
+
+  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;
+    }
+# 867 "/usr/include/c++/10.2.0/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));
+    }
+# 901 "/usr/include/c++/10.2.0/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;
+    }
+# 970 "/usr/include/c++/10.2.0/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());
+    }
+# 1001 "/usr/include/c++/10.2.0/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;
+ }
+    }
+# 1162 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+   
+    inline void
+    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    {
+
+     
+
+      ;
+      std::__reverse(__first, __last, std::__iterator_category(__first));
+    }
+# 1190 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _OutputIterator>
+   
+    _OutputIterator
+    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
+   _OutputIterator __result)
+    {
+
+     
+
+     
+
+      ;
+
+      while (__first != __last)
+ {
+   --__last;
+   *__result = *__last;
+   ++__result;
+ }
+      return __result;
+    }
+
+
+
+
+
+  template<typename _EuclideanRingElement>
+   
+    _EuclideanRingElement
+    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
+    {
+      while (__n != 0)
+ {
+   _EuclideanRingElement __t = __m % __n;
+   __m = __n;
+   __n = __t;
+ }
+      return __m;
+    }
+
+  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);
+     }
+ }
+    }
+# 1422 "/usr/include/c++/10.2.0/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));
+    }
+
+  }
+# 1460 "/usr/include/c++/10.2.0/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;
+ }
+    }
+# 1540 "/usr/include/c++/10.2.0/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);
+
+      return std::rotate(__left_split, __middle, __right_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, std::distance(__first, __last));
+      return
+ std::__stable_partition_adaptive(__first, __last, __pred,
+      _DistanceType(__buf.requested_size()),
+      __buf.begin(),
+      _DistanceType(__buf.size()));
+    }
+# 1642 "/usr/include/c++/10.2.0/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;
+    }
+# 1730 "/usr/include/c++/10.2.0/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)
+    {
+# 1745 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+     
+     
+
+     
+
+     
+      ;
+      ;
+      ;
+
+      return std::__partial_sort_copy(__first, __last,
+          __result_first, __result_last,
+          __gnu_cxx::__ops::__iter_less_iter());
+    }
+# 1780 "/usr/include/c++/10.2.0/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)
+    {
+# 1797 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+     
+     
+
+     
+
+     
+
+     
+
+      ;
+      ;
+      ;
+
+      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);
+    }
+# 2028 "/usr/include/c++/10.2.0/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)
+    {
+
+     
+     
+
+     
+                    ;
+
+      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;
+    }
+# 2084 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    inline _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+
+      return std::__upper_bound(__first, __last, __val,
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+# 2115 "/usr/include/c++/10.2.0/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)
+    {
+
+     
+     
+
+     
+                    ;
+
+      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);
+    }
+# 2188 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    inline pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+
+     
+     
+
+     
+
+      ;
+      ;
+
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_less_val(),
+    __gnu_cxx::__ops::__val_less_iter());
+    }
+# 2225 "/usr/include/c++/10.2.0/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)
+    {
+
+     
+     
+
+     
+
+     
+                    ;
+     
+                    ;
+
+      return std::__equal_range(__first, __last, __val,
+    __gnu_cxx::__ops::__iter_comp_val(__comp),
+    __gnu_cxx::__ops::__val_comp_iter(__comp));
+    }
+# 2259 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      _ForwardIterator __i
+ = std::__lower_bound(__first, __last, __val,
+        __gnu_cxx::__ops::__iter_less_val());
+      return __i != __last && !(__val < *__i);
+    }
+# 2293 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+   
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __val, _Compare __comp)
+    {
+
+     
+     
+
+     
+                    ;
+     
+                    ;
+
+      _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
+ return std::rotate(__first, __middle, __last);
+    }
+
+
+  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);
+ }
+
+      _BidirectionalIterator __new_middle
+ = std::rotate(__first_cut, __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, __len1 + __len2);
+
+      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);
+    }
+# 2583 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/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);
+    }
+# 2797 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+   
+    bool
+    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _Compare __comp)
+    {
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(__first2, __first1))
+   return false;
+ else if (__comp(__first1, __first2))
+   ++__first1;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+
+      return __first2 == __last2;
+    }
+# 2837 "/usr/include/c++/10.2.0/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());
+    }
+# 2882 "/usr/include/c++/10.2.0/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));
+    }
+# 2918 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+   
+    bool
+    __next_permutation(_BidirectionalIterator __first,
+         _BidirectionalIterator __last, _Compare __comp)
+    {
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(__i, __ii))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!__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;
+     }
+ }
+    }
+# 2968 "/usr/include/c++/10.2.0/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());
+    }
+# 3001 "/usr/include/c++/10.2.0/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;
+     }
+ }
+    }
+# 3071 "/usr/include/c++/10.2.0/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());
+    }
+# 3104 "/usr/include/c++/10.2.0/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, (void)++__result)
+ if (__pred(__first))
+   *__result = __new_value;
+ else
+   *__result = *__first;
+      return __result;
+    }
+# 3156 "/usr/include/c++/10.2.0/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);
+    }
+# 3191 "/usr/include/c++/10.2.0/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);
+    }
+# 3220 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+   
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
+    { return std::is_sorted_until(__first, __last) == __last; }
+# 3235 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+   
+    inline bool
+    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
+       _Compare __comp)
+    { return std::is_sorted_until(__first, __last, __comp) == __last; }
+
+  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, (void)++__next)
+ if (__comp(__next, __first))
+   return __next;
+      return __next;
+    }
+# 3266 "/usr/include/c++/10.2.0/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());
+    }
+# 3291 "/usr/include/c++/10.2.0/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));
+    }
+# 3317 "/usr/include/c++/10.2.0/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);
+    }
+# 3338 "/usr/include/c++/10.2.0/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);
+    }
+# 3418 "/usr/include/c++/10.2.0/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());
+    }
+# 3446 "/usr/include/c++/10.2.0/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);
+    }
+# 3523 "/usr/include/c++/10.2.0/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, (void)++__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;
+    }
+# 3618 "/usr/include/c++/10.2.0/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());
+    }
+# 3646 "/usr/include/c++/10.2.0/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));
+    }
+# 3723 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _IntType, typename _UniformRandomBitGenerator>
+    pair<_IntType, _IntType>
+    __gen_two_uniform_ints(_IntType __b0, _IntType __b1,
+      _UniformRandomBitGenerator&& __g)
+    {
+      _IntType __x
+ = uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g);
+      return std::make_pair(__x / __b1, __x % __b1);
+    }
+# 3745 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator,
+    typename _UniformRandomNumberGenerator>
+    void
+    shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+     _UniformRandomNumberGenerator&& __g)
+    {
+
+     
+
+      ;
+
+      if (__first == __last)
+ return;
+
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+      typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
+      typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
+      typedef typename __distr_type::param_type __p_type;
+
+      typedef typename remove_reference<_UniformRandomNumberGenerator>::type
+ _Gen;
+      typedef typename common_type<typename _Gen::result_type, __ud_type>::type
+ __uc_type;
+
+      const __uc_type __urngrange = __g.max() - __g.min();
+      const __uc_type __urange = __uc_type(__last - __first);
+
+      if (__urngrange / __urange >= __urange)
+
+      {
+ _RandomAccessIterator __i = __first + 1;
+
+
+
+
+
+ if ((__urange % 2) == 0)
+ {
+   __distr_type __d{0, 1};
+   std::iter_swap(__i++, __first + __d(__g));
+ }
+
+
+
+
+
+ while (__i != __last)
+ {
+   const __uc_type __swap_range = __uc_type(__i - __first) + 1;
+
+   const pair<__uc_type, __uc_type> __pospos =
+     __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g);
+
+   std::iter_swap(__i++, __first + __pospos.first);
+   std::iter_swap(__i++, __first + __pospos.second);
+ }
+
+ return;
+      }
+
+      __distr_type __d;
+
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
+    }
+
+
+
+
+
+# 3830 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Function>
+   
+    _Function
+    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
+    {
+
+     
+      ;
+      for (; __first != __last; ++__first)
+ __f(*__first);
+      return __f;
+    }
+# 3891 "/usr/include/c++/10.2.0/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));
+    }
+# 3916 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+   
+    inline _InputIterator
+    find_if(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+
+     
+     
+
+      ;
+
+      return std::__find_if(__first, __last,
+       __gnu_cxx::__ops::__pred_iter(__pred));
+    }
+# 3948 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _ForwardIterator>
+   
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (*__first1 == *__iter)
+     return __first1;
+      return __last1;
+    }
+# 3989 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+   
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2,
+    _BinaryPredicate __comp)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (__comp(*__first1, *__iter))
+     return __first1;
+      return __last1;
+    }
+# 4022 "/usr/include/c++/10.2.0/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());
+    }
+# 4048 "/usr/include/c++/10.2.0/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));
+    }
+# 4074 "/usr/include/c++/10.2.0/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));
+    }
+# 4098 "/usr/include/c++/10.2.0/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));
+    }
+# 4139 "/usr/include/c++/10.2.0/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());
+    }
+# 4179 "/usr/include/c++/10.2.0/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));
+    }
+# 4215 "/usr/include/c++/10.2.0/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));
+    }
+# 4249 "/usr/include/c++/10.2.0/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));
+    }
+# 4298 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _UnaryOperation>
+   
+    _OutputIterator
+    transform(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _UnaryOperation __unary_op)
+    {
+
+     
+     
+
+
+      ;
+
+      for (; __first != __last; ++__first, (void)++__result)
+ *__result = __unary_op(*__first);
+      return __result;
+    }
+# 4336 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _BinaryOperation>
+   
+    _OutputIterator
+    transform(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _OutputIterator __result,
+       _BinaryOperation __binary_op)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
+ *__result = __binary_op(*__first1, *__first2);
+      return __result;
+    }
+# 4370 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    void
+    replace(_ForwardIterator __first, _ForwardIterator __last,
+     const _Tp& __old_value, const _Tp& __new_value)
+    {
+
+     
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (*__first == __old_value)
+   *__first = __new_value;
+    }
+# 4403 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
+   
+    void
+    replace_if(_ForwardIterator __first, _ForwardIterator __last,
+        _Predicate __pred, const _Tp& __new_value)
+    {
+
+     
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   *__first = __new_value;
+    }
+# 4436 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Generator>
+   
+    void
+    generate(_ForwardIterator __first, _ForwardIterator __last,
+      _Generator __gen)
+    {
+
+     
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ *__first = __gen();
+    }
+# 4470 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+   
+    _OutputIterator
+    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
+    {
+
+     
+
+
+
+      typedef __decltype(std::__size_to_integer(__n)) _IntSize;
+      for (_IntSize __niter = std::__size_to_integer(__n);
+    __niter > 0; --__niter, (void) ++__first)
+ *__first = __gen();
+      return __first;
+    }
+# 4508 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator>
+   
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+    __gnu_cxx::__ops::__iter_equal_to_iter(),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4549 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+   
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result,
+  _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4583 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+      ;
+
+      if (__first != __last)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+   {
+
+     _RandomAccessIterator __j = __first
+     + std::rand() % ((__i - __first) + 1);
+     if (__i != __j)
+       std::iter_swap(__i, __j);
+   }
+    }
+# 4618 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+
+     _RandomNumberGenerator&& __rand)
+
+
+
+    {
+
+     
+
+      ;
+
+      if (__first == __last)
+ return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
+   if (__i != __j)
+     std::iter_swap(__i, __j);
+ }
+    }
+# 4658 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+   
+    inline _ForwardIterator
+    partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__partition(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+# 4692 "/usr/include/c++/10.2.0/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());
+    }
+# 4731 "/usr/include/c++/10.2.0/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));
+    }
+# 4768 "/usr/include/c++/10.2.0/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());
+    }
+# 4808 "/usr/include/c++/10.2.0/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));
+    }
+# 4846 "/usr/include/c++/10.2.0/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());
+    }
+# 4877 "/usr/include/c++/10.2.0/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));
+    }
+# 4940 "/usr/include/c++/10.2.0/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());
+    }
+# 4991 "/usr/include/c++/10.2.0/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, std::distance(__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);
+    }
+# 5056 "/usr/include/c++/10.2.0/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());
+    }
+# 5090 "/usr/include/c++/10.2.0/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));
+    }
+# 5160 "/usr/include/c++/10.2.0/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());
+    }
+# 5211 "/usr/include/c++/10.2.0/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;
+    }
+# 5284 "/usr/include/c++/10.2.0/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());
+    }
+# 5334 "/usr/include/c++/10.2.0/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);
+    }
+# 5409 "/usr/include/c++/10.2.0/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());
+    }
+# 5461 "/usr/include/c++/10.2.0/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));
+    }
+# 5542 "/usr/include/c++/10.2.0/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());
+    }
+# 5594 "/usr/include/c++/10.2.0/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;
+    }
+# 5648 "/usr/include/c++/10.2.0/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());
+    }
+# 5673 "/usr/include/c++/10.2.0/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;
+    }
+# 5712 "/usr/include/c++/10.2.0/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());
+    }
+# 5737 "/usr/include/c++/10.2.0/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));
+    }
+
+
+
+  template<typename _InputIterator, typename _RandomAccessIterator,
+           typename _Size, typename _UniformRandomBitGenerator>
+    _RandomAccessIterator
+    __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
+      _RandomAccessIterator __out, random_access_iterator_tag,
+      _Size __n, _UniformRandomBitGenerator&& __g)
+    {
+      using __distrib_type = uniform_int_distribution<_Size>;
+      using __param_type = typename __distrib_type::param_type;
+      __distrib_type __d{};
+      _Size __sample_sz = 0;
+      while (__first != __last && __sample_sz != __n)
+ {
+   __out[__sample_sz++] = *__first;
+   ++__first;
+ }
+      for (auto __pop_sz = __sample_sz; __first != __last;
+   ++__first, (void) ++__pop_sz)
+ {
+   const auto __k = __d(__g, __param_type{0, __pop_sz});
+   if (__k < __n)
+     __out[__k] = *__first;
+ }
+      return __out + __sample_sz;
+    }
+
+
+  template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
+           typename _Size, typename _UniformRandomBitGenerator>
+    _OutputIterator
+    __sample(_ForwardIterator __first, _ForwardIterator __last,
+      forward_iterator_tag,
+      _OutputIterator __out, _Cat,
+      _Size __n, _UniformRandomBitGenerator&& __g)
+    {
+      using __distrib_type = uniform_int_distribution<_Size>;
+      using __param_type = typename __distrib_type::param_type;
+      using _USize = make_unsigned_t<_Size>;
+      using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
+      using __uc_type = common_type_t<typename _Gen::result_type, _USize>;
+
+      __distrib_type __d{};
+      _Size __unsampled_sz = std::distance(__first, __last);
+      __n = std::min(__n, __unsampled_sz);
+
+
+
+
+      const __uc_type __urngrange = __g.max() - __g.min();
+      if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))
+
+
+        {
+   while (__n != 0 && __unsampled_sz >= 2)
+     {
+       const pair<_Size, _Size> __p =
+  __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);
+
+       --__unsampled_sz;
+       if (__p.first < __n)
+  {
+    *__out++ = *__first;
+    --__n;
+  }
+
+       ++__first;
+
+       if (__n == 0) break;
+
+       --__unsampled_sz;
+       if (__p.second < __n)
+  {
+    *__out++ = *__first;
+    --__n;
+  }
+
+       ++__first;
+     }
+        }
+
+
+
+      for (; __n != 0; ++__first)
+ if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
+   {
+     *__out++ = *__first;
+     --__n;
+   }
+      return __out;
+    }
+# 5880 "/usr/include/c++/10.2.0/bits/stl_algo.h" 3
+
+
+}
+# 63 "/usr/include/c++/10.2.0/algorithm" 2 3
+# 15 "/home/ted/dev/openrct2/src/openrct2/world/Location.hpp" 2
+
+
+# 16 "/home/ted/dev/openrct2/src/openrct2/world/Location.hpp"
+constexpr const int16_t LOCATION_NULL = -32768;
+
+constexpr const int32_t COORDS_XY_STEP = 32;
+constexpr const int32_t COORDS_XY_HALF_TILE = (COORDS_XY_STEP / 2);
+constexpr const int32_t COORDS_Z_STEP = 8;
+constexpr const int32_t COORDS_Z_PER_TINY_Z = 16;
+
+constexpr const auto NumOrthogonalDirections = 4;
+
+#pragma pack(push, 1)
+
+struct LocationXY16
+{
+    int16_t x, y;
+};
+static_assert(sizeof(LocationXY16) == (4), "Improper struct size");
+
+struct LocationXYZ16
+{
+    int16_t x, y, z;
+};
+static_assert(sizeof(LocationXYZ16) == (6), "Improper struct size");
+#pragma pack(pop)
+
+constexpr int32_t COORDS_NULL = 0xFFFF8000;
+
+struct ScreenCoordsXY
+{
+    int32_t x = 0;
+    int32_t y = 0;
+
+    ScreenCoordsXY() = default;
+    constexpr ScreenCoordsXY(int32_t _x, int32_t _y)
+        : x(_x)
+        , y(_y)
+    {
+    }
+
+    const ScreenCoordsXY operator-(const ScreenCoordsXY& rhs) const
+    {
+        return { x - rhs.x, y - rhs.y };
+    }
+
+    ScreenCoordsXY& operator+=(const ScreenCoordsXY& rhs)
+    {
+        x += rhs.x;
+        y += rhs.y;
+        return *this;
+    }
+
+    ScreenCoordsXY& operator-=(const ScreenCoordsXY& rhs)
+    {
+        x -= rhs.x;
+        y -= rhs.y;
+        return *this;
+    }
+
+    const ScreenCoordsXY operator+(const ScreenCoordsXY& rhs) const
+    {
+        return { x + rhs.x, y + rhs.y };
+    }
+
+    bool operator==(const ScreenCoordsXY& other) const
+    {
+        return x == other.x && y == other.y;
+    }
+
+    bool operator!=(const ScreenCoordsXY& other) const
+    {
+        return !(*this == other);
+    }
+};
+
+struct ScreenSize
+{
+    int32_t width{};
+    int32_t height{};
+
+    ScreenSize() = default;
+    constexpr ScreenSize(int32_t _width, int32_t _height)
+        : width(_width)
+        , height(_height)
+    {
+    }
+
+    bool operator==(const ScreenSize& other) const
+    {
+        return width == other.width && height == other.height;
+    }
+
+    bool operator!=(const ScreenSize& other) const
+    {
+        return !(*this == other);
+    }
+};
+
+
+
+
+
+struct CoordsXY
+{
+    int32_t x = 0;
+    int32_t y = 0;
+
+    CoordsXY() = default;
+    constexpr CoordsXY(int32_t _x, int32_t _y)
+        : x(_x)
+        , y(_y)
+    {
+    }
+
+    constexpr CoordsXY& operator+=(const CoordsXY& rhs)
+    {
+        x += rhs.x;
+        y += rhs.y;
+        return *this;
+    }
+
+    constexpr CoordsXY& operator-=(const CoordsXY& rhs)
+    {
+        x -= rhs.x;
+        y -= rhs.y;
+        return *this;
+    }
+
+    constexpr CoordsXY& operator*=(const int32_t rhs)
+    {
+        x *= rhs;
+        y *= rhs;
+        return *this;
+    }
+
+    constexpr CoordsXY& operator/=(const int32_t rhs)
+    {
+        x /= rhs;
+        y /= rhs;
+        return *this;
+    }
+
+    constexpr bool operator>=(const CoordsXY& rhs) const
+    {
+        return x >= rhs.x && y >= rhs.y;
+    }
+
+    constexpr bool operator<=(const CoordsXY& rhs) const
+    {
+        return x <= rhs.x && y <= rhs.y;
+    }
+
+    constexpr const CoordsXY operator+(const CoordsXY& rhs) const
+    {
+        return { x + rhs.x, y + rhs.y };
+    }
+
+    constexpr const CoordsXY operator-(const CoordsXY& rhs) const
+    {
+        return { x - rhs.x, y - rhs.y };
+    }
+
+    constexpr const CoordsXY operator*(const int32_t rhs) const
+    {
+        return { x * rhs, y * rhs };
+    }
+
+    constexpr const CoordsXY operator/(const int32_t rhs) const
+    {
+        return { x / rhs, y / rhs };
+    }
+
+    constexpr CoordsXY Rotate(int32_t direction) const
+    {
+        CoordsXY rotatedCoords;
+        switch (direction & 3)
+        {
+            default:
+            case 0:
+                rotatedCoords.x = x;
+                rotatedCoords.y = y;
+                break;
+            case 1:
+                rotatedCoords.x = y;
+                rotatedCoords.y = -x;
+                break;
+            case 2:
+                rotatedCoords.x = -x;
+                rotatedCoords.y = -y;
+                break;
+            case 3:
+                rotatedCoords.x = -y;
+                rotatedCoords.y = x;
+                break;
+        }
+
+        return rotatedCoords;
+    }
+
+    constexpr bool operator==(const CoordsXY& other) const
+    {
+        return x == other.x && y == other.y;
+    }
+
+    constexpr bool operator!=(const CoordsXY& other) const
+    {
+        return !(*this == other);
+    }
+
+    constexpr CoordsXY ToTileCentre() const
+    {
+        return ToTileStart() + CoordsXY{ COORDS_XY_HALF_TILE, COORDS_XY_HALF_TILE };
+    }
+
+    constexpr CoordsXY ToTileStart() const
+    {
+        return { floor2(x, COORDS_XY_STEP), floor2(y, COORDS_XY_STEP) };
+    }
+
+    constexpr bool isNull() const
+    {
+        return x == COORDS_NULL;
+    };
+
+    constexpr void setNull()
+    {
+        x = COORDS_NULL;
+        y = 0;
+    }
+};
+
+struct CoordsXYZ : public CoordsXY
+{
+    int32_t z = 0;
+
+    CoordsXYZ() = default;
+    constexpr CoordsXYZ(int32_t _x, int32_t _y, int32_t _z)
+        : CoordsXY(_x, _y)
+        , z(_z)
+    {
+    }
+
+    constexpr CoordsXYZ(const CoordsXY& c, int32_t _z)
+        : CoordsXY(c)
+        , z(_z)
+    {
+    }
+
+    const CoordsXYZ operator+(const CoordsXYZ& rhs) const
+    {
+        return { x + rhs.x, y + rhs.y, z + rhs.z };
+    }
+
+    const CoordsXYZ operator-(const CoordsXYZ& rhs) const
+    {
+        return { x - rhs.x, y - rhs.y, z - rhs.z };
+    }
+
+    bool operator==(const CoordsXYZ& other) const
+    {
+        return x == other.x && y == other.y && z == other.z;
+    }
+
+    CoordsXYZ ToTileStart() const
+    {
+        return { floor2(x, COORDS_XY_STEP), floor2(y, COORDS_XY_STEP), z };
+    }
+
+    CoordsXYZ ToTileCentre() const
+    {
+        return ToTileStart() + CoordsXYZ{ COORDS_XY_HALF_TILE, COORDS_XY_HALF_TILE, 0 };
+    }
+};
+
+struct CoordsXYRangedZ : public CoordsXY
+{
+    int32_t baseZ = 0;
+    int32_t clearanceZ = 0;
+
+    CoordsXYRangedZ() = default;
+    constexpr CoordsXYRangedZ(int32_t _x, int32_t _y, int32_t _baseZ, int32_t _clearanceZ)
+        : CoordsXY(_x, _y)
+        , baseZ(_baseZ)
+        , clearanceZ(_clearanceZ)
+    {
+    }
+
+    constexpr CoordsXYRangedZ(const CoordsXY& _c, int32_t _baseZ, int32_t _clearanceZ)
+        : CoordsXY(_c)
+        , baseZ(_baseZ)
+        , clearanceZ(_clearanceZ)
+    {
+    }
+
+    constexpr CoordsXYRangedZ(const CoordsXYZ& _c, int32_t _clearanceZ)
+        : CoordsXY(_c)
+        , baseZ(_c.z)
+        , clearanceZ(_clearanceZ)
+    {
+    }
+};
+
+struct TileCoordsXY
+{
+    int32_t x = 0;
+    int32_t y = 0;
+
+    TileCoordsXY() = default;
+    constexpr TileCoordsXY(int32_t x_, int32_t y_)
+        : x(x_)
+        , y(y_)
+    {
+    }
+
+    explicit TileCoordsXY(const CoordsXY& c)
+        : x(c.x / COORDS_XY_STEP)
+        , y(c.y / COORDS_XY_STEP)
+    {
+    }
+
+    const TileCoordsXY operator+(const TileCoordsXY& rhs) const
+    {
+        return { x + rhs.x, y + rhs.y };
+    }
+
+    TileCoordsXY& operator+=(const TileCoordsXY& rhs)
+    {
+        x += rhs.x;
+        y += rhs.y;
+        return *this;
+    }
+
+    TileCoordsXY& operator-=(const TileCoordsXY& rhs)
+    {
+        x -= rhs.x;
+        y -= rhs.y;
+        return *this;
+    }
+
+    CoordsXY ToCoordsXY() const
+    {
+        if (isNull())
+        {
+            CoordsXY ret{};
+            ret.setNull();
+            return ret;
+        }
+
+        return { x * COORDS_XY_STEP, y * COORDS_XY_STEP };
+    }
+
+    TileCoordsXY Rotate(int32_t direction) const
+    {
+        TileCoordsXY rotatedCoords;
+        switch (direction & 3)
+        {
+            default:
+            case 0:
+                rotatedCoords.x = x;
+                rotatedCoords.y = y;
+                break;
+            case 1:
+                rotatedCoords.x = y;
+                rotatedCoords.y = -x;
+                break;
+            case 2:
+                rotatedCoords.x = -x;
+                rotatedCoords.y = -y;
+                break;
+            case 3:
+                rotatedCoords.x = -y;
+                rotatedCoords.y = x;
+                break;
+        }
+
+        return rotatedCoords;
+    }
+
+    bool operator==(const TileCoordsXY& other) const
+    {
+        return x == other.x && y == other.y;
+    }
+
+    bool operator!=(const TileCoordsXY& other) const
+    {
+        return !(*this == other);
+    }
+
+    bool isNull() const
+    {
+        return x == COORDS_NULL;
+    };
+
+    void setNull()
+    {
+        x = COORDS_NULL;
+        y = 0;
+    }
+};
+
+struct TileCoordsXYZ : public TileCoordsXY
+{
+    int32_t z = 0;
+
+    TileCoordsXYZ() = default;
+    constexpr TileCoordsXYZ(int32_t x_, int32_t y_, int32_t z_)
+        : TileCoordsXY(x_, y_)
+        , z(z_)
+    {
+    }
+
+    TileCoordsXYZ(const TileCoordsXY& c, int32_t z_)
+        : TileCoordsXY(c.x, c.y)
+        , z(z_)
+    {
+    }
+
+    TileCoordsXYZ(const CoordsXY& c, int32_t z_)
+        : TileCoordsXY(c)
+        , z(z_)
+    {
+    }
+
+    explicit TileCoordsXYZ(const CoordsXYZ& c)
+        : TileCoordsXY(c)
+        , z(c.z / COORDS_Z_STEP)
+    {
+    }
+
+    TileCoordsXYZ& operator+=(const TileCoordsXY& rhs)
+    {
+        x += rhs.x;
+        y += rhs.y;
+        return *this;
+    }
+
+    TileCoordsXYZ& operator-=(const TileCoordsXY& rhs)
+    {
+        x -= rhs.x;
+        y -= rhs.y;
+        return *this;
+    }
+
+    bool operator==(const TileCoordsXYZ& other) const
+    {
+        return x == other.x && y == other.y && z == other.z;
+    }
+
+    bool operator!=(const TileCoordsXYZ& other) const
+    {
+        return !(*this == other);
+    }
+
+    CoordsXYZ ToCoordsXYZ() const
+    {
+        if (isNull())
+        {
+            CoordsXYZ ret{};
+            ret.setNull();
+            return ret;
+        }
+        return { x * COORDS_XY_STEP, y * COORDS_XY_STEP, z * COORDS_Z_STEP };
+    }
+};
+# 488 "/home/ted/dev/openrct2/src/openrct2/world/Location.hpp"
+using Direction = uint8_t;
+
+const Direction INVALID_DIRECTION = 0xFF;
+
+
+
+
+
+constexpr Direction ALL_DIRECTIONS[] = { 0, 1, 2, 3 };
+
+
+
+
+
+[[maybe_unused]] static constexpr Direction direction_reverse(Direction dir)
+{
+    return dir ^ 2;
+}
+
+[[maybe_unused]] static constexpr bool direction_valid(Direction dir)
+{
+    return dir < NumOrthogonalDirections;
+}
+
+
+
+
+
+[[maybe_unused]] static constexpr Direction direction_next(Direction dir)
+{
+    return (dir + 1) & 0x03;
+}
+
+
+
+
+
+[[maybe_unused]] static constexpr Direction direction_prev(Direction dir)
+{
+    return (dir - 1) & 0x03;
+}
+
+
+
+
+[[maybe_unused]] static constexpr Direction DirectionFromTo(const CoordsXY& from, const CoordsXY& to)
+{
+    int16_t x_diff = to.x - from.x;
+    int16_t y_diff = to.y - from.y;
+
+    int16_t abs_x = x_diff < 0 ? -x_diff : x_diff;
+    int16_t abs_y = y_diff < 0 ? -y_diff : y_diff;
+
+    if (abs_x <= abs_y)
+    {
+        return y_diff < 0 ? 3 : 1;
+    }
+    else
+    {
+        return x_diff < 0 ? 0 : 2;
+    }
+}
+
+struct CoordsXYZD : public CoordsXYZ
+{
+    Direction direction = 0;
+
+    CoordsXYZD() = default;
+    constexpr CoordsXYZD(int32_t _x, int32_t _y, int32_t _z, Direction _d)
+        : CoordsXYZ(_x, _y, _z)
+        , direction(_d)
+    {
+    }
+
+    constexpr CoordsXYZD(const CoordsXY& _c, int32_t _z, Direction _d)
+        : CoordsXYZ(_c, _z)
+        , direction(_d)
+    {
+    }
+
+    constexpr CoordsXYZD(const CoordsXYZ& _c, Direction _d)
+        : CoordsXYZ(_c)
+        , direction(_d)
+    {
+    }
+
+    bool operator==(const CoordsXYZD& other) const
+    {
+        return x == other.x && y == other.y && z == other.z && direction == other.direction;
+    }
+
+    bool operator!=(const CoordsXYZD& other) const
+    {
+        return !(*this == other);
+    }
+
+    CoordsXYZD& operator+=(const CoordsXY& rhs)
+    {
+        x += rhs.x;
+        y += rhs.y;
+        return *this;
+    }
+
+    const CoordsXYZD operator+(const CoordsXY& rhs) const
+    {
+        return { x + rhs.x, y + rhs.y, z, direction };
+    }
+
+    const CoordsXYZD operator+(const CoordsXYZ& rhs) const
+    {
+        return { x + rhs.x, y + rhs.y, z + rhs.z, direction };
+    }
+
+    const CoordsXYZD operator-(const CoordsXY& rhs) const
+    {
+        return { x - rhs.x, y - rhs.y, z, direction };
+    }
+
+    const CoordsXYZD operator-(const CoordsXYZ& rhs) const
+    {
+        return { x - rhs.x, y - rhs.y, z - rhs.z, direction };
+    }
+
+    CoordsXYZD ToTileStart() const
+    {
+        return { floor2(x, COORDS_XY_STEP), floor2(y, COORDS_XY_STEP), z, direction };
+    }
+
+    CoordsXYZD ToTileCentre() const
+    {
+        return ToTileStart() + CoordsXYZD{ COORDS_XY_HALF_TILE, COORDS_XY_HALF_TILE, 0, 0 };
+    }
+};
+
+struct TileCoordsXYZD : public TileCoordsXYZ
+{
+    Direction direction;
+
+    TileCoordsXYZD() = default;
+    constexpr TileCoordsXYZD(int32_t x_, int32_t y_, int32_t z_, Direction d_)
+        : TileCoordsXYZ(x_, y_, z_)
+        , direction(d_)
+    {
+    }
+
+    TileCoordsXYZD(const TileCoordsXY& t_, int32_t z_, Direction d_)
+        : TileCoordsXYZ(t_, z_)
+        , direction(d_)
+    {
+    }
+
+    TileCoordsXYZD(const CoordsXY& c_, int32_t z_, Direction d_)
+        : TileCoordsXYZ(c_, z_)
+        , direction(d_)
+    {
+    }
+
+    TileCoordsXYZD(const CoordsXYZ& c_, Direction d_)
+        : TileCoordsXYZ(c_)
+        , direction(d_)
+    {
+    }
+
+    TileCoordsXYZD(const CoordsXYZD& c_)
+        : TileCoordsXYZ(c_)
+        , direction(c_.direction)
+    {
+    }
+
+    CoordsXYZD ToCoordsXYZD() const
+    {
+        if (isNull())
+        {
+            CoordsXYZD ret{};
+            ret.setNull();
+            return ret;
+        }
+        return { x * COORDS_XY_STEP, y * COORDS_XY_STEP, z * COORDS_Z_STEP, direction };
+    }
+};
+
+
+
+
+template<class T> struct CoordsRange
+{
+    T Point1{ 0, 0 };
+    T Point2{ 0, 0 };
+
+    int32_t GetX1() const
+    {
+        return Point1.x;
+    }
+    int32_t GetY1() const
+    {
+        return Point1.y;
+    }
+    int32_t GetX2() const
+    {
+        return Point2.x;
+    }
+    int32_t GetY2() const
+    {
+        return Point2.y;
+    }
+
+    CoordsRange() = default;
+    CoordsRange(int32_t x1, int32_t y1, int32_t x2, int32_t y2)
+        : CoordsRange({ x1, y1 }, { x2, y2 })
+    {
+    }
+
+    CoordsRange(const T& pointOne, const T& pointTwo)
+        : Point1(pointOne)
+        , Point2(pointTwo)
+    {
+    }
+};
+
+template<class T> struct RectRange : public CoordsRange<T>
+{
+    using CoordsRange<T>::CoordsRange;
+
+    int32_t GetLeft() const
+    {
+        return CoordsRange<T>::GetX1();
+    }
+    int32_t GetTop() const
+    {
+        return CoordsRange<T>::GetY1();
+    }
+    int32_t GetRight() const
+    {
+        return CoordsRange<T>::GetX2();
+    }
+    int32_t GetBottom() const
+    {
+        return CoordsRange<T>::GetY2();
+    }
+
+    RectRange(int32_t left, int32_t top, int32_t right, int32_t bottom)
+        : RectRange({ left, top }, { right, bottom })
+    {
+    }
+
+    RectRange(const T& leftTop, const T& rightBottom)
+        : CoordsRange<T>(leftTop, rightBottom)
+    {
+    }
+};
+
+
+
+
+
+struct MapRange : public RectRange<CoordsXY>
+{
+    using RectRange::RectRange;
+
+    MapRange Normalise() const
+    {
+        auto result = MapRange(
+            std::min(GetLeft(), GetRight()), std::min(GetTop(), GetBottom()), std::max(GetLeft(), GetRight()),
+            std::max(GetTop(), GetBottom()));
+        return result;
+    }
+};
+
+
+
+
+
+struct ScreenLine : public CoordsRange<ScreenCoordsXY>
+{
+    ScreenLine(const ScreenCoordsXY& leftTop, const ScreenCoordsXY& rightBottom)
+        : CoordsRange<ScreenCoordsXY>(leftTop, rightBottom)
+    {
+    }
+};
+
+
+
+
+
+struct ScreenRect : public RectRange<ScreenCoordsXY>
+{
+    using RectRange::RectRange;
+
+    int32_t GetWidth() const
+    {
+        return GetRight() - GetLeft();
+    }
+    int32_t GetHeight() const
+    {
+        return GetBottom() - GetTop();
+    }
+    bool Contains(const ScreenCoordsXY& coords) const
+    {
+        return coords.x >= GetLeft() && coords.x <= GetRight() && coords.y >= GetTop() && coords.y <= GetBottom();
+    }
+};
+# 14 "/home/ted/dev/openrct2/src/openrct2/Context.h" 2
+
+# 1 "/usr/include/c++/10.2.0/memory" 1 3
+# 47 "/usr/include/c++/10.2.0/memory" 3
+       
+# 48 "/usr/include/c++/10.2.0/memory" 3
+# 68 "/usr/include/c++/10.2.0/memory" 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_raw_storage_iter.h" 1 3
+# 59 "/usr/include/c++/10.2.0/bits/stl_raw_storage_iter.h" 3
+
+# 59 "/usr/include/c++/10.2.0/bits/stl_raw_storage_iter.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  template <class _OutputIterator, class _Tp>
+    class raw_storage_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _OutputIterator _M_iter;
+
+    public:
+      explicit
+      raw_storage_iterator(_OutputIterator __x)
+      : _M_iter(__x) {}
+
+      raw_storage_iterator&
+      operator*() { return *this; }
+
+      raw_storage_iterator&
+      operator=(const _Tp& __element)
+      {
+ std::_Construct(std::__addressof(*_M_iter), __element);
+ return *this;
+      }
+
+
+
+
+      raw_storage_iterator&
+      operator=(_Tp&& __element)
+      {
+ std::_Construct(std::__addressof(*_M_iter), std::move(__element));
+ return *this;
+      }
+
+
+      raw_storage_iterator&
+      operator++()
+      {
+ ++_M_iter;
+ return *this;
+      }
+
+      raw_storage_iterator
+      operator++(int)
+      {
+ raw_storage_iterator __tmp = *this;
+ ++_M_iter;
+ return __tmp;
+      }
+
+
+
+      _OutputIterator base() const { return _M_iter; }
+    };
+
+
+}
+# 69 "/usr/include/c++/10.2.0/memory" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/ranges_uninitialized.h" 1 3
+# 70 "/usr/include/c++/10.2.0/memory" 2 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/ext/concurrence.h" 1 3
+# 32 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+       
+# 33 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+
+
+
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  enum _Lock_policy { _S_single, _S_mutex, _S_atomic };
+
+
+
+  static const _Lock_policy __default_lock_policy =
+
+
+
+  _S_atomic;
+
+
+
+
+
+
+  class __concurrence_lock_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_lock_error"; }
+  };
+
+  class __concurrence_unlock_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_unlock_error"; }
+  };
+
+  class __concurrence_broadcast_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_broadcast_error"; }
+  };
+
+  class __concurrence_wait_error : public std::exception
+  {
+  public:
+    virtual char const*
+    what() const throw()
+    { return "__gnu_cxx::__concurrence_wait_error"; }
+  };
+
+
+  inline void
+  __throw_concurrence_lock_error()
+  { (throw (__concurrence_lock_error())); }
+
+  inline void
+  __throw_concurrence_unlock_error()
+  { (throw (__concurrence_unlock_error())); }
+
+
+  inline void
+  __throw_concurrence_broadcast_error()
+  { (throw (__concurrence_broadcast_error())); }
+
+  inline void
+  __throw_concurrence_wait_error()
+  { (throw (__concurrence_wait_error())); }
+
+
+  class __mutex
+  {
+  private:
+
+    __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } };
+
+
+
+
+    __mutex(const __mutex&);
+    __mutex& operator=(const __mutex&);
+
+  public:
+    __mutex()
+    {
+
+
+
+
+    }
+# 144 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+    void lock()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_mutex_lock(&_M_mutex) != 0)
+     __throw_concurrence_lock_error();
+ }
+
+    }
+
+    void unlock()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_mutex_unlock(&_M_mutex) != 0)
+     __throw_concurrence_unlock_error();
+ }
+
+    }
+
+    __gthread_mutex_t* gthread_mutex(void)
+      { return &_M_mutex; }
+  };
+
+  class __recursive_mutex
+  {
+  private:
+
+    __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } };
+
+
+
+
+    __recursive_mutex(const __recursive_mutex&);
+    __recursive_mutex& operator=(const __recursive_mutex&);
+
+  public:
+    __recursive_mutex()
+    {
+
+
+
+
+    }
+# 199 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+    void lock()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_recursive_mutex_lock(&_M_mutex) != 0)
+     __throw_concurrence_lock_error();
+ }
+
+    }
+
+    void unlock()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0)
+     __throw_concurrence_unlock_error();
+ }
+
+    }
+
+    __gthread_recursive_mutex_t* gthread_recursive_mutex(void)
+    { return &_M_mutex; }
+  };
+
+
+
+
+  class __scoped_lock
+  {
+  public:
+    typedef __mutex __mutex_type;
+
+  private:
+    __mutex_type& _M_device;
+
+    __scoped_lock(const __scoped_lock&);
+    __scoped_lock& operator=(const __scoped_lock&);
+
+  public:
+    explicit __scoped_lock(__mutex_type& __name) : _M_device(__name)
+    { _M_device.lock(); }
+
+    ~__scoped_lock() throw()
+    { _M_device.unlock(); }
+  };
+
+
+  class __cond
+  {
+  private:
+
+    __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } };
+
+
+
+
+    __cond(const __cond&);
+    __cond& operator=(const __cond&);
+
+  public:
+    __cond()
+    {
+
+
+
+
+    }
+# 277 "/usr/include/c++/10.2.0/ext/concurrence.h" 3
+    void broadcast()
+    {
+
+      if (__gthread_active_p())
+ {
+   if (__gthread_cond_broadcast(&_M_cond) != 0)
+     __throw_concurrence_broadcast_error();
+ }
+
+    }
+
+    void wait(__mutex *mutex)
+    {
+
+      {
+   if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0)
+     __throw_concurrence_wait_error();
+      }
+
+    }
+
+    void wait_recursive(__recursive_mutex *mutex)
+    {
+
+      {
+   if (__gthread_cond_wait_recursive(&_M_cond,
+         mutex->gthread_recursive_mutex())
+       != 0)
+     __throw_concurrence_wait_error();
+      }
+
+    }
+  };
+
+
+
+}
+# 77 "/usr/include/c++/10.2.0/memory" 2 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/uses_allocator.h" 1 3
+# 35 "/usr/include/c++/10.2.0/bits/uses_allocator.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  struct __erased_type { };
+
+
+
+
+  template<typename _Alloc, typename _Tp>
+    using __is_erased_or_convertible
+      = __or_<is_convertible<_Alloc, _Tp>, is_same<_Tp, __erased_type>>;
+
+
+  struct allocator_arg_t { explicit allocator_arg_t() = default; };
+
+  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_erased_or_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, const _Alloc&, _Args...>::value,
+        __uses_alloc1<_Alloc>,
+        __uses_alloc2<_Alloc>>::type
+    {
+
+
+      static_assert(__or_<
+   is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>,
+   is_constructible<_Tp, _Args..., const _Alloc&>>::value,
+   "construction with an allocator must be possible"
+   " if uses_allocator is true");
+    };
+
+  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 = std::__addressof(__a);
+      return __ret;
+    }
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void
+    __use_alloc(const _Alloc&&) = delete;
+
+
+
+
+
+
+
+  template<template<typename...> class _Predicate,
+    typename _Tp, typename _Alloc, typename... _Args>
+    struct __is_uses_allocator_predicate
+    : conditional<uses_allocator<_Tp, _Alloc>::value,
+      __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>,
+     _Predicate<_Tp, _Args..., _Alloc>>,
+      _Predicate<_Tp, _Args...>>::type { };
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __is_uses_allocator_constructible
+    : __is_uses_allocator_predicate<is_constructible, _Tp, _Alloc, _Args...>
+    { };
+
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    constexpr bool __is_uses_allocator_constructible_v =
+      __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;
+
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    struct __is_nothrow_uses_allocator_constructible
+    : __is_uses_allocator_predicate<is_nothrow_constructible,
+        _Tp, _Alloc, _Args...>
+    { };
+
+
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    constexpr bool
+    __is_nothrow_uses_allocator_constructible_v =
+      __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;
+
+
+  template<typename _Tp, typename... _Args>
+    void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr,
+      _Args&&... __args)
+    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); }
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr,
+      _Args&&... __args)
+    {
+      ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a,
+          std::forward<_Args>(__args)...);
+    }
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr,
+      _Args&&... __args)
+    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); }
+
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr,
+        _Args&&... __args)
+    {
+      std::__uses_allocator_construct_impl(
+   std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr,
+   std::forward<_Args>(__args)...);
+    }
+
+
+}
+# 80 "/usr/include/c++/10.2.0/memory" 2 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+# 1 "/usr/include/c++/10.2.0/tuple" 1 3
+# 32 "/usr/include/c++/10.2.0/tuple" 3
+       
+# 33 "/usr/include/c++/10.2.0/tuple" 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/array" 1 3
+# 32 "/usr/include/c++/10.2.0/array" 3
+       
+# 33 "/usr/include/c++/10.2.0/array" 3
+# 43 "/usr/include/c++/10.2.0/array" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __array_traits
+    {
+      typedef _Tp _Type[_Nm];
+      typedef __is_swappable<_Tp> _Is_swappable;
+      typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;
+
+      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 { };
+     typedef true_type _Is_swappable;
+     typedef true_type _Is_nothrow_swappable;
+
+     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; }
+   };
+# 93 "/usr/include/c++/10.2.0/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(_AT_Type::_Is_nothrow_swappable::value)
+      { 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); }
+    };
+# 250 "/usr/include/c++/10.2.0/array" 3
+  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()); }
+# 275 "/usr/include/c++/10.2.0/array" 3
+  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
+
+
+    typename enable_if<
+      std::__array_traits<_Tp, _Nm>::_Is_swappable::value
+    >::type
+
+
+
+    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
+    noexcept(noexcept(__one.swap(__two)))
+    { __one.swap(__two); }
+
+
+  template<typename _Tp, std::size_t _Nm>
+    typename enable_if<
+      !std::__array_traits<_Tp, _Nm>::_Is_swappable::value>::type
+    swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;
+
+
+  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
+    constexpr _Tp&
+    get(array<_Tp, _Nm>& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within 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, "array index is within 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, "array index is within 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 const _Tp&&
+    get(const array<_Tp, _Nm>&& __arr) noexcept
+    {
+      static_assert(_Int < _Nm, "array index is within bounds");
+      return std::move(std::get<_Int>(__arr));
+    }
+# 404 "/usr/include/c++/10.2.0/array" 3
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  template<typename _Tp>
+    struct 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>
+    struct 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;
+    };
+
+  template<typename _Tp, std::size_t _Nm>
+    struct __is_tuple_like_impl<std::array<_Tp, _Nm>> : true_type
+    { };
+
+
+}
+# 40 "/usr/include/c++/10.2.0/tuple" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/invoke.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/invoke.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/invoke.h" 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 52 "/usr/include/c++/10.2.0/bits/invoke.h" 3
+  template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>
+    constexpr _Up&&
+    __invfwd(typename remove_reference<_Tp>::type& __t) noexcept
+    { return static_cast<_Up&&>(__t); }
+
+  template<typename _Res, typename _Fn, typename... _Args>
+    constexpr _Res
+    __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
+    { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    constexpr _Res
+    __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
+    _Args&&... __args)
+    { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }
+
+  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
+    constexpr _Res
+    __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
+    _Args&&... __args)
+    {
+      return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
+    }
+
+  template<typename _Res, typename _MemPtr, typename _Tp>
+    constexpr _Res
+    __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)
+    { return __invfwd<_Tp>(__t).*__f; }
+
+  template<typename _Res, typename _MemPtr, typename _Tp>
+    constexpr _Res
+    __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)
+    { return (*std::forward<_Tp>(__t)).*__f; }
+
+
+  template<typename _Callable, typename... _Args>
+    constexpr typename __invoke_result<_Callable, _Args...>::type
+    __invoke(_Callable&& __fn, _Args&&... __args)
+    noexcept(__is_nothrow_invocable<_Callable, _Args...>::value)
+    {
+      using __result = __invoke_result<_Callable, _Args...>;
+      using __type = typename __result::type;
+      using __tag = typename __result::__invoke_type;
+      return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
+     std::forward<_Args>(__args)...);
+    }
+# 118 "/usr/include/c++/10.2.0/bits/invoke.h" 3
+  template<typename _Res, typename _Callable, typename... _Args>
+    using __can_invoke_as_void = __enable_if_t<
+      __and_<is_void<_Res>, __is_invocable<_Callable, _Args...>>::value,
+      _Res
+    >;
+
+  template<typename _Res, typename _Callable, typename... _Args>
+    using __can_invoke_as_nonvoid = __enable_if_t<
+      __and_<__not_<is_void<_Res>>,
+      is_convertible<typename __invoke_result<_Callable, _Args...>::type,
+       _Res>
+      >::value,
+      _Res
+    >;
+
+
+  template<typename _Res, typename _Callable, typename... _Args>
+    constexpr __can_invoke_as_nonvoid<_Res, _Callable, _Args...>
+    __invoke_r(_Callable&& __fn, _Args&&... __args)
+    {
+      using __result = __invoke_result<_Callable, _Args...>;
+      using __type = typename __result::type;
+      using __tag = typename __result::__invoke_type;
+      return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
+     std::forward<_Args>(__args)...);
+    }
+
+
+  template<typename _Res, typename _Callable, typename... _Args>
+    constexpr __can_invoke_as_void<_Res, _Callable, _Args...>
+    __invoke_r(_Callable&& __fn, _Args&&... __args)
+    {
+      using __result = __invoke_result<_Callable, _Args...>;
+      using __type = typename __result::type;
+      using __tag = typename __result::__invoke_type;
+      std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
+     std::forward<_Args>(__args)...);
+    }
+
+
+
+}
+# 42 "/usr/include/c++/10.2.0/tuple" 2 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename... _Elements>
+    class tuple;
+
+  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,
+    bool = __empty_not_final<_Head>::value>
+    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;
+    };
+# 182 "/usr/include/c++/10.2.0/tuple" 3
+  template<std::size_t _Idx, typename... _Elements>
+    struct _Tuple_impl;
+
+
+
+
+
+
+  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>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+
+      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
+      typedef _Head_base<_Idx, _Head> _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;
+
+
+
+      _Tuple_impl& operator=(const _Tuple_impl&) = delete;
+
+      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))) { }
+
+      template<typename... _UElements>
+
+        void
+        _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
+        {
+   _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
+   _M_tail(*this)._M_assign(
+       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
+ }
+
+      template<typename _UHead, typename... _UTails>
+
+        void
+        _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+        {
+   _M_head(*this) = std::forward<_UHead>
+     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
+   _M_tail(*this)._M_assign(
+       std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
+ }
+
+    protected:
+     
+      void
+      _M_swap(_Tuple_impl& __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>
+    {
+      template<std::size_t, typename...> friend class _Tuple_impl;
+
+      typedef _Head_base<_Idx, _Head> _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;
+
+
+
+      _Tuple_impl& operator=(const _Tuple_impl&) = delete;
+
+      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)))
+ { }
+
+      template<typename _UHead>
+
+        void
+        _M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
+        {
+   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
+ }
+
+      template<typename _UHead>
+
+        void
+        _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
+        {
+   _M_head(*this)
+     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
+ }
+
+    protected:
+     
+      void
+      _M_swap(_Tuple_impl& __in)
+      {
+ using std::swap;
+ swap(_M_head(*this), _M_head(__in));
+      }
+    };
+
+
+
+  template<bool, typename... _Types>
+    struct _TupleConstraints
+    {
+
+
+
+      template<typename... _UTypes>
+ static constexpr bool __is_implicitly_constructible()
+ {
+   return __and_<is_constructible<_Types, _UTypes>...,
+   is_convertible<_UTypes, _Types>...
+   >::value;
+ }
+
+
+
+
+      template<typename... _UTypes>
+ static constexpr bool __is_explicitly_constructible()
+ {
+   return __and_<is_constructible<_Types, _UTypes>...,
+   __not_<__and_<is_convertible<_UTypes, _Types>...>>
+   >::value;
+ }
+
+      static constexpr bool __is_implicitly_default_constructible()
+      {
+ return __and_<std::__is_implicitly_default_constructible<_Types>...
+        >::value;
+      }
+
+      static constexpr bool __is_explicitly_default_constructible()
+      {
+ return __and_<is_default_constructible<_Types>...,
+        __not_<__and_<
+   std::__is_implicitly_default_constructible<_Types>...>
+        >>::value;
+      }
+    };
+
+
+
+  template<typename... _Types>
+    struct _TupleConstraints<false, _Types...>
+    {
+      template<typename... _UTypes>
+ static constexpr bool __is_implicitly_constructible()
+ { return false; }
+
+      template<typename... _UTypes>
+ static constexpr bool __is_explicitly_constructible()
+ { return false; }
+    };
+
+
+  template<typename... _Elements>
+    class tuple : public _Tuple_impl<0, _Elements...>
+    {
+      typedef _Tuple_impl<0, _Elements...> _Inherited;
+
+      template<bool _Cond>
+ using _TCC = _TupleConstraints<_Cond, _Elements...>;
+
+
+      template<bool _Dummy>
+ using _ImplicitDefaultCtor = __enable_if_t<
+   _TCC<_Dummy>::__is_implicitly_default_constructible(),
+   bool>;
+
+
+      template<bool _Dummy>
+ using _ExplicitDefaultCtor = __enable_if_t<
+   _TCC<_Dummy>::__is_explicitly_default_constructible(),
+   bool>;
+
+
+      template<bool _Cond, typename... _Args>
+ using _ImplicitCtor = __enable_if_t<
+   _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(),
+   bool>;
+
+
+      template<bool _Cond, typename... _Args>
+ using _ExplicitCtor = __enable_if_t<
+   _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(),
+   bool>;
+
+      template<typename... _UElements>
+ static constexpr
+ __enable_if_t<sizeof...(_UElements) == sizeof...(_Elements), bool>
+ __assignable()
+ { return __and_<is_assignable<_Elements&, _UElements>...>::value; }
+
+
+      template<typename... _UElements>
+ static constexpr bool __nothrow_assignable()
+ {
+   return
+     __and_<is_nothrow_assignable<_Elements&, _UElements>...>::value;
+ }
+
+
+      template<typename... _UElements>
+ static constexpr bool __nothrow_constructible()
+ {
+   return
+     __and_<is_nothrow_constructible<_Elements, _UElements>...>::value;
+ }
+
+
+      template<typename _Up>
+ static constexpr bool __valid_args()
+ {
+   return sizeof...(_Elements) == 1
+     && !is_same<tuple, __remove_cvref_t<_Up>>::value;
+ }
+
+
+      template<typename, typename, typename... _Tail>
+ static constexpr bool __valid_args()
+ { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); }
+# 591 "/usr/include/c++/10.2.0/tuple" 3
+      template<typename _Tuple, typename = tuple,
+        typename = __remove_cvref_t<_Tuple>>
+ struct _UseOtherCtor
+ : false_type
+ { };
+
+
+      template<typename _Tuple, typename _Tp, typename _Up>
+ struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>>
+ : __or_<is_convertible<_Tuple, _Tp>, is_constructible<_Tp, _Tuple>>
+ { };
+
+
+      template<typename _Tuple, typename _Tp>
+ struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>>
+ : true_type
+ { };
+
+
+
+
+      template<typename _Tuple>
+ static constexpr bool __use_other_ctor()
+ { return _UseOtherCtor<_Tuple>::value; }
+
+    public:
+      template<typename _Dummy = void,
+        _ImplicitDefaultCtor<is_void<_Dummy>::value> = true>
+ constexpr
+ tuple()
+ noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
+ : _Inherited() { }
+
+      template<typename _Dummy = void,
+        _ExplicitDefaultCtor<is_void<_Dummy>::value> = false>
+ explicit constexpr
+ tuple()
+ noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
+ : _Inherited() { }
+
+      template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
+        _ImplicitCtor<_NotEmpty, const _Elements&...> = true>
+ constexpr
+ tuple(const _Elements&... __elements)
+ noexcept(__nothrow_constructible<const _Elements&...>())
+ : _Inherited(__elements...) { }
+
+      template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
+        _ExplicitCtor<_NotEmpty, const _Elements&...> = false>
+ explicit constexpr
+ tuple(const _Elements&... __elements)
+ noexcept(__nothrow_constructible<const _Elements&...>())
+ : _Inherited(__elements...) { }
+
+      template<typename... _UElements,
+        bool _Valid = __valid_args<_UElements...>(),
+        _ImplicitCtor<_Valid, _UElements...> = true>
+ constexpr
+ tuple(_UElements&&... __elements)
+ noexcept(__nothrow_constructible<_UElements...>())
+ : _Inherited(std::forward<_UElements>(__elements)...) { }
+
+      template<typename... _UElements,
+        bool _Valid = __valid_args<_UElements...>(),
+        _ExplicitCtor<_Valid, _UElements...> = false>
+ explicit constexpr
+ tuple(_UElements&&... __elements)
+ noexcept(__nothrow_constructible<_UElements...>())
+ : _Inherited(std::forward<_UElements>(__elements)...) { }
+
+      constexpr tuple(const tuple&) = default;
+
+      constexpr tuple(tuple&&) = default;
+
+      template<typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+      && !__use_other_ctor<const tuple<_UElements...>&>(),
+        _ImplicitCtor<_Valid, const _UElements&...> = true>
+ constexpr
+ tuple(const tuple<_UElements...>& __in)
+ noexcept(__nothrow_constructible<const _UElements&...>())
+ : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+
+      template<typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+      && !__use_other_ctor<const tuple<_UElements...>&>(),
+        _ExplicitCtor<_Valid, const _UElements&...> = false>
+ explicit constexpr
+ tuple(const tuple<_UElements...>& __in)
+ noexcept(__nothrow_constructible<const _UElements&...>())
+ : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ { }
+
+      template<typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<tuple<_UElements...>&&>(),
+        _ImplicitCtor<_Valid, _UElements...> = true>
+ constexpr
+ tuple(tuple<_UElements...>&& __in)
+ noexcept(__nothrow_constructible<_UElements...>())
+ : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+
+      template<typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<tuple<_UElements...>&&>(),
+        _ExplicitCtor<_Valid, _UElements...> = false>
+ explicit constexpr
+ tuple(tuple<_UElements...>&& __in)
+ noexcept(__nothrow_constructible<_UElements...>())
+ : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { }
+
+
+
+      template<typename _Alloc,
+        _ImplicitDefaultCtor<is_object<_Alloc>::value> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a) { }
+
+      template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
+        _ImplicitCtor<_NotEmpty, const _Elements&...> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _Elements&... __elements)
+ : _Inherited(__tag, __a, __elements...) { }
+
+      template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
+        _ExplicitCtor<_NotEmpty, const _Elements&...> = false>
+
+ explicit
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _Elements&... __elements)
+ : _Inherited(__tag, __a, __elements...) { }
+
+      template<typename _Alloc, typename... _UElements,
+        bool _Valid = __valid_args<_UElements...>(),
+        _ImplicitCtor<_Valid, _UElements...> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       _UElements&&... __elements)
+ : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
+ { }
+
+      template<typename _Alloc, typename... _UElements,
+   bool _Valid = __valid_args<_UElements...>(),
+        _ExplicitCtor<_Valid, _UElements...> = false>
+
+ explicit
+ 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,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<const tuple<_UElements...>&>(),
+        _ImplicitCtor<_Valid, const _UElements&...> = true>
+
+ 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,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<const tuple<_UElements...>&>(),
+        _ExplicitCtor<_Valid, const _UElements&...> = false>
+
+ explicit
+ 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,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<tuple<_UElements...>&&>(),
+        _ImplicitCtor<_Valid, _UElements...> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       tuple<_UElements...>&& __in)
+ : _Inherited(__tag, __a,
+              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ { }
+
+      template<typename _Alloc, typename... _UElements,
+        bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
+        && !__use_other_ctor<tuple<_UElements...>&&>(),
+        _ExplicitCtor<_Valid, _UElements...> = false>
+
+ explicit
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       tuple<_UElements...>&& __in)
+ : _Inherited(__tag, __a,
+              static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ { }
+
+
+
+     
+      tuple&
+      operator=(typename conditional<__assignable<const _Elements&...>(),
+         const tuple&,
+         const __nonesuch&>::type __in)
+      noexcept(__nothrow_assignable<const _Elements&...>())
+      {
+ this->_M_assign(__in);
+ return *this;
+      }
+
+     
+      tuple&
+      operator=(typename conditional<__assignable<_Elements...>(),
+         tuple&&,
+         __nonesuch&&>::type __in)
+      noexcept(__nothrow_assignable<_Elements...>())
+      {
+ this->_M_assign(std::move(__in));
+ return *this;
+      }
+
+      template<typename... _UElements>
+
+ __enable_if_t<__assignable<const _UElements&...>(), tuple&>
+ operator=(const tuple<_UElements...>& __in)
+ noexcept(__nothrow_assignable<const _UElements&...>())
+ {
+   this->_M_assign(__in);
+   return *this;
+ }
+
+      template<typename... _UElements>
+
+ __enable_if_t<__assignable<_UElements...>(), tuple&>
+ operator=(tuple<_UElements...>&& __in)
+ noexcept(__nothrow_assignable<_UElements...>())
+ {
+   this->_M_assign(std::move(__in));
+   return *this;
+ }
+
+
+     
+      void
+      swap(tuple& __in)
+      noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
+      { _Inherited::_M_swap(__in); }
+    };
+# 867 "/usr/include/c++/10.2.0/tuple" 3
+  template<>
+    class tuple<>
+    {
+    public:
+      void swap(tuple&) noexcept { }
+
+
+      tuple() = default;
+
+      template<typename _Alloc>
+
+ tuple(allocator_arg_t, const _Alloc&) noexcept { }
+      template<typename _Alloc>
+
+ tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { }
+    };
+
+
+
+  template<typename _T1, typename _T2>
+    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
+    {
+      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
+
+
+      template<bool _Dummy, typename _U1, typename _U2>
+ using _ImplicitDefaultCtor = __enable_if_t<
+   _TupleConstraints<_Dummy, _U1, _U2>::
+     __is_implicitly_default_constructible(),
+   bool>;
+
+
+      template<bool _Dummy, typename _U1, typename _U2>
+ using _ExplicitDefaultCtor = __enable_if_t<
+   _TupleConstraints<_Dummy, _U1, _U2>::
+     __is_explicitly_default_constructible(),
+   bool>;
+
+      template<bool _Dummy>
+ using _TCC = _TupleConstraints<_Dummy, _T1, _T2>;
+
+
+      template<bool _Cond, typename _U1, typename _U2>
+ using _ImplicitCtor = __enable_if_t<
+   _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(),
+   bool>;
+
+
+      template<bool _Cond, typename _U1, typename _U2>
+ using _ExplicitCtor = __enable_if_t<
+   _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(),
+   bool>;
+
+      template<typename _U1, typename _U2>
+ static constexpr bool __assignable()
+ {
+   return __and_<is_assignable<_T1&, _U1>,
+   is_assignable<_T2&, _U2>>::value;
+ }
+
+      template<typename _U1, typename _U2>
+ static constexpr bool __nothrow_assignable()
+ {
+   return __and_<is_nothrow_assignable<_T1&, _U1>,
+   is_nothrow_assignable<_T2&, _U2>>::value;
+ }
+
+      template<typename _U1, typename _U2>
+ static constexpr bool __nothrow_constructible()
+ {
+   return __and_<is_nothrow_constructible<_T1, _U1>,
+       is_nothrow_constructible<_T2, _U2>>::value;
+ }
+
+      static constexpr bool __nothrow_default_constructible()
+      {
+ return __and_<is_nothrow_default_constructible<_T1>,
+        is_nothrow_default_constructible<_T2>>::value;
+      }
+
+      template<typename _U1>
+ static constexpr bool __is_alloc_arg()
+ { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; }
+
+    public:
+      template<bool _Dummy = true,
+        _ImplicitDefaultCtor<_Dummy, _T1, _T2> = true>
+ constexpr
+ tuple()
+ noexcept(__nothrow_default_constructible())
+ : _Inherited() { }
+
+      template<bool _Dummy = true,
+        _ExplicitDefaultCtor<_Dummy, _T1, _T2> = false>
+ explicit constexpr
+ tuple()
+ noexcept(__nothrow_default_constructible())
+ : _Inherited() { }
+
+      template<bool _Dummy = true,
+        _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>
+ constexpr
+ tuple(const _T1& __a1, const _T2& __a2)
+ noexcept(__nothrow_constructible<const _T1&, const _T2&>())
+ : _Inherited(__a1, __a2) { }
+
+      template<bool _Dummy = true,
+        _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
+ explicit constexpr
+ tuple(const _T1& __a1, const _T2& __a2)
+ noexcept(__nothrow_constructible<const _T1&, const _T2&>())
+ : _Inherited(__a1, __a2) { }
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = true>
+ constexpr
+ tuple(_U1&& __a1, _U2&& __a2)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = false>
+ explicit constexpr
+ tuple(_U1&& __a1, _U2&& __a2)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { }
+
+      constexpr tuple(const tuple&) = default;
+
+      constexpr tuple(tuple&&) = default;
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<true, const _U1&, const _U2&> = true>
+ constexpr
+ tuple(const tuple<_U1, _U2>& __in)
+ noexcept(__nothrow_constructible<const _U1&, const _U2&>())
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<true, const _U1&, const _U2&> = false>
+ explicit constexpr
+ tuple(const tuple<_U1, _U2>& __in)
+ noexcept(__nothrow_constructible<const _U1&, const _U2&>())
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in)) { }
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<true, _U1, _U2> = true>
+ constexpr
+ tuple(tuple<_U1, _U2>&& __in)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit constexpr
+ tuple(tuple<_U1, _U2>&& __in)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { }
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<true, const _U1&, const _U2&> = true>
+ constexpr
+ tuple(const pair<_U1, _U2>& __in)
+ noexcept(__nothrow_constructible<const _U1&, const _U2&>())
+ : _Inherited(__in.first, __in.second) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<true, const _U1&, const _U2&> = false>
+ explicit constexpr
+ tuple(const pair<_U1, _U2>& __in)
+ noexcept(__nothrow_constructible<const _U1&, const _U2&>())
+ : _Inherited(__in.first, __in.second) { }
+
+      template<typename _U1, typename _U2,
+        _ImplicitCtor<true, _U1, _U2> = true>
+ constexpr
+ tuple(pair<_U1, _U2>&& __in)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+      template<typename _U1, typename _U2,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit constexpr
+ tuple(pair<_U1, _U2>&& __in)
+ noexcept(__nothrow_constructible<_U1, _U2>())
+ : _Inherited(std::forward<_U1>(__in.first),
+       std::forward<_U2>(__in.second)) { }
+
+
+
+      template<typename _Alloc,
+        _ImplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a)
+ : _Inherited(__tag, __a) { }
+
+      template<typename _Alloc, bool _Dummy = true,
+        _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>
+
+ tuple(allocator_arg_t __tag, const _Alloc& __a,
+       const _T1& __a1, const _T2& __a2)
+ : _Inherited(__tag, __a, __a1, __a2) { }
+
+      template<typename _Alloc, bool _Dummy = true,
+        _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
+ explicit
+
+ 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,
+        _ImplicitCtor<true, _U1, _U2> = true>
+
+ 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, typename _U1, typename _U2,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit
+
+ 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,
+        _ImplicitCtor<true, const _U1&, const _U2&> = true>
+
+ 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,
+        _ExplicitCtor<true, const _U1&, const _U2&> = false>
+ explicit
+
+ 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,
+        _ImplicitCtor<true, _U1, _U2> = true>
+
+ 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,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit
+
+ 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,
+        _ImplicitCtor<true, const _U1&, const _U2&> = true>
+
+ 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,
+        _ExplicitCtor<true, const _U1&, const _U2&> = false>
+ explicit
+
+ 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,
+        _ImplicitCtor<true, _U1, _U2> = true>
+
+ 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)) { }
+
+      template<typename _Alloc, typename _U1, typename _U2,
+        _ExplicitCtor<true, _U1, _U2> = false>
+ explicit
+
+ 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=(typename conditional<__assignable<const _T1&, const _T2&>(),
+         const tuple&,
+         const __nonesuch&>::type __in)
+      noexcept(__nothrow_assignable<const _T1&, const _T2&>())
+      {
+ this->_M_assign(__in);
+ return *this;
+      }
+
+     
+      tuple&
+      operator=(typename conditional<__assignable<_T1, _T2>(),
+         tuple&&,
+         __nonesuch&&>::type __in)
+      noexcept(__nothrow_assignable<_T1, _T2>())
+      {
+ this->_M_assign(std::move(__in));
+ return *this;
+      }
+
+      template<typename _U1, typename _U2>
+
+ __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
+ operator=(const tuple<_U1, _U2>& __in)
+ noexcept(__nothrow_assignable<const _U1&, const _U2&>())
+ {
+   this->_M_assign(__in);
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+
+ __enable_if_t<__assignable<_U1, _U2>(), tuple&>
+ operator=(tuple<_U1, _U2>&& __in)
+ noexcept(__nothrow_assignable<_U1, _U2>())
+ {
+   this->_M_assign(std::move(__in));
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+
+ __enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
+ operator=(const pair<_U1, _U2>& __in)
+ noexcept(__nothrow_assignable<const _U1&, const _U2&>())
+ {
+   this->_M_head(*this) = __in.first;
+   this->_M_tail(*this)._M_head(*this) = __in.second;
+   return *this;
+ }
+
+      template<typename _U1, typename _U2>
+
+ __enable_if_t<__assignable<_U1, _U2>(), tuple&>
+ operator=(pair<_U1, _U2>&& __in)
+ noexcept(__nothrow_assignable<_U1, _U2>())
+ {
+   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(__and_<__is_nothrow_swappable<_T1>,
+        __is_nothrow_swappable<_T2>>::value)
+      { _Inherited::_M_swap(__in); }
+    };
+
+
+
+  template<typename... _Elements>
+    struct tuple_size<tuple<_Elements...>>
+    : public integral_constant<std::size_t, sizeof...(_Elements)> { };
+# 1258 "/usr/include/c++/10.2.0/tuple" 3
+  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<size_t __i>
+    struct tuple_element<__i, tuple<>>
+    {
+      static_assert(__i < tuple_size<tuple<>>::value,
+   "tuple index is in range");
+    };
+
+  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<std::size_t __i, typename... _Elements>
+    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
+    get(const tuple<_Elements...>&& __t) noexcept
+    {
+      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
+      return std::forward<const __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... _Types>
+    constexpr const _Tp&&
+    get(const tuple<_Types...>&& __t) noexcept
+    { return std::forward<const _Tp&&>(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);
+    }
+# 1433 "/usr/include/c++/10.2.0/tuple" 3
+  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>
+    constexpr tuple<_Elements&&...>
+    forward_as_tuple(_Elements&&... __args) noexcept
+    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
+
+  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<__remove_cvref_t<_Tuple>>
+    { };
+
+
+  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>
+    constexpr tuple<_Elements&...>
+    tie(_Elements&... __args) noexcept
+    { return tuple<_Elements&...>(__args...); }
+
+
+  template<typename... _Elements>
+   
+    inline
+
+
+    typename enable_if<__and_<__is_swappable<_Elements>...>::value
+      >::type
+
+
+
+    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+  template<typename... _Elements>
+   
+    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
+    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
+
+
+
+
+
+
+  struct _Swallow_assign
+  {
+    template<class _Tp>
+      constexpr const _Swallow_assign&
+      operator=(const _Tp&) const
+      { return *this; }
+  };
+
+
+
+  constexpr _Swallow_assign ignore{};
+
+
+  template<typename... _Types, typename _Alloc>
+    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
+# 1669 "/usr/include/c++/10.2.0/tuple" 3
+  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))...)
+      { }
+# 1759 "/usr/include/c++/10.2.0/tuple" 3
+
+}
+# 38 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 2 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  template<typename> class auto_ptr;
+#pragma GCC diagnostic pop
+
+
+
+  template<typename _Tp>
+    struct default_delete
+    {
+
+      constexpr default_delete() noexcept = default;
+
+
+
+
+
+
+      template<typename _Up,
+        typename = _Require<is_convertible<_Up*, _Tp*>>>
+        default_delete(const default_delete<_Up>&) noexcept { }
+
+
+      void
+      operator()(_Tp* __ptr) const
+      {
+ static_assert(!is_void<_Tp>::value,
+        "can't delete pointer to incomplete type");
+ static_assert(sizeof(_Tp)>0,
+        "can't delete pointer to incomplete type");
+ delete __ptr;
+      }
+    };
+
+
+
+
+
+  template<typename _Tp>
+    struct default_delete<_Tp[]>
+    {
+    public:
+
+      constexpr default_delete() noexcept = default;
+# 109 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up,
+        typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
+        default_delete(const default_delete<_Up[]>&) noexcept { }
+
+
+      template<typename _Up>
+ typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
+ operator()(_Up* __ptr) const
+ {
+   static_assert(sizeof(_Tp)>0,
+   "can't delete pointer to incomplete type");
+   delete [] __ptr;
+ }
+    };
+
+
+
+
+  template <typename _Tp, typename _Dp>
+    class __uniq_ptr_impl
+    {
+      template <typename _Up, typename _Ep, typename = void>
+ struct _Ptr
+ {
+   using type = _Up*;
+ };
+
+      template <typename _Up, typename _Ep>
+ struct
+ _Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
+ {
+   using type = typename remove_reference<_Ep>::type::pointer;
+ };
+
+    public:
+      using _DeleterConstraint = enable_if<
+        __and_<__not_<is_pointer<_Dp>>,
+        is_default_constructible<_Dp>>::value>;
+
+      using pointer = typename _Ptr<_Tp, _Dp>::type;
+
+      static_assert( !is_rvalue_reference<_Dp>::value,
+       "unique_ptr's deleter type must be a function object type"
+       " or an lvalue reference type" );
+
+      __uniq_ptr_impl() = default;
+      __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }
+
+      template<typename _Del>
+      __uniq_ptr_impl(pointer __p, _Del&& __d)
+ : _M_t(__p, std::forward<_Del>(__d)) { }
+
+      __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
+      : _M_t(std::move(__u._M_t))
+      { __u._M_ptr() = nullptr; }
+
+      __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
+      {
+ reset(__u.release());
+ _M_deleter() = std::forward<_Dp>(__u._M_deleter());
+ return *this;
+      }
+
+      pointer& _M_ptr() { return std::get<0>(_M_t); }
+      pointer _M_ptr() const { return std::get<0>(_M_t); }
+      _Dp& _M_deleter() { return std::get<1>(_M_t); }
+      const _Dp& _M_deleter() const { return std::get<1>(_M_t); }
+
+      void reset(pointer __p) noexcept
+      {
+ const pointer __old_p = _M_ptr();
+ _M_ptr() = __p;
+ if (__old_p)
+   _M_deleter()(__old_p);
+      }
+
+      pointer release() noexcept
+      {
+ pointer __p = _M_ptr();
+ _M_ptr() = nullptr;
+ return __p;
+      }
+
+      void
+      swap(__uniq_ptr_impl& __rhs) noexcept
+      {
+ using std::swap;
+ swap(this->_M_ptr(), __rhs._M_ptr());
+ swap(this->_M_deleter(), __rhs._M_deleter());
+      }
+
+    private:
+      tuple<pointer, _Dp> _M_t;
+    };
+
+
+  template <typename _Tp, typename _Dp,
+     bool = is_move_constructible<_Dp>::value,
+     bool = is_move_assignable<_Dp>::value>
+    struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp>
+    {
+      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
+      __uniq_ptr_data(__uniq_ptr_data&&) = default;
+      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
+    };
+
+  template <typename _Tp, typename _Dp>
+    struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp>
+    {
+      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
+      __uniq_ptr_data(__uniq_ptr_data&&) = default;
+      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
+    };
+
+  template <typename _Tp, typename _Dp>
+    struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp>
+    {
+      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
+      __uniq_ptr_data(__uniq_ptr_data&&) = delete;
+      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
+    };
+
+  template <typename _Tp, typename _Dp>
+    struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp>
+    {
+      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
+      __uniq_ptr_data(__uniq_ptr_data&&) = delete;
+      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
+    };
+
+
+
+  template <typename _Tp, typename _Dp = default_delete<_Tp>>
+    class unique_ptr
+    {
+      template <typename _Up>
+ using _DeleterConstraint =
+   typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
+
+      __uniq_ptr_data<_Tp, _Dp> _M_t;
+
+    public:
+      using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
+      using element_type = _Tp;
+      using deleter_type = _Dp;
+
+    private:
+
+
+      template<typename _Up, typename _Ep>
+ using __safe_conversion_up = __and_<
+   is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
+   __not_<is_array<_Up>>
+        >;
+
+    public:
+
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ constexpr unique_ptr() noexcept
+ : _M_t()
+ { }
+
+
+
+
+
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ explicit
+ unique_ptr(pointer __p) noexcept
+ : _M_t(__p)
+        { }
+# 292 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Del = deleter_type,
+        typename = _Require<is_copy_constructible<_Del>>>
+ unique_ptr(pointer __p, const deleter_type& __d) noexcept
+ : _M_t(__p, __d) { }
+# 304 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Del = deleter_type,
+        typename = _Require<is_move_constructible<_Del>>>
+ unique_ptr(pointer __p,
+     __enable_if_t<!is_lvalue_reference<_Del>::value,
+     _Del&&> __d) noexcept
+ : _M_t(__p, std::move(__d))
+ { }
+
+      template<typename _Del = deleter_type,
+        typename _DelUnref = typename remove_reference<_Del>::type>
+ unique_ptr(pointer,
+     __enable_if_t<is_lvalue_reference<_Del>::value,
+     _DelUnref&&>) = delete;
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ constexpr unique_ptr(nullptr_t) noexcept
+ : _M_t()
+ { }
+
+
+
+
+      unique_ptr(unique_ptr&&) = default;
+
+
+
+
+
+
+
+      template<typename _Up, typename _Ep, typename = _Require<
+               __safe_conversion_up<_Up, _Ep>,
+        typename conditional<is_reference<_Dp>::value,
+        is_same<_Ep, _Dp>,
+        is_convertible<_Ep, _Dp>>::type>>
+ unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+ : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
+ { }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+      template<typename _Up, typename = _Require<
+        is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
+ unique_ptr(auto_ptr<_Up>&& __u) noexcept;
+#pragma GCC diagnostic pop
+
+
+
+      ~unique_ptr() noexcept
+      {
+ static_assert(__is_invocable<deleter_type&, pointer>::value,
+        "unique_ptr's deleter must be invocable with a pointer");
+ auto& __ptr = _M_t._M_ptr();
+ if (__ptr != nullptr)
+   get_deleter()(std::move(__ptr));
+ __ptr = pointer();
+      }
+
+
+
+
+
+
+
+      unique_ptr& operator=(unique_ptr&&) = default;
+# 380 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up, typename _Ep>
+        typename enable_if< __and_<
+          __safe_conversion_up<_Up, _Ep>,
+          is_assignable<deleter_type&, _Ep&&>
+          >::value,
+          unique_ptr&>::type
+ operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
+ {
+   reset(__u.release());
+   get_deleter() = std::forward<_Ep>(__u.get_deleter());
+   return *this;
+ }
+
+
+      unique_ptr&
+      operator=(nullptr_t) noexcept
+      {
+ reset();
+ return *this;
+      }
+
+
+
+
+      typename add_lvalue_reference<element_type>::type
+      operator*() const
+      {
+ ;
+ return *get();
+      }
+
+
+      pointer
+      operator->() const noexcept
+      {
+ ;
+ return get();
+      }
+
+
+      pointer
+      get() const noexcept
+      { return _M_t._M_ptr(); }
+
+
+      deleter_type&
+      get_deleter() noexcept
+      { return _M_t._M_deleter(); }
+
+
+      const deleter_type&
+      get_deleter() const noexcept
+      { return _M_t._M_deleter(); }
+
+
+      explicit operator bool() const noexcept
+      { return get() == pointer() ? false : true; }
+
+
+
+
+      pointer
+      release() noexcept
+      { return _M_t.release(); }
+
+
+
+
+
+
+
+      void
+      reset(pointer __p = pointer()) noexcept
+      {
+ static_assert(__is_invocable<deleter_type&, pointer>::value,
+        "unique_ptr's deleter must be invocable with a pointer");
+ _M_t.reset(std::move(__p));
+      }
+
+
+      void
+      swap(unique_ptr& __u) noexcept
+      {
+ static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
+ _M_t.swap(__u._M_t);
+      }
+
+
+      unique_ptr(const unique_ptr&) = delete;
+      unique_ptr& operator=(const unique_ptr&) = delete;
+  };
+
+
+
+
+
+  template<typename _Tp, typename _Dp>
+    class unique_ptr<_Tp[], _Dp>
+    {
+      template <typename _Up>
+      using _DeleterConstraint =
+ typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
+
+      __uniq_ptr_data<_Tp, _Dp> _M_t;
+
+      template<typename _Up>
+ using __remove_cv = typename remove_cv<_Up>::type;
+
+
+      template<typename _Up>
+ using __is_derived_Tp
+   = __and_< is_base_of<_Tp, _Up>,
+      __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
+
+    public:
+      using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
+      using element_type = _Tp;
+      using deleter_type = _Dp;
+
+
+
+      template<typename _Up, typename _Ep,
+               typename _UPtr = unique_ptr<_Up, _Ep>,
+        typename _UP_pointer = typename _UPtr::pointer,
+        typename _UP_element_type = typename _UPtr::element_type>
+ using __safe_conversion_up = __and_<
+          is_array<_Up>,
+          is_same<pointer, element_type*>,
+          is_same<_UP_pointer, _UP_element_type*>,
+          is_convertible<_UP_element_type(*)[], element_type(*)[]>
+        >;
+
+
+      template<typename _Up>
+        using __safe_conversion_raw = __and_<
+          __or_<__or_<is_same<_Up, pointer>,
+                      is_same<_Up, nullptr_t>>,
+                __and_<is_pointer<_Up>,
+                       is_same<pointer, element_type*>,
+                       is_convertible<
+                         typename remove_pointer<_Up>::type(*)[],
+                         element_type(*)[]>
+                >
+          >
+        >;
+
+
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ constexpr unique_ptr() noexcept
+ : _M_t()
+ { }
+# 541 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up,
+        typename _Vp = _Dp,
+        typename = _DeleterConstraint<_Vp>,
+        typename = typename enable_if<
+                 __safe_conversion_raw<_Up>::value, bool>::type>
+ explicit
+ unique_ptr(_Up __p) noexcept
+ : _M_t(__p)
+        { }
+# 559 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up, typename _Del = deleter_type,
+        typename = _Require<__safe_conversion_raw<_Up>,
+       is_copy_constructible<_Del>>>
+      unique_ptr(_Up __p, const deleter_type& __d) noexcept
+      : _M_t(__p, __d) { }
+# 573 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up, typename _Del = deleter_type,
+        typename = _Require<__safe_conversion_raw<_Up>,
+       is_move_constructible<_Del>>>
+ unique_ptr(_Up __p,
+     __enable_if_t<!is_lvalue_reference<_Del>::value,
+     _Del&&> __d) noexcept
+ : _M_t(std::move(__p), std::move(__d))
+ { }
+
+      template<typename _Up, typename _Del = deleter_type,
+        typename _DelUnref = typename remove_reference<_Del>::type,
+        typename = _Require<__safe_conversion_raw<_Up>>>
+ unique_ptr(_Up,
+     __enable_if_t<is_lvalue_reference<_Del>::value,
+     _DelUnref&&>) = delete;
+
+
+      unique_ptr(unique_ptr&&) = default;
+
+
+      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
+ constexpr unique_ptr(nullptr_t) noexcept
+ : _M_t()
+        { }
+
+      template<typename _Up, typename _Ep, typename = _Require<
+        __safe_conversion_up<_Up, _Ep>,
+        typename conditional<is_reference<_Dp>::value,
+        is_same<_Ep, _Dp>,
+        is_convertible<_Ep, _Dp>>::type>>
+ unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
+ : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
+ { }
+
+
+      ~unique_ptr()
+      {
+ auto& __ptr = _M_t._M_ptr();
+ if (__ptr != nullptr)
+   get_deleter()(__ptr);
+ __ptr = pointer();
+      }
+
+
+
+
+
+
+
+      unique_ptr&
+      operator=(unique_ptr&&) = default;
+# 632 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+      template<typename _Up, typename _Ep>
+ typename
+ enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
+                         is_assignable<deleter_type&, _Ep&&>
+                  >::value,
+                  unique_ptr&>::type
+ operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
+ {
+   reset(__u.release());
+   get_deleter() = std::forward<_Ep>(__u.get_deleter());
+   return *this;
+ }
+
+
+      unique_ptr&
+      operator=(nullptr_t) noexcept
+      {
+ reset();
+ return *this;
+      }
+
+
+
+
+      typename std::add_lvalue_reference<element_type>::type
+      operator[](size_t __i) const
+      {
+ ;
+ return get()[__i];
+      }
+
+
+      pointer
+      get() const noexcept
+      { return _M_t._M_ptr(); }
+
+
+      deleter_type&
+      get_deleter() noexcept
+      { return _M_t._M_deleter(); }
+
+
+      const deleter_type&
+      get_deleter() const noexcept
+      { return _M_t._M_deleter(); }
+
+
+      explicit operator bool() const noexcept
+      { return get() == pointer() ? false : true; }
+
+
+
+
+      pointer
+      release() noexcept
+      { return _M_t.release(); }
+
+
+
+
+
+
+
+      template <typename _Up,
+                typename = _Require<
+                  __or_<is_same<_Up, pointer>,
+                        __and_<is_same<pointer, element_type*>,
+                               is_pointer<_Up>,
+                               is_convertible<
+                                 typename remove_pointer<_Up>::type(*)[],
+                                 element_type(*)[]
+                               >
+                        >
+                  >
+               >>
+      void
+      reset(_Up __p) noexcept
+      { _M_t.reset(std::move(__p)); }
+
+      void reset(nullptr_t = nullptr) noexcept
+      { reset(pointer()); }
+
+
+      void
+      swap(unique_ptr& __u) noexcept
+      {
+ static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
+ _M_t.swap(__u._M_t);
+      }
+
+
+      unique_ptr(const unique_ptr&) = delete;
+      unique_ptr& operator=(const unique_ptr&) = delete;
+    };
+
+
+
+
+  template<typename _Tp, typename _Dp>
+    inline
+
+
+    typename enable_if<__is_swappable<_Dp>::value>::type
+
+
+
+    swap(unique_ptr<_Tp, _Dp>& __x,
+  unique_ptr<_Tp, _Dp>& __y) noexcept
+    { __x.swap(__y); }
+
+
+  template<typename _Tp, typename _Dp>
+    typename enable_if<!__is_swappable<_Dp>::value>::type
+    swap(unique_ptr<_Tp, _Dp>&,
+  unique_ptr<_Tp, _Dp>&) = delete;
+
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    inline bool
+    operator==(const unique_ptr<_Tp, _Dp>& __x,
+        const unique_ptr<_Up, _Ep>& __y)
+    { return __x.get() == __y.get(); }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+    { return !__x; }
+
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+    { return !__x; }
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    inline bool
+    operator!=(const unique_ptr<_Tp, _Dp>& __x,
+        const unique_ptr<_Up, _Ep>& __y)
+    { return __x.get() != __y.get(); }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
+    { return (bool)__x; }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
+    { return (bool)__x; }
+
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    inline bool
+    operator<(const unique_ptr<_Tp, _Dp>& __x,
+       const unique_ptr<_Up, _Ep>& __y)
+    {
+      typedef typename
+ std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
+                  typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
+      return std::less<_CT>()(__x.get(), __y.get());
+    }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    {
+      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+         nullptr);
+    }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    {
+      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+         __x.get());
+    }
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    inline bool
+    operator<=(const unique_ptr<_Tp, _Dp>& __x,
+        const unique_ptr<_Up, _Ep>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    { return !(nullptr < __x); }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    { return !(__x < nullptr); }
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    inline bool
+    operator>(const unique_ptr<_Tp, _Dp>& __x,
+       const unique_ptr<_Up, _Ep>& __y)
+    { return (__y < __x); }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    {
+      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
+         __x.get());
+    }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    {
+      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
+         nullptr);
+    }
+
+
+  template<typename _Tp, typename _Dp,
+    typename _Up, typename _Ep>
+    inline bool
+    operator>=(const unique_ptr<_Tp, _Dp>& __x,
+        const unique_ptr<_Up, _Ep>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
+    { return !(__x < nullptr); }
+
+
+  template<typename _Tp, typename _Dp>
+    inline bool
+    operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
+    { return !(nullptr < __x); }
+# 912 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+  template<typename _Up, typename _Ptr = typename _Up::pointer,
+    bool = __poison_hash<_Ptr>::__enable_hash_call>
+    struct __uniq_ptr_hash
+
+    : private __poison_hash<_Ptr>
+
+    {
+      size_t
+      operator()(const _Up& __u) const
+      noexcept(noexcept(std::declval<hash<_Ptr>>()(std::declval<_Ptr>())))
+      { return hash<_Ptr>()(__u.get()); }
+    };
+
+  template<typename _Up, typename _Ptr>
+    struct __uniq_ptr_hash<_Up, _Ptr, false>
+    : private __poison_hash<_Ptr>
+    { };
+
+
+
+  template<typename _Tp, typename _Dp>
+    struct hash<unique_ptr<_Tp, _Dp>>
+    : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
+      public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
+    { };
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct _MakeUniq
+    { typedef unique_ptr<_Tp> __single_object; };
+
+  template<typename _Tp>
+    struct _MakeUniq<_Tp[]>
+    { typedef unique_ptr<_Tp[]> __array; };
+
+  template<typename _Tp, size_t _Bound>
+    struct _MakeUniq<_Tp[_Bound]>
+    { struct __invalid_type { }; };
+
+
+
+
+  template<typename _Tp, typename... _Args>
+    inline typename _MakeUniq<_Tp>::__single_object
+    make_unique(_Args&&... __args)
+    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
+
+
+  template<typename _Tp>
+    inline typename _MakeUniq<_Tp>::__array
+    make_unique(size_t __num)
+    { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
+
+
+  template<typename _Tp, typename... _Args>
+    inline typename _MakeUniq<_Tp>::__invalid_type
+    make_unique(_Args&&...) = delete;
+# 1008 "/usr/include/c++/10.2.0/bits/unique_ptr.h" 3
+
+}
+# 84 "/usr/include/c++/10.2.0/memory" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 1 3
+# 52 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+# 1 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 1 3
+# 53 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+# 1 "/usr/include/c++/10.2.0/bits/allocated_ptr.h" 1 3
+# 40 "/usr/include/c++/10.2.0/bits/allocated_ptr.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _Alloc>
+    struct __allocated_ptr
+    {
+      using pointer = typename allocator_traits<_Alloc>::pointer;
+      using value_type = typename allocator_traits<_Alloc>::value_type;
+
+
+      __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
+      : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr)
+      { }
+
+
+      template<typename _Ptr,
+        typename _Req = _Require<is_same<_Ptr, value_type*>>>
+      __allocated_ptr(_Alloc& __a, _Ptr __ptr)
+      : _M_alloc(std::__addressof(__a)),
+ _M_ptr(pointer_traits<pointer>::pointer_to(*__ptr))
+      { }
+
+
+      __allocated_ptr(__allocated_ptr&& __gd) noexcept
+      : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr)
+      { __gd._M_ptr = nullptr; }
+
+
+      ~__allocated_ptr()
+      {
+ if (_M_ptr != nullptr)
+   std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
+      }
+
+
+      __allocated_ptr&
+      operator=(std::nullptr_t) noexcept
+      {
+ _M_ptr = nullptr;
+ return *this;
+      }
+
+
+      value_type* get() { return std::__to_address(_M_ptr); }
+
+    private:
+      _Alloc* _M_alloc;
+      pointer _M_ptr;
+    };
+
+
+  template<typename _Alloc>
+    __allocated_ptr<_Alloc>
+    __allocate_guarded(_Alloc& __a)
+    {
+      return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) };
+    }
+
+
+}
+# 54 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/refwrap.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+# 43 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 54 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+  template<typename _Res, typename... _ArgTypes>
+    struct _Maybe_unary_or_binary_function { };
+
+
+  template<typename _Res, typename _T1>
+    struct _Maybe_unary_or_binary_function<_Res, _T1>
+    : std::unary_function<_T1, _Res> { };
+
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
+    : std::binary_function<_T1, _T2, _Res> { };
+
+  template<typename _Signature>
+    struct _Mem_fn_traits;
+
+  template<typename _Res, typename _Class, typename... _ArgTypes>
+    struct _Mem_fn_traits_base
+    {
+      using __result_type = _Res;
+      using __maybe_type
+ = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
+      using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
+    };
+# 99 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
+# 113 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+  template<typename _Functor, typename = __void_t<>>
+    struct _Maybe_get_result_type
+    { };
+
+  template<typename _Functor>
+    struct _Maybe_get_result_type<_Functor,
+      __void_t<typename _Functor::result_type>>
+    { typedef typename _Functor::result_type result_type; };
+
+
+
+
+
+  template<typename _Functor>
+    struct _Weak_result_type_impl
+    : _Maybe_get_result_type<_Functor>
+    { };
+
+
+  template<typename _Res, typename... _ArgTypes >
+    struct _Weak_result_type_impl<_Res(_ArgTypes...) >
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename... _ArgTypes >
+    struct _Weak_result_type_impl<_Res(_ArgTypes......) >
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename... _ArgTypes >
+    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) >
+    { typedef _Res result_type; };
+
+
+  template<typename _Res, typename... _ArgTypes >
+    struct
+    _Weak_result_type_impl<_Res(*)(_ArgTypes......) >
+    { typedef _Res result_type; };
+
+
+  template<typename _Functor,
+    bool = is_member_function_pointer<_Functor>::value>
+    struct _Weak_result_type_memfun
+    : _Weak_result_type_impl<_Functor>
+    { };
+
+
+  template<typename _MemFunPtr>
+    struct _Weak_result_type_memfun<_MemFunPtr, true>
+    {
+      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
+    };
+
+
+  template<typename _Func, typename _Class>
+    struct _Weak_result_type_memfun<_Func _Class::*, false>
+    { };
+
+
+
+
+
+  template<typename _Functor>
+    struct _Weak_result_type
+    : _Weak_result_type_memfun<typename remove_cv<_Functor>::type>
+    { };
+
+
+
+  template<typename _Tp, typename = __void_t<>>
+    struct _Refwrap_base_arg1
+    { };
+
+
+  template<typename _Tp>
+    struct _Refwrap_base_arg1<_Tp,
+         __void_t<typename _Tp::argument_type>>
+    {
+      typedef typename _Tp::argument_type argument_type;
+    };
+
+
+  template<typename _Tp, typename = __void_t<>>
+    struct _Refwrap_base_arg2
+    { };
+
+
+  template<typename _Tp>
+    struct _Refwrap_base_arg2<_Tp,
+         __void_t<typename _Tp::first_argument_type,
+           typename _Tp::second_argument_type>>
+    {
+      typedef typename _Tp::first_argument_type first_argument_type;
+      typedef typename _Tp::second_argument_type second_argument_type;
+    };
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct _Reference_wrapper_base
+    : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
+    { };
+
+
+  template<typename _Res, typename _T1 >
+    struct _Reference_wrapper_base<_Res(_T1) >
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) volatile>
+    : unary_function<_T1, _Res>
+    { };
+
+  template<typename _Res, typename _T1>
+    struct _Reference_wrapper_base<_Res(_T1) const volatile>
+    : unary_function<_T1, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2 >
+    struct _Reference_wrapper_base<_Res(_T1, _T2) >
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Res, typename _T1, typename _T2>
+    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1 >
+    struct _Reference_wrapper_base<_Res(*)(_T1) >
+    : unary_function<_T1, _Res>
+    { };
+
+
+  template<typename _Res, typename _T1, typename _T2 >
+    struct _Reference_wrapper_base<_Res(*)(_T1, _T2) >
+    : binary_function<_T1, _T2, _Res>
+    { };
+
+  template<typename _Tp, bool = is_member_function_pointer<_Tp>::value>
+    struct _Reference_wrapper_base_memfun
+    : _Reference_wrapper_base<_Tp>
+    { };
+
+  template<typename _MemFunPtr>
+    struct _Reference_wrapper_base_memfun<_MemFunPtr, true>
+    : _Mem_fn_traits<_MemFunPtr>::__maybe_type
+    {
+      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
+    };
+# 293 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+  template<typename _Tp>
+    class reference_wrapper
+
+
+
+    : public _Reference_wrapper_base_memfun<typename remove_cv<_Tp>::type>
+
+    {
+      _Tp* _M_data;
+
+     
+      static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); }
+
+      static void _S_fun(_Tp&&) = delete;
+
+      template<typename _Up, typename _Up2 = __remove_cvref_t<_Up>>
+ using __not_same
+   = typename enable_if<!is_same<reference_wrapper, _Up2>::value>::type;
+
+    public:
+      typedef _Tp type;
+
+
+
+
+      template<typename _Up, typename = __not_same<_Up>, typename
+  = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))>
+
+ reference_wrapper(_Up&& __uref)
+ noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>())))
+ : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref)))
+ { }
+
+      reference_wrapper(const reference_wrapper&) = default;
+
+      reference_wrapper&
+      operator=(const reference_wrapper&) = default;
+
+     
+      operator _Tp&() const noexcept
+      { return this->get(); }
+
+     
+      _Tp&
+      get() const noexcept
+      { return *_M_data; }
+
+      template<typename... _Args>
+
+ typename result_of<_Tp&(_Args&&...)>::type
+ operator()(_Args&&... __args) const
+ {
+
+
+
+
+   return std::__invoke(get(), std::forward<_Args>(__args)...);
+ }
+    };
+# 361 "/usr/include/c++/10.2.0/bits/refwrap.h" 3
+  template<typename _Tp>
+   
+    inline reference_wrapper<_Tp>
+    ref(_Tp& __t) noexcept
+    { return reference_wrapper<_Tp>(__t); }
+
+
+  template<typename _Tp>
+   
+    inline reference_wrapper<const _Tp>
+    cref(const _Tp& __t) noexcept
+    { return reference_wrapper<const _Tp>(__t); }
+
+  template<typename _Tp>
+    void ref(const _Tp&&) = delete;
+
+  template<typename _Tp>
+    void cref(const _Tp&&) = delete;
+
+
+  template<typename _Tp>
+   
+    inline reference_wrapper<_Tp>
+    ref(reference_wrapper<_Tp> __t) noexcept
+    { return __t; }
+
+
+  template<typename _Tp>
+   
+    inline reference_wrapper<const _Tp>
+    cref(reference_wrapper<_Tp> __t) noexcept
+    { return { __t.get() }; }
+
+
+
+
+}
+# 55 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/ext/aligned_buffer.h" 1 3
+# 32 "/usr/include/c++/10.2.0/ext/aligned_buffer.h" 3
+       
+# 33 "/usr/include/c++/10.2.0/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()); }
+    };
+# 89 "/usr/include/c++/10.2.0/ext/aligned_buffer.h" 3
+  template<typename _Tp>
+    struct __aligned_buffer
+    : std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>
+    {
+      typename
+ std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>::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()); }
+    };
+
+
+}
+# 57 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+  template<typename> class auto_ptr;
+#pragma GCC diagnostic pop
+
+
+
+
+
+
+  class bad_weak_ptr : public std::exception
+  {
+  public:
+    virtual char const* what() const noexcept;
+
+    virtual ~bad_weak_ptr() noexcept;
+  };
+
+
+  inline void
+  __throw_bad_weak_ptr()
+  { (throw (bad_weak_ptr())); }
+
+  using __gnu_cxx::_Lock_policy;
+  using __gnu_cxx::__default_lock_policy;
+  using __gnu_cxx::_S_single;
+  using __gnu_cxx::_S_mutex;
+  using __gnu_cxx::_S_atomic;
+
+
+  template<_Lock_policy _Lp>
+    class _Mutex_base
+    {
+    protected:
+
+      enum { _S_need_barriers = 0 };
+    };
+
+  template<>
+    class _Mutex_base<_S_mutex>
+    : public __gnu_cxx::__mutex
+    {
+    protected:
+
+
+
+      enum { _S_need_barriers = 1 };
+    };
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class _Sp_counted_base
+    : public _Mutex_base<_Lp>
+    {
+    public:
+      _Sp_counted_base() noexcept
+      : _M_use_count(1), _M_weak_count(1) { }
+
+      virtual
+      ~_Sp_counted_base() noexcept
+      { }
+
+
+
+      virtual void
+      _M_dispose() noexcept = 0;
+
+
+      virtual void
+      _M_destroy() noexcept
+      { delete this; }
+
+      virtual void*
+      _M_get_deleter(const std::type_info&) noexcept = 0;
+
+      void
+      _M_add_ref_copy()
+      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }
+
+      void
+      _M_add_ref_lock();
+
+      bool
+      _M_add_ref_lock_nothrow();
+
+      void
+      _M_release() noexcept
+      {
+
+        ;
+ if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
+   {
+            ;
+     _M_dispose();
+
+
+
+
+     if (_Mutex_base<_Lp>::_S_need_barriers)
+       {
+  __atomic_thread_fence (4);
+       }
+
+
+            ;
+     if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
+             -1) == 1)
+              {
+                ;
+         _M_destroy();
+              }
+   }
+      }
+
+      void
+      _M_weak_add_ref() noexcept
+      { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }
+
+      void
+      _M_weak_release() noexcept
+      {
+
+        ;
+ if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
+   {
+            ;
+     if (_Mutex_base<_Lp>::_S_need_barriers)
+       {
+
+
+  __atomic_thread_fence (4);
+       }
+     _M_destroy();
+   }
+      }
+
+      long
+      _M_get_use_count() const noexcept
+      {
+
+
+        return __atomic_load_n(&_M_use_count, 0);
+      }
+
+    private:
+      _Sp_counted_base(_Sp_counted_base const&) = delete;
+      _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
+
+      _Atomic_word _M_use_count;
+      _Atomic_word _M_weak_count;
+    };
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::
+    _M_add_ref_lock()
+    {
+      if (_M_use_count == 0)
+ __throw_bad_weak_ptr();
+      ++_M_use_count;
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_mutex>::
+    _M_add_ref_lock()
+    {
+      __gnu_cxx::__scoped_lock sentry(*this);
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
+ {
+   _M_use_count = 0;
+   __throw_bad_weak_ptr();
+ }
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_atomic>::
+    _M_add_ref_lock()
+    {
+
+      _Atomic_word __count = _M_get_use_count();
+      do
+ {
+   if (__count == 0)
+     __throw_bad_weak_ptr();
+
+
+ }
+      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
+       true, 4,
+       0));
+    }
+
+  template<>
+    inline bool
+    _Sp_counted_base<_S_single>::
+    _M_add_ref_lock_nothrow()
+    {
+      if (_M_use_count == 0)
+ return false;
+      ++_M_use_count;
+      return true;
+    }
+
+  template<>
+    inline bool
+    _Sp_counted_base<_S_mutex>::
+    _M_add_ref_lock_nothrow()
+    {
+      __gnu_cxx::__scoped_lock sentry(*this);
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0)
+ {
+   _M_use_count = 0;
+   return false;
+ }
+      return true;
+    }
+
+  template<>
+    inline bool
+    _Sp_counted_base<_S_atomic>::
+    _M_add_ref_lock_nothrow()
+    {
+
+      _Atomic_word __count = _M_get_use_count();
+      do
+ {
+   if (__count == 0)
+     return false;
+
+
+ }
+      while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
+       true, 4,
+       0));
+      return true;
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_add_ref_copy()
+    { ++_M_use_count; }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_release() noexcept
+    {
+      if (--_M_use_count == 0)
+        {
+          _M_dispose();
+          if (--_M_weak_count == 0)
+            _M_destroy();
+        }
+    }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
+    { ++_M_weak_count; }
+
+  template<>
+    inline void
+    _Sp_counted_base<_S_single>::_M_weak_release() noexcept
+    {
+      if (--_M_weak_count == 0)
+        _M_destroy();
+    }
+
+  template<>
+    inline long
+    _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
+    { return _M_use_count; }
+
+
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __shared_ptr;
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __weak_ptr;
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
+    class __enable_shared_from_this;
+
+  template<typename _Tp>
+    class shared_ptr;
+
+  template<typename _Tp>
+    class weak_ptr;
+
+  template<typename _Tp>
+    struct owner_less;
+
+  template<typename _Tp>
+    class enable_shared_from_this;
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class __weak_count;
+
+  template<_Lock_policy _Lp = __default_lock_policy>
+    class __shared_count;
+
+
+
+  template<typename _Ptr, _Lock_policy _Lp>
+    class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
+    {
+    public:
+      explicit
+      _Sp_counted_ptr(_Ptr __p) noexcept
+      : _M_ptr(__p) { }
+
+      virtual void
+      _M_dispose() noexcept
+      { delete _M_ptr; }
+
+      virtual void
+      _M_destroy() noexcept
+      { delete this; }
+
+      virtual void*
+      _M_get_deleter(const std::type_info&) noexcept
+      { return nullptr; }
+
+      _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
+      _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
+
+    private:
+      _Ptr _M_ptr;
+    };
+
+  template<>
+    inline void
+    _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
+
+  template<>
+    inline void
+    _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
+
+  template<>
+    inline void
+    _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
+
+  template<int _Nm, typename _Tp,
+    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
+    struct _Sp_ebo_helper;
+
+
+  template<int _Nm, typename _Tp>
+    struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
+    {
+      explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
+      explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }
+
+      static _Tp&
+      _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
+    };
+
+
+  template<int _Nm, typename _Tp>
+    struct _Sp_ebo_helper<_Nm, _Tp, false>
+    {
+      explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
+      explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }
+
+      static _Tp&
+      _S_get(_Sp_ebo_helper& __eboh)
+      { return __eboh._M_tp; }
+
+    private:
+      _Tp _M_tp;
+    };
+
+
+  template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
+    class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
+    {
+      class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
+      {
+ typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
+ typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
+
+      public:
+ _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
+ : _M_ptr(__p), _Del_base(std::move(__d)), _Alloc_base(__a)
+ { }
+
+ _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
+ _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
+
+ _Ptr _M_ptr;
+      };
+
+    public:
+      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;
+
+
+      _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
+      : _M_impl(__p, std::move(__d), _Alloc()) { }
+
+
+      _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
+      : _M_impl(__p, std::move(__d), __a) { }
+
+      ~_Sp_counted_deleter() noexcept { }
+
+      virtual void
+      _M_dispose() noexcept
+      { _M_impl._M_del()(_M_impl._M_ptr); }
+
+      virtual void
+      _M_destroy() noexcept
+      {
+ __allocator_type __a(_M_impl._M_alloc());
+ __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
+ this->~_Sp_counted_deleter();
+      }
+
+      virtual void*
+      _M_get_deleter(const std::type_info& __ti) noexcept
+      {
+
+
+
+        return __ti == typeid(_Deleter)
+   ? std::__addressof(_M_impl._M_del())
+   : nullptr;
+
+
+
+      }
+
+    private:
+      _Impl _M_impl;
+    };
+
+
+
+  struct _Sp_make_shared_tag
+  {
+  private:
+    template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
+      friend class _Sp_counted_ptr_inplace;
+
+    static const type_info&
+    _S_ti() noexcept __attribute__ ((__visibility__ ("default")))
+    {
+      alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { };
+      return reinterpret_cast<const type_info&>(__tag);
+    }
+
+    static bool _S_eq(const type_info&) noexcept;
+  };
+
+  template<typename _Alloc>
+    struct _Sp_alloc_shared_tag
+    {
+      const _Alloc& _M_a;
+    };
+
+  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
+    class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
+    {
+      class _Impl : _Sp_ebo_helper<0, _Alloc>
+      {
+ typedef _Sp_ebo_helper<0, _Alloc> _A_base;
+
+      public:
+ explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }
+
+ _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }
+
+ __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
+      };
+
+    public:
+      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;
+
+
+      template<typename... _Args>
+ _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
+ : _M_impl(__a)
+ {
+
+
+   allocator_traits<_Alloc>::construct(__a, _M_ptr(),
+       std::forward<_Args>(__args)...);
+ }
+
+      ~_Sp_counted_ptr_inplace() noexcept { }
+
+      virtual void
+      _M_dispose() noexcept
+      {
+ allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
+      }
+
+
+      virtual void
+      _M_destroy() noexcept
+      {
+ __allocator_type __a(_M_impl._M_alloc());
+ __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
+ this->~_Sp_counted_ptr_inplace();
+      }
+
+    private:
+      friend class __shared_count<_Lp>;
+
+
+
+      virtual void*
+      _M_get_deleter(const std::type_info& __ti) noexcept override
+      {
+ auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());
+
+
+
+
+ if (&__ti == &_Sp_make_shared_tag::_S_ti()
+     ||
+
+     __ti == typeid(_Sp_make_shared_tag)
+
+
+
+    )
+   return __ptr;
+ return nullptr;
+      }
+
+      _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
+
+      _Impl _M_impl;
+    };
+
+
+  struct __sp_array_delete
+  {
+    template<typename _Yp>
+      void operator()(_Yp* __p) const { delete[] __p; }
+  };
+
+  template<_Lock_policy _Lp>
+    class __shared_count
+    {
+      template<typename _Tp>
+ struct __not_alloc_shared_tag { using type = void; };
+
+      template<typename _Tp>
+ struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };
+
+    public:
+      constexpr __shared_count() noexcept : _M_pi(0)
+      { }
+
+      template<typename _Ptr>
+        explicit
+ __shared_count(_Ptr __p) : _M_pi(0)
+ {
+   try
+     {
+       _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
+     }
+   catch(...)
+     {
+       delete __p;
+       throw;
+     }
+ }
+
+      template<typename _Ptr>
+ __shared_count(_Ptr __p, false_type)
+ : __shared_count(__p)
+ { }
+
+      template<typename _Ptr>
+ __shared_count(_Ptr __p, true_type)
+ : __shared_count(__p, __sp_array_delete{}, allocator<void>())
+ { }
+
+      template<typename _Ptr, typename _Deleter,
+        typename = typename __not_alloc_shared_tag<_Deleter>::type>
+ __shared_count(_Ptr __p, _Deleter __d)
+ : __shared_count(__p, std::move(__d), allocator<void>())
+ { }
+
+      template<typename _Ptr, typename _Deleter, typename _Alloc,
+        typename = typename __not_alloc_shared_tag<_Deleter>::type>
+ __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
+ {
+   typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
+   try
+     {
+       typename _Sp_cd_type::__allocator_type __a2(__a);
+       auto __guard = std::__allocate_guarded(__a2);
+       _Sp_cd_type* __mem = __guard.get();
+       ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
+       _M_pi = __mem;
+       __guard = nullptr;
+     }
+   catch(...)
+     {
+       __d(__p);
+       throw;
+     }
+ }
+
+      template<typename _Tp, typename _Alloc, typename... _Args>
+ __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
+         _Args&&... __args)
+ {
+   typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
+   typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
+   auto __guard = std::__allocate_guarded(__a2);
+   _Sp_cp_type* __mem = __guard.get();
+   auto __pi = ::new (__mem)
+     _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
+   __guard = nullptr;
+   _M_pi = __pi;
+   __p = __pi->_M_ptr();
+ }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+      template<typename _Tp>
+        explicit
+ __shared_count(std::auto_ptr<_Tp>&& __r);
+#pragma GCC diagnostic pop
+
+
+
+      template<typename _Tp, typename _Del>
+        explicit
+ __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
+ {
+
+
+   if (__r.get() == nullptr)
+     return;
+
+   using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
+   using _Del2 = typename conditional<is_reference<_Del>::value,
+       reference_wrapper<typename remove_reference<_Del>::type>,
+       _Del>::type;
+   using _Sp_cd_type
+     = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
+   using _Alloc = allocator<_Sp_cd_type>;
+   using _Alloc_traits = allocator_traits<_Alloc>;
+   _Alloc __a;
+   _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
+   _Alloc_traits::construct(__a, __mem, __r.release(),
+       __r.get_deleter());
+   _M_pi = __mem;
+ }
+
+
+      explicit __shared_count(const __weak_count<_Lp>& __r);
+
+
+      explicit __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t);
+
+      ~__shared_count() noexcept
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_release();
+      }
+
+      __shared_count(const __shared_count& __r) noexcept
+      : _M_pi(__r._M_pi)
+      {
+ if (_M_pi != 0)
+   _M_pi->_M_add_ref_copy();
+      }
+
+      __shared_count&
+      operator=(const __shared_count& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ if (__tmp != _M_pi)
+   {
+     if (__tmp != 0)
+       __tmp->_M_add_ref_copy();
+     if (_M_pi != 0)
+       _M_pi->_M_release();
+     _M_pi = __tmp;
+   }
+ return *this;
+      }
+
+      void
+      _M_swap(__shared_count& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ __r._M_pi = _M_pi;
+ _M_pi = __tmp;
+      }
+
+      long
+      _M_get_use_count() const noexcept
+      { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; }
+
+      bool
+      _M_unique() const noexcept
+      { return this->_M_get_use_count() == 1; }
+
+      void*
+      _M_get_deleter(const std::type_info& __ti) const noexcept
+      { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }
+
+      bool
+      _M_less(const __shared_count& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+      bool
+      _M_less(const __weak_count<_Lp>& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+
+      friend inline bool
+      operator==(const __shared_count& __a, const __shared_count& __b) noexcept
+      { return __a._M_pi == __b._M_pi; }
+
+    private:
+      friend class __weak_count<_Lp>;
+
+      _Sp_counted_base<_Lp>* _M_pi;
+    };
+
+
+  template<_Lock_policy _Lp>
+    class __weak_count
+    {
+    public:
+      constexpr __weak_count() noexcept : _M_pi(nullptr)
+      { }
+
+      __weak_count(const __shared_count<_Lp>& __r) noexcept
+      : _M_pi(__r._M_pi)
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_add_ref();
+      }
+
+      __weak_count(const __weak_count& __r) noexcept
+      : _M_pi(__r._M_pi)
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_add_ref();
+      }
+
+      __weak_count(__weak_count&& __r) noexcept
+      : _M_pi(__r._M_pi)
+      { __r._M_pi = nullptr; }
+
+      ~__weak_count() noexcept
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_release();
+      }
+
+      __weak_count&
+      operator=(const __shared_count<_Lp>& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ if (__tmp != nullptr)
+   __tmp->_M_weak_add_ref();
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_release();
+ _M_pi = __tmp;
+ return *this;
+      }
+
+      __weak_count&
+      operator=(const __weak_count& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ if (__tmp != nullptr)
+   __tmp->_M_weak_add_ref();
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_release();
+ _M_pi = __tmp;
+ return *this;
+      }
+
+      __weak_count&
+      operator=(__weak_count&& __r) noexcept
+      {
+ if (_M_pi != nullptr)
+   _M_pi->_M_weak_release();
+ _M_pi = __r._M_pi;
+        __r._M_pi = nullptr;
+ return *this;
+      }
+
+      void
+      _M_swap(__weak_count& __r) noexcept
+      {
+ _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
+ __r._M_pi = _M_pi;
+ _M_pi = __tmp;
+      }
+
+      long
+      _M_get_use_count() const noexcept
+      { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }
+
+      bool
+      _M_less(const __weak_count& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+      bool
+      _M_less(const __shared_count<_Lp>& __rhs) const noexcept
+      { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
+
+
+      friend inline bool
+      operator==(const __weak_count& __a, const __weak_count& __b) noexcept
+      { return __a._M_pi == __b._M_pi; }
+
+    private:
+      friend class __shared_count<_Lp>;
+
+      _Sp_counted_base<_Lp>* _M_pi;
+    };
+
+
+  template<_Lock_policy _Lp>
+    inline
+    __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
+    : _M_pi(__r._M_pi)
+    {
+      if (_M_pi != nullptr)
+ _M_pi->_M_add_ref_lock();
+      else
+ __throw_bad_weak_ptr();
+    }
+
+
+  template<_Lock_policy _Lp>
+    inline
+    __shared_count<_Lp>::
+    __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t)
+    : _M_pi(__r._M_pi)
+    {
+      if (_M_pi != nullptr)
+ if (!_M_pi->_M_add_ref_lock_nothrow())
+   _M_pi = nullptr;
+    }
+
+
+
+
+
+
+
+  template<typename _Yp_ptr, typename _Tp_ptr>
+    struct __sp_compatible_with
+    : false_type
+    { };
+
+  template<typename _Yp, typename _Tp>
+    struct __sp_compatible_with<_Yp*, _Tp*>
+    : is_convertible<_Yp*, _Tp*>::type
+    { };
+
+  template<typename _Up, size_t _Nm>
+    struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
+    : true_type
+    { };
+
+  template<typename _Up, size_t _Nm>
+    struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
+    : true_type
+    { };
+
+  template<typename _Up, size_t _Nm>
+    struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
+    : true_type
+    { };
+
+  template<typename _Up, size_t _Nm>
+    struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
+    : true_type
+    { };
+
+
+  template<typename _Up, size_t _Nm, typename _Yp, typename = void>
+    struct __sp_is_constructible_arrN
+    : false_type
+    { };
+
+  template<typename _Up, size_t _Nm, typename _Yp>
+    struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
+    : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
+    { };
+
+
+  template<typename _Up, typename _Yp, typename = void>
+    struct __sp_is_constructible_arr
+    : false_type
+    { };
+
+  template<typename _Up, typename _Yp>
+    struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
+    : is_convertible<_Yp(*)[], _Up(*)[]>::type
+    { };
+
+
+  template<typename _Tp, typename _Yp>
+    struct __sp_is_constructible;
+
+
+  template<typename _Up, size_t _Nm, typename _Yp>
+    struct __sp_is_constructible<_Up[_Nm], _Yp>
+    : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
+    { };
+
+
+  template<typename _Up, typename _Yp>
+    struct __sp_is_constructible<_Up[], _Yp>
+    : __sp_is_constructible_arr<_Up, _Yp>::type
+    { };
+
+
+  template<typename _Tp, typename _Yp>
+    struct __sp_is_constructible
+    : is_convertible<_Yp*, _Tp*>::type
+    { };
+
+
+
+  template<typename _Tp, _Lock_policy _Lp,
+    bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
+    class __shared_ptr_access
+    {
+    public:
+      using element_type = _Tp;
+
+      element_type&
+      operator*() const noexcept
+      {
+ ;
+ return *_M_get();
+      }
+
+      element_type*
+      operator->() const noexcept
+      {
+ ;
+ return _M_get();
+      }
+
+    private:
+      element_type*
+      _M_get() const noexcept
+      { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
+    };
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __shared_ptr_access<_Tp, _Lp, false, true>
+    {
+    public:
+      using element_type = _Tp;
+
+      element_type*
+      operator->() const noexcept
+      {
+ auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
+ ;
+ return __ptr;
+      }
+    };
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __shared_ptr_access<_Tp, _Lp, true, false>
+    {
+    public:
+      using element_type = typename remove_extent<_Tp>::type;
+
+
+      [[__deprecated__("shared_ptr<T[]>::operator* is absent from C++17")]]
+      element_type&
+      operator*() const noexcept
+      {
+ ;
+ return *_M_get();
+      }
+
+      [[__deprecated__("shared_ptr<T[]>::operator-> is absent from C++17")]]
+      element_type*
+      operator->() const noexcept
+      {
+ ;
+ return _M_get();
+      }
+
+
+      element_type&
+      operator[](ptrdiff_t __i) const
+      {
+ ;
+ ;
+ return _M_get()[__i];
+      }
+
+    private:
+      element_type*
+      _M_get() const noexcept
+      { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
+    };
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __shared_ptr
+    : public __shared_ptr_access<_Tp, _Lp>
+    {
+    public:
+      using element_type = typename remove_extent<_Tp>::type;
+
+    private:
+
+      template<typename _Yp>
+ using _SafeConv
+   = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;
+
+
+      template<typename _Yp, typename _Res = void>
+ using _Compatible = typename
+   enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;
+
+
+      template<typename _Yp>
+ using _Assignable = _Compatible<_Yp, __shared_ptr&>;
+
+
+      template<typename _Yp, typename _Del, typename _Res = void,
+        typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
+ using _UniqCompatible = typename enable_if<__and_<
+   __sp_compatible_with<_Yp*, _Tp*>, is_convertible<_Ptr, element_type*>
+   >::value, _Res>::type;
+
+
+      template<typename _Yp, typename _Del>
+ using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;
+
+    public:
+
+
+
+
+
+      constexpr __shared_ptr() noexcept
+      : _M_ptr(0), _M_refcount()
+      { }
+
+      template<typename _Yp, typename = _SafeConv<_Yp>>
+ explicit
+ __shared_ptr(_Yp* __p)
+ : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
+ {
+   static_assert( !is_void<_Yp>::value, "incomplete type" );
+   static_assert( sizeof(_Yp) > 0, "incomplete type" );
+   _M_enable_shared_from_this_with(__p);
+ }
+
+      template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
+ __shared_ptr(_Yp* __p, _Deleter __d)
+ : _M_ptr(__p), _M_refcount(__p, std::move(__d))
+ {
+   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
+       "deleter expression d(p) is well-formed");
+   _M_enable_shared_from_this_with(__p);
+ }
+
+      template<typename _Yp, typename _Deleter, typename _Alloc,
+        typename = _SafeConv<_Yp>>
+ __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
+ : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
+ {
+   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
+       "deleter expression d(p) is well-formed");
+   _M_enable_shared_from_this_with(__p);
+ }
+
+      template<typename _Deleter>
+ __shared_ptr(nullptr_t __p, _Deleter __d)
+ : _M_ptr(0), _M_refcount(__p, std::move(__d))
+ { }
+
+      template<typename _Deleter, typename _Alloc>
+        __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
+ : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
+ { }
+
+
+      template<typename _Yp>
+ __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
+       element_type* __p) noexcept
+ : _M_ptr(__p), _M_refcount(__r._M_refcount)
+ { }
+
+
+      template<typename _Yp>
+ __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r,
+       element_type* __p) noexcept
+ : _M_ptr(__p), _M_refcount()
+ {
+   _M_refcount._M_swap(__r._M_refcount);
+   __r._M_ptr = 0;
+ }
+
+      __shared_ptr(const __shared_ptr&) noexcept = default;
+      __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
+      ~__shared_ptr() = default;
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
+ : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
+ { }
+
+      __shared_ptr(__shared_ptr&& __r) noexcept
+      : _M_ptr(__r._M_ptr), _M_refcount()
+      {
+ _M_refcount._M_swap(__r._M_refcount);
+ __r._M_ptr = 0;
+      }
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
+ : _M_ptr(__r._M_ptr), _M_refcount()
+ {
+   _M_refcount._M_swap(__r._M_refcount);
+   __r._M_ptr = 0;
+ }
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
+ : _M_refcount(__r._M_refcount)
+ {
+
+
+   _M_ptr = __r._M_ptr;
+ }
+
+
+      template<typename _Yp, typename _Del,
+        typename = _UniqCompatible<_Yp, _Del>>
+ __shared_ptr(unique_ptr<_Yp, _Del>&& __r)
+ : _M_ptr(__r.get()), _M_refcount()
+ {
+   auto __raw = __to_address(__r.get());
+   _M_refcount = __shared_count<_Lp>(std::move(__r));
+   _M_enable_shared_from_this_with(__raw);
+ }
+
+
+    protected:
+
+      template<typename _Tp1, typename _Del,
+        typename enable_if<__and_<
+   __not_<is_array<_Tp>>, is_array<_Tp1>,
+          is_convertible<typename unique_ptr<_Tp1, _Del>::pointer, _Tp*>
+        >::value, bool>::type = true>
+ __shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete)
+ : _M_ptr(__r.get()), _M_refcount()
+ {
+   auto __raw = __to_address(__r.get());
+   _M_refcount = __shared_count<_Lp>(std::move(__r));
+   _M_enable_shared_from_this_with(__raw);
+ }
+    public:
+
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __shared_ptr(auto_ptr<_Yp>&& __r);
+#pragma GCC diagnostic pop
+
+
+      constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }
+
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
+ {
+   _M_ptr = __r._M_ptr;
+   _M_refcount = __r._M_refcount;
+   return *this;
+ }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(auto_ptr<_Yp>&& __r)
+ {
+   __shared_ptr(std::move(__r)).swap(*this);
+   return *this;
+ }
+#pragma GCC diagnostic pop
+
+
+      __shared_ptr&
+      operator=(__shared_ptr&& __r) noexcept
+      {
+ __shared_ptr(std::move(__r)).swap(*this);
+ return *this;
+      }
+
+      template<class _Yp>
+ _Assignable<_Yp>
+ operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
+ {
+   __shared_ptr(std::move(__r)).swap(*this);
+   return *this;
+ }
+
+      template<typename _Yp, typename _Del>
+ _UniqAssignable<_Yp, _Del>
+ operator=(unique_ptr<_Yp, _Del>&& __r)
+ {
+   __shared_ptr(std::move(__r)).swap(*this);
+   return *this;
+ }
+
+      void
+      reset() noexcept
+      { __shared_ptr().swap(*this); }
+
+      template<typename _Yp>
+ _SafeConv<_Yp>
+ reset(_Yp* __p)
+ {
+
+   ;
+   __shared_ptr(__p).swap(*this);
+ }
+
+      template<typename _Yp, typename _Deleter>
+ _SafeConv<_Yp>
+ reset(_Yp* __p, _Deleter __d)
+ { __shared_ptr(__p, std::move(__d)).swap(*this); }
+
+      template<typename _Yp, typename _Deleter, typename _Alloc>
+ _SafeConv<_Yp>
+ reset(_Yp* __p, _Deleter __d, _Alloc __a)
+        { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }
+
+
+      element_type*
+      get() const noexcept
+      { return _M_ptr; }
+
+
+      explicit operator bool() const
+      { return _M_ptr == 0 ? false : true; }
+
+
+      bool
+      unique() const noexcept
+      { return _M_refcount._M_unique(); }
+
+
+      long
+      use_count() const noexcept
+      { return _M_refcount._M_get_use_count(); }
+
+
+      void
+      swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
+      {
+ std::swap(_M_ptr, __other._M_ptr);
+ _M_refcount._M_swap(__other._M_refcount);
+      }
+# 1356 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+      template<typename _Tp1>
+ bool
+ owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
+ { return _M_refcount._M_less(__rhs._M_refcount); }
+
+      template<typename _Tp1>
+ bool
+ owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
+ { return _M_refcount._M_less(__rhs._M_refcount); }
+
+
+    protected:
+
+      template<typename _Alloc, typename... _Args>
+ __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
+ : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
+ { _M_enable_shared_from_this_with(_M_ptr); }
+
+      template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
+        typename... _Args>
+ friend __shared_ptr<_Tp1, _Lp1>
+ __allocate_shared(const _Alloc& __a, _Args&&... __args);
+
+
+
+      __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t)
+      : _M_refcount(__r._M_refcount, std::nothrow)
+      {
+ _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
+      }
+
+      friend class __weak_ptr<_Tp, _Lp>;
+
+    private:
+
+      template<typename _Yp>
+ using __esft_base_t = decltype(__enable_shared_from_this_base(
+       std::declval<const __shared_count<_Lp>&>(),
+       std::declval<_Yp*>()));
+
+
+      template<typename _Yp, typename = void>
+ struct __has_esft_base
+ : false_type { };
+
+      template<typename _Yp>
+ struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
+ : __not_<is_array<_Tp>> { };
+
+      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
+ typename enable_if<__has_esft_base<_Yp2>::value>::type
+ _M_enable_shared_from_this_with(_Yp* __p) noexcept
+ {
+   if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
+     __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
+ }
+
+      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
+ typename enable_if<!__has_esft_base<_Yp2>::value>::type
+ _M_enable_shared_from_this_with(_Yp*) noexcept
+ { }
+
+      void*
+      _M_get_deleter(const std::type_info& __ti) const noexcept
+      { return _M_refcount._M_get_deleter(__ti); }
+
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
+
+      template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
+ friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
+
+      template<typename _Del, typename _Tp1>
+ friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;
+
+      element_type* _M_ptr;
+      __shared_count<_Lp> _M_refcount;
+    };
+
+
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator==(const __shared_ptr<_Tp1, _Lp>& __a,
+        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return __a.get() == __b.get(); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return !__a; }
+# 1463 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return !__a; }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
+        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return __a.get() != __b.get(); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return (bool)__a; }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return (bool)__a; }
+
+  template<typename _Tp, typename _Up, _Lock_policy _Lp>
+    inline bool
+    operator<(const __shared_ptr<_Tp, _Lp>& __a,
+       const __shared_ptr<_Up, _Lp>& __b) noexcept
+    {
+      using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
+      using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
+      using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
+      return less<_Vp>()(__a.get(), __b.get());
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    {
+      using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
+      return less<_Tp_elt*>()(__a.get(), nullptr);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    {
+      using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
+      return less<_Tp_elt*>()(nullptr, __a.get());
+    }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
+        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return !(__b < __a); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return !(nullptr < __a); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return !(__a < nullptr); }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator>(const __shared_ptr<_Tp1, _Lp>& __a,
+       const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return (__b < __a); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return nullptr < __a; }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return __a < nullptr; }
+
+  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
+    inline bool
+    operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
+        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
+    { return !(__a < __b); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
+    { return !(__a < nullptr); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
+    { return !(nullptr < __a); }
+
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
+    { __a.swap(__b); }
+# 1573 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    {
+      using _Sp = __shared_ptr<_Tp, _Lp>;
+      return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
+    }
+
+
+
+
+
+
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    {
+      using _Sp = __shared_ptr<_Tp, _Lp>;
+      return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
+    }
+
+
+
+
+
+
+  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
+    {
+      using _Sp = __shared_ptr<_Tp, _Lp>;
+      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
+ return _Sp(__r, __p);
+      return _Sp();
+    }
+# 1619 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+  template<typename _Tp, _Lock_policy _Lp>
+    class __weak_ptr
+    {
+      template<typename _Yp, typename _Res = void>
+ using _Compatible = typename
+   enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;
+
+
+      template<typename _Yp>
+ using _Assignable = _Compatible<_Yp, __weak_ptr&>;
+
+    public:
+      using element_type = typename remove_extent<_Tp>::type;
+
+      constexpr __weak_ptr() noexcept
+      : _M_ptr(nullptr), _M_refcount()
+      { }
+
+      __weak_ptr(const __weak_ptr&) noexcept = default;
+
+      ~__weak_ptr() = default;
+# 1655 "/usr/include/c++/10.2.0/bits/shared_ptr_base.h" 3
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
+ : _M_refcount(__r._M_refcount)
+        { _M_ptr = __r.lock().get(); }
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
+ : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
+ { }
+
+      __weak_ptr(__weak_ptr&& __r) noexcept
+      : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
+      { __r._M_ptr = nullptr; }
+
+      template<typename _Yp, typename = _Compatible<_Yp>>
+ __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
+ : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
+        { __r._M_ptr = nullptr; }
+
+      __weak_ptr&
+      operator=(const __weak_ptr& __r) noexcept = default;
+
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
+ {
+   _M_ptr = __r.lock().get();
+   _M_refcount = __r._M_refcount;
+   return *this;
+ }
+
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
+ {
+   _M_ptr = __r._M_ptr;
+   _M_refcount = __r._M_refcount;
+   return *this;
+ }
+
+      __weak_ptr&
+      operator=(__weak_ptr&& __r) noexcept
+      {
+ _M_ptr = __r._M_ptr;
+ _M_refcount = std::move(__r._M_refcount);
+ __r._M_ptr = nullptr;
+ return *this;
+      }
+
+      template<typename _Yp>
+ _Assignable<_Yp>
+ operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
+ {
+   _M_ptr = __r.lock().get();
+   _M_refcount = std::move(__r._M_refcount);
+   __r._M_ptr = nullptr;
+   return *this;
+ }
+
+      __shared_ptr<_Tp, _Lp>
+      lock() const noexcept
+      { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }
+
+      long
+      use_count() const noexcept
+      { return _M_refcount._M_get_use_count(); }
+
+      bool
+      expired() const noexcept
+      { return _M_refcount._M_get_use_count() == 0; }
+
+      template<typename _Tp1>
+ bool
+ owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
+ { return _M_refcount._M_less(__rhs._M_refcount); }
+
+      template<typename _Tp1>
+ bool
+ owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
+ { return _M_refcount._M_less(__rhs._M_refcount); }
+
+      void
+      reset() noexcept
+      { __weak_ptr().swap(*this); }
+
+      void
+      swap(__weak_ptr& __s) noexcept
+      {
+ std::swap(_M_ptr, __s._M_ptr);
+ _M_refcount._M_swap(__s._M_refcount);
+      }
+
+    private:
+
+      void
+      _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
+      {
+ if (use_count() == 0)
+   {
+     _M_ptr = __ptr;
+     _M_refcount = __refcount;
+   }
+      }
+
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
+      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
+      friend class __enable_shared_from_this<_Tp, _Lp>;
+      friend class enable_shared_from_this<_Tp>;
+
+      element_type* _M_ptr;
+      __weak_count<_Lp> _M_refcount;
+    };
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
+    { __a.swap(__b); }
+
+  template<typename _Tp, typename _Tp1>
+    struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
+      { return __lhs.owner_before(__rhs); }
+
+      bool
+      operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
+      { return __lhs.owner_before(__rhs); }
+
+      bool
+      operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
+      { return __lhs.owner_before(__rhs); }
+    };
+
+  template<>
+    struct _Sp_owner_less<void, void>
+    {
+      template<typename _Tp, typename _Up>
+ auto
+ operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
+ -> decltype(__lhs.owner_before(__rhs))
+ { return __lhs.owner_before(__rhs); }
+
+      using is_transparent = void;
+    };
+
+  template<typename _Tp, _Lock_policy _Lp>
+    struct owner_less<__shared_ptr<_Tp, _Lp>>
+    : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
+    { };
+
+  template<typename _Tp, _Lock_policy _Lp>
+    struct owner_less<__weak_ptr<_Tp, _Lp>>
+    : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
+    { };
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    class __enable_shared_from_this
+    {
+    protected:
+      constexpr __enable_shared_from_this() noexcept { }
+
+      __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
+
+      __enable_shared_from_this&
+      operator=(const __enable_shared_from_this&) noexcept
+      { return *this; }
+
+      ~__enable_shared_from_this() { }
+
+    public:
+      __shared_ptr<_Tp, _Lp>
+      shared_from_this()
+      { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
+
+      __shared_ptr<const _Tp, _Lp>
+      shared_from_this() const
+      { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
+
+
+      __weak_ptr<_Tp, _Lp>
+      weak_from_this() noexcept
+      { return this->_M_weak_this; }
+
+      __weak_ptr<const _Tp, _Lp>
+      weak_from_this() const noexcept
+      { return this->_M_weak_this; }
+
+
+    private:
+      template<typename _Tp1>
+ void
+ _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
+ { _M_weak_this._M_assign(__p, __n); }
+
+      friend const __enable_shared_from_this*
+      __enable_shared_from_this_base(const __shared_count<_Lp>&,
+         const __enable_shared_from_this* __p)
+      { return __p; }
+
+      template<typename, _Lock_policy>
+ friend class __shared_ptr;
+
+      mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
+    };
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
+    typename _Alloc, typename... _Args>
+    inline __shared_ptr<_Tp, _Lp>
+    __allocate_shared(const _Alloc& __a, _Args&&... __args)
+    {
+      return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a},
+        std::forward<_Args>(__args)...);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
+    typename... _Args>
+    inline __shared_ptr<_Tp, _Lp>
+    __make_shared(_Args&&... __args)
+    {
+      typedef typename std::remove_const<_Tp>::type _Tp_nc;
+      return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
+           std::forward<_Args>(__args)...);
+    }
+
+
+  template<typename _Tp, _Lock_policy _Lp>
+    struct hash<__shared_ptr<_Tp, _Lp>>
+    : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
+    {
+      size_t
+      operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
+      {
+ return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
+     __s.get());
+      }
+    };
+
+
+}
+# 53 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 67 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
+    inline std::basic_ostream<_Ch, _Tr>&
+    operator<<(std::basic_ostream<_Ch, _Tr>& __os,
+        const __shared_ptr<_Tp, _Lp>& __p)
+    {
+      __os << __p.get();
+      return __os;
+    }
+
+  template<typename _Del, typename _Tp, _Lock_policy _Lp>
+    inline _Del*
+    get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
+    {
+
+      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
+
+
+
+    }
+
+
+
+
+
+  template<typename _Del, typename _Tp>
+    inline _Del*
+    get_deleter(const shared_ptr<_Tp>& __p) noexcept
+    {
+
+      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
+
+
+
+    }
+# 120 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp>
+    class shared_ptr : public __shared_ptr<_Tp>
+    {
+      template<typename... _Args>
+ using _Constructible = typename enable_if<
+   is_constructible<__shared_ptr<_Tp>, _Args...>::value
+ >::type;
+
+      template<typename _Arg>
+ using _Assignable = typename enable_if<
+   is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
+ >::type;
+
+    public:
+
+
+      using element_type = typename __shared_ptr<_Tp>::element_type;
+# 147 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }
+
+      shared_ptr(const shared_ptr&) noexcept = default;
+
+
+
+
+
+
+
+      template<typename _Yp, typename = _Constructible<_Yp*>>
+ explicit
+ shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }
+# 174 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp, typename _Deleter,
+        typename = _Constructible<_Yp*, _Deleter>>
+ shared_ptr(_Yp* __p, _Deleter __d)
+        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
+# 192 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Deleter>
+ shared_ptr(nullptr_t __p, _Deleter __d)
+        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
+# 211 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp, typename _Deleter, typename _Alloc,
+        typename = _Constructible<_Yp*, _Deleter, _Alloc>>
+ shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
+ : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
+# 231 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Deleter, typename _Alloc>
+ shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
+ : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
+# 255 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp>
+ shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
+ : __shared_ptr<_Tp>(__r, __p) { }
+# 293 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp,
+        typename = _Constructible<const shared_ptr<_Yp>&>>
+ shared_ptr(const shared_ptr<_Yp>& __r) noexcept
+        : __shared_ptr<_Tp>(__r) { }
+
+
+
+
+
+
+      shared_ptr(shared_ptr&& __r) noexcept
+      : __shared_ptr<_Tp>(std::move(__r)) { }
+
+
+
+
+
+
+      template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
+ shared_ptr(shared_ptr<_Yp>&& __r) noexcept
+ : __shared_ptr<_Tp>(std::move(__r)) { }
+# 323 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+      template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
+ explicit shared_ptr(const weak_ptr<_Yp>& __r)
+ : __shared_ptr<_Tp>(__r) { }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+      template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
+ shared_ptr(auto_ptr<_Yp>&& __r);
+#pragma GCC diagnostic pop
+
+
+
+
+      template<typename _Yp, typename _Del,
+        typename = _Constructible<unique_ptr<_Yp, _Del>>>
+ shared_ptr(unique_ptr<_Yp, _Del>&& __r)
+ : __shared_ptr<_Tp>(std::move(__r)) { }
+
+
+
+
+
+      template<typename _Yp, typename _Del,
+  _Constructible<unique_ptr<_Yp, _Del>, __sp_array_delete>* = 0>
+ shared_ptr(unique_ptr<_Yp, _Del>&& __r)
+ : __shared_ptr<_Tp>(std::move(__r), __sp_array_delete()) { }
+
+
+
+
+
+
+      constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }
+
+      shared_ptr& operator=(const shared_ptr&) noexcept = default;
+
+      template<typename _Yp>
+ _Assignable<const shared_ptr<_Yp>&>
+ operator=(const shared_ptr<_Yp>& __r) noexcept
+ {
+   this->__shared_ptr<_Tp>::operator=(__r);
+   return *this;
+ }
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+      template<typename _Yp>
+ _Assignable<auto_ptr<_Yp>>
+ operator=(auto_ptr<_Yp>&& __r)
+ {
+   this->__shared_ptr<_Tp>::operator=(std::move(__r));
+   return *this;
+ }
+#pragma GCC diagnostic pop
+
+
+      shared_ptr&
+      operator=(shared_ptr&& __r) noexcept
+      {
+ this->__shared_ptr<_Tp>::operator=(std::move(__r));
+ return *this;
+      }
+
+      template<class _Yp>
+ _Assignable<shared_ptr<_Yp>>
+ operator=(shared_ptr<_Yp>&& __r) noexcept
+ {
+   this->__shared_ptr<_Tp>::operator=(std::move(__r));
+   return *this;
+ }
+
+      template<typename _Yp, typename _Del>
+ _Assignable<unique_ptr<_Yp, _Del>>
+ operator=(unique_ptr<_Yp, _Del>&& __r)
+ {
+   this->__shared_ptr<_Tp>::operator=(std::move(__r));
+   return *this;
+ }
+
+    private:
+
+      template<typename _Alloc, typename... _Args>
+ shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
+ : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
+ { }
+
+      template<typename _Yp, typename _Alloc, typename... _Args>
+ friend shared_ptr<_Yp>
+ allocate_shared(const _Alloc& __a, _Args&&... __args);
+
+
+      shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t)
+      : __shared_ptr<_Tp>(__r, std::nothrow) { }
+
+      friend class weak_ptr<_Tp>;
+    };
+# 434 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp, typename _Up>
+    inline bool
+    operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return __a.get() == __b.get(); }
+
+
+  template<typename _Tp>
+    inline bool
+    operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return !__a; }
+# 461 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp>
+    inline bool
+    operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return !__a; }
+
+
+  template<typename _Tp, typename _Up>
+    inline bool
+    operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return __a.get() != __b.get(); }
+
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return (bool)__a; }
+
+
+  template<typename _Tp>
+    inline bool
+    operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return (bool)__a; }
+
+
+  template<typename _Tp, typename _Up>
+    inline bool
+    operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    {
+      using _Tp_elt = typename shared_ptr<_Tp>::element_type;
+      using _Up_elt = typename shared_ptr<_Up>::element_type;
+      using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
+      return less<_Vp>()(__a.get(), __b.get());
+    }
+
+
+  template<typename _Tp>
+    inline bool
+    operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    {
+      using _Tp_elt = typename shared_ptr<_Tp>::element_type;
+      return less<_Tp_elt*>()(__a.get(), nullptr);
+    }
+
+
+  template<typename _Tp>
+    inline bool
+    operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    {
+      using _Tp_elt = typename shared_ptr<_Tp>::element_type;
+      return less<_Tp_elt*>()(nullptr, __a.get());
+    }
+
+
+  template<typename _Tp, typename _Up>
+    inline bool
+    operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return !(__b < __a); }
+
+
+  template<typename _Tp>
+    inline bool
+    operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return !(nullptr < __a); }
+
+
+  template<typename _Tp>
+    inline bool
+    operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return !(__a < nullptr); }
+
+
+  template<typename _Tp, typename _Up>
+    inline bool
+    operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return (__b < __a); }
+
+
+  template<typename _Tp>
+    inline bool
+    operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return nullptr < __a; }
+
+
+  template<typename _Tp>
+    inline bool
+    operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return __a < nullptr; }
+
+
+  template<typename _Tp, typename _Up>
+    inline bool
+    operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
+    { return !(__a < __b); }
+
+
+  template<typename _Tp>
+    inline bool
+    operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
+    { return !(__a < nullptr); }
+
+
+  template<typename _Tp>
+    inline bool
+    operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
+    { return !(nullptr < __a); }
+
+
+
+
+
+  template<typename _Tp>
+    inline void
+    swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
+    { __a.swap(__b); }
+
+
+
+
+  template<typename _Tp, typename _Up>
+    inline shared_ptr<_Tp>
+    static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
+    {
+      using _Sp = shared_ptr<_Tp>;
+      return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
+    }
+
+
+  template<typename _Tp, typename _Up>
+    inline shared_ptr<_Tp>
+    const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
+    {
+      using _Sp = shared_ptr<_Tp>;
+      return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
+    }
+
+
+  template<typename _Tp, typename _Up>
+    inline shared_ptr<_Tp>
+    dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
+    {
+      using _Sp = shared_ptr<_Tp>;
+      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
+ return _Sp(__r, __p);
+      return _Sp();
+    }
+# 684 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp>
+    class weak_ptr : public __weak_ptr<_Tp>
+    {
+      template<typename _Arg>
+ using _Constructible = typename enable_if<
+   is_constructible<__weak_ptr<_Tp>, _Arg>::value
+ >::type;
+
+      template<typename _Arg>
+ using _Assignable = typename enable_if<
+   is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
+ >::type;
+
+    public:
+      constexpr weak_ptr() noexcept = default;
+
+      template<typename _Yp,
+        typename = _Constructible<const shared_ptr<_Yp>&>>
+ weak_ptr(const shared_ptr<_Yp>& __r) noexcept
+ : __weak_ptr<_Tp>(__r) { }
+
+      weak_ptr(const weak_ptr&) noexcept = default;
+
+      template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
+ weak_ptr(const weak_ptr<_Yp>& __r) noexcept
+ : __weak_ptr<_Tp>(__r) { }
+
+      weak_ptr(weak_ptr&&) noexcept = default;
+
+      template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
+ weak_ptr(weak_ptr<_Yp>&& __r) noexcept
+ : __weak_ptr<_Tp>(std::move(__r)) { }
+
+      weak_ptr&
+      operator=(const weak_ptr& __r) noexcept = default;
+
+      template<typename _Yp>
+ _Assignable<const weak_ptr<_Yp>&>
+ operator=(const weak_ptr<_Yp>& __r) noexcept
+ {
+   this->__weak_ptr<_Tp>::operator=(__r);
+   return *this;
+ }
+
+      template<typename _Yp>
+ _Assignable<const shared_ptr<_Yp>&>
+ operator=(const shared_ptr<_Yp>& __r) noexcept
+ {
+   this->__weak_ptr<_Tp>::operator=(__r);
+   return *this;
+ }
+
+      weak_ptr&
+      operator=(weak_ptr&& __r) noexcept = default;
+
+      template<typename _Yp>
+ _Assignable<weak_ptr<_Yp>>
+ operator=(weak_ptr<_Yp>&& __r) noexcept
+ {
+   this->__weak_ptr<_Tp>::operator=(std::move(__r));
+   return *this;
+ }
+
+      shared_ptr<_Tp>
+      lock() const noexcept
+      { return shared_ptr<_Tp>(*this, std::nothrow); }
+    };
+# 760 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp>
+    inline void
+    swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
+    { __a.swap(__b); }
+
+
+
+  template<typename _Tp = void>
+    struct owner_less;
+
+
+  template<>
+    struct owner_less<void> : _Sp_owner_less<void, void>
+    { };
+
+
+  template<typename _Tp>
+    struct owner_less<shared_ptr<_Tp>>
+    : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
+    { };
+
+
+  template<typename _Tp>
+    struct owner_less<weak_ptr<_Tp>>
+    : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
+    { };
+
+
+
+
+  template<typename _Tp>
+    class enable_shared_from_this
+    {
+    protected:
+      constexpr enable_shared_from_this() noexcept { }
+
+      enable_shared_from_this(const enable_shared_from_this&) noexcept { }
+
+      enable_shared_from_this&
+      operator=(const enable_shared_from_this&) noexcept
+      { return *this; }
+
+      ~enable_shared_from_this() { }
+
+    public:
+      shared_ptr<_Tp>
+      shared_from_this()
+      { return shared_ptr<_Tp>(this->_M_weak_this); }
+
+      shared_ptr<const _Tp>
+      shared_from_this() const
+      { return shared_ptr<const _Tp>(this->_M_weak_this); }
+
+
+
+      weak_ptr<_Tp>
+      weak_from_this() noexcept
+      { return this->_M_weak_this; }
+
+      weak_ptr<const _Tp>
+      weak_from_this() const noexcept
+      { return this->_M_weak_this; }
+
+
+    private:
+      template<typename _Tp1>
+ void
+ _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
+ { _M_weak_this._M_assign(__p, __n); }
+
+
+      friend const enable_shared_from_this*
+      __enable_shared_from_this_base(const __shared_count<>&,
+         const enable_shared_from_this* __p)
+      { return __p; }
+
+      template<typename, _Lock_policy>
+ friend class __shared_ptr;
+
+      mutable weak_ptr<_Tp> _M_weak_this;
+    };
+# 855 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp, typename _Alloc, typename... _Args>
+    inline shared_ptr<_Tp>
+    allocate_shared(const _Alloc& __a, _Args&&... __args)
+    {
+      return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
+        std::forward<_Args>(__args)...);
+    }
+# 870 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+  template<typename _Tp, typename... _Args>
+    inline shared_ptr<_Tp>
+    make_shared(_Args&&... __args)
+    {
+      typedef typename std::remove_cv<_Tp>::type _Tp_nc;
+      return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
+           std::forward<_Args>(__args)...);
+    }
+
+
+  template<typename _Tp>
+    struct hash<shared_ptr<_Tp>>
+    : public __hash_base<size_t, shared_ptr<_Tp>>
+    {
+      size_t
+      operator()(const shared_ptr<_Tp>& __s) const noexcept
+      {
+ return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
+      }
+    };
+# 915 "/usr/include/c++/10.2.0/bits/shared_ptr.h" 3
+
+}
+# 85 "/usr/include/c++/10.2.0/memory" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+# 1 "/usr/include/c++/10.2.0/bits/atomic_base.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/atomic_lockfree_defines.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/atomic_lockfree_defines.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/atomic_lockfree_defines.h" 3
+# 38 "/usr/include/c++/10.2.0/bits/atomic_base.h" 2 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 74 "/usr/include/c++/10.2.0/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(int(__m) | int(__mod));
+  }
+
+  constexpr memory_order
+  operator&(memory_order __m, __memory_order_modifier __mod)
+  {
+    return memory_order(int(__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)
+      | __memory_order_modifier(__m & __memory_order_modifier_mask));
+  }
+
+  inline __attribute__((__always_inline__)) void
+  atomic_thread_fence(memory_order __m) noexcept
+  { __atomic_thread_fence(int(__m)); }
+
+  inline __attribute__((__always_inline__)) void
+  atomic_signal_fence(memory_order __m) noexcept
+  { __atomic_signal_fence(int(__m)); }
+
+
+  template<typename _Tp>
+    inline _Tp
+    kill_dependency(_Tp __y) noexcept
+    {
+      _Tp __ret(__y);
+      return __ret;
+    }
+
+
+
+  template<typename _IntTp>
+    struct __atomic_base;
+# 151 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+  template<typename _Tp>
+    struct atomic;
+
+  template<typename _Tp>
+    struct atomic<_Tp*>;
+
+
+
+    typedef bool __atomic_flag_data_type;
+# 174 "/usr/include/c++/10.2.0/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, int(__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, int(__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, int(__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, int(__m));
+    }
+
+  private:
+    static constexpr __atomic_flag_data_type
+    _S_init(bool __i)
+    { return __i ? 1 : 0; }
+  };
+# 264 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+  template<typename _ITp>
+    struct __atomic_base
+    {
+      using value_type = _ITp;
+      using difference_type = value_type;
+
+    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, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator+=(__int_type __i) noexcept
+      { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator+=(__int_type __i) volatile noexcept
+      { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator-=(__int_type __i) noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator-=(__int_type __i) volatile noexcept
+      { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator&=(__int_type __i) noexcept
+      { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator&=(__int_type __i) volatile noexcept
+      { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator|=(__int_type __i) noexcept
+      { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator|=(__int_type __i) volatile noexcept
+      { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator^=(__int_type __i) noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      __int_type
+      operator^=(__int_type __i) volatile noexcept
+      { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); }
+
+      bool
+      is_lock_free() const noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-_S_alignment));
+      }
+
+      bool
+      is_lock_free() const volatile noexcept
+      {
+
+ return __atomic_is_lock_free(sizeof(_M_i),
+     reinterpret_cast<void *>(-_S_alignment));
+      }
+
+      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, int(__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, int(__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, int(__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, int(__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, int(__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, int(__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,
+        int(__m1), int(__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,
+        int(__m1), int(__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,
+        int(__m1), int(__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,
+        int(__m1), int(__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, int(__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, int(__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, int(__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, int(__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, int(__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, int(__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, int(__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, int(__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, int(__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, int(__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),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator++() volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(1),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator--() noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator--() volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(1),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator+=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_add_fetch(&_M_p, _M_type_size(__d),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+      int(memory_order_seq_cst)); }
+
+      __pointer_type
+      operator-=(ptrdiff_t __d) volatile noexcept
+      { return __atomic_sub_fetch(&_M_p, _M_type_size(__d),
+      int(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, int(__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, int(__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, int(__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, int(__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, int(__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, int(__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,
+        int(__m1), int(__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,
+        int(__m1), int(__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), int(__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), int(__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), int(__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), int(__m)); }
+    };
+# 1700 "/usr/include/c++/10.2.0/bits/atomic_base.h" 3
+
+}
+# 34 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 47 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  struct _Sp_locker
+  {
+    _Sp_locker(const _Sp_locker&) = delete;
+    _Sp_locker& operator=(const _Sp_locker&) = delete;
+
+
+    explicit
+    _Sp_locker(const void*) noexcept;
+    _Sp_locker(const void*, const void*) noexcept;
+    ~_Sp_locker();
+
+  private:
+    unsigned char _M_key1;
+    unsigned char _M_key2;
+
+
+
+  };
+# 74 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
+    {
+
+      return __gthread_active_p() == 0;
+
+
+
+    }
+
+  template<typename _Tp>
+    inline bool
+    atomic_is_lock_free(const shared_ptr<_Tp>* __p)
+    { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
+# 101 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp>
+    inline shared_ptr<_Tp>
+    atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
+    {
+      _Sp_locker __lock{__p};
+      return *__p;
+    }
+
+  template<typename _Tp>
+    inline shared_ptr<_Tp>
+    atomic_load(const shared_ptr<_Tp>* __p)
+    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
+    {
+      _Sp_locker __lock{__p};
+      return *__p;
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
+    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
+# 137 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp>
+    inline void
+    atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
+     memory_order)
+    {
+      _Sp_locker __lock{__p};
+      __p->swap(__r);
+    }
+
+  template<typename _Tp>
+    inline void
+    atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
+    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
+     __shared_ptr<_Tp, _Lp> __r,
+     memory_order)
+    {
+      _Sp_locker __lock{__p};
+      __p->swap(__r);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline void
+    atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
+    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
+# 174 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp>
+    inline shared_ptr<_Tp>
+    atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
+        memory_order)
+    {
+      _Sp_locker __lock{__p};
+      __p->swap(__r);
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline shared_ptr<_Tp>
+    atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
+    {
+      return std::atomic_exchange_explicit(__p, std::move(__r),
+        memory_order_seq_cst);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
+        __shared_ptr<_Tp, _Lp> __r,
+        memory_order)
+    {
+      _Sp_locker __lock{__p};
+      __p->swap(__r);
+      return __r;
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline __shared_ptr<_Tp, _Lp>
+    atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
+    {
+      return std::atomic_exchange_explicit(__p, std::move(__r),
+        memory_order_seq_cst);
+    }
+# 223 "/usr/include/c++/10.2.0/bits/shared_ptr_atomic.h" 3
+  template<typename _Tp>
+    bool
+    atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
+         shared_ptr<_Tp>* __v,
+         shared_ptr<_Tp> __w,
+         memory_order,
+         memory_order)
+    {
+      shared_ptr<_Tp> __x;
+      _Sp_locker __lock{__p, __v};
+      owner_less<shared_ptr<_Tp>> __less;
+      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
+ {
+   __x = std::move(*__p);
+   *__p = std::move(__w);
+   return true;
+ }
+      __x = std::move(*__v);
+      *__v = *__p;
+      return false;
+    }
+
+  template<typename _Tp>
+    inline bool
+    atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
+     shared_ptr<_Tp> __w)
+    {
+      return std::atomic_compare_exchange_strong_explicit(__p, __v,
+   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+    }
+
+  template<typename _Tp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
+       shared_ptr<_Tp>* __v,
+       shared_ptr<_Tp> __w,
+       memory_order __success,
+       memory_order __failure)
+    {
+      return std::atomic_compare_exchange_strong_explicit(__p, __v,
+   std::move(__w), __success, __failure);
+    }
+
+  template<typename _Tp>
+    inline bool
+    atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
+     shared_ptr<_Tp> __w)
+    {
+      return std::atomic_compare_exchange_weak_explicit(__p, __v,
+   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    bool
+    atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
+         __shared_ptr<_Tp, _Lp>* __v,
+         __shared_ptr<_Tp, _Lp> __w,
+         memory_order,
+         memory_order)
+    {
+      __shared_ptr<_Tp, _Lp> __x;
+      _Sp_locker __lock{__p, __v};
+      owner_less<__shared_ptr<_Tp, _Lp>> __less;
+      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
+ {
+   __x = std::move(*__p);
+   *__p = std::move(__w);
+   return true;
+ }
+      __x = std::move(*__v);
+      *__v = *__p;
+      return false;
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
+       __shared_ptr<_Tp, _Lp>* __v,
+       __shared_ptr<_Tp, _Lp> __w)
+    {
+      return std::atomic_compare_exchange_strong_explicit(__p, __v,
+   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
+       __shared_ptr<_Tp, _Lp>* __v,
+       __shared_ptr<_Tp, _Lp> __w,
+       memory_order __success,
+       memory_order __failure)
+    {
+      return std::atomic_compare_exchange_strong_explicit(__p, __v,
+   std::move(__w), __success, __failure);
+    }
+
+  template<typename _Tp, _Lock_policy _Lp>
+    inline bool
+    atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
+     __shared_ptr<_Tp, _Lp>* __v,
+     __shared_ptr<_Tp, _Lp> __w)
+    {
+      return std::atomic_compare_exchange_weak_explicit(__p, __v,
+   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+    }
+
+
+
+
+
+
+}
+# 86 "/usr/include/c++/10.2.0/memory" 2 3
+
+# 1 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 1 3
+# 36 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 47 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+  template<typename _Tp1>
+    struct auto_ptr_ref
+    {
+      _Tp1* _M_ptr;
+
+      explicit
+      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
+    } __attribute__ ((__deprecated__));
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+# 88 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+  template<typename _Tp>
+    class auto_ptr
+    {
+    private:
+      _Tp* _M_ptr;
+
+    public:
+
+      typedef _Tp element_type;
+
+
+
+
+
+
+
+      explicit
+      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
+# 114 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
+# 126 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      template<typename _Tp1>
+        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
+# 137 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      auto_ptr&
+      operator=(auto_ptr& __a) throw()
+      {
+ reset(__a.release());
+ return *this;
+      }
+# 154 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      template<typename _Tp1>
+        auto_ptr&
+        operator=(auto_ptr<_Tp1>& __a) throw()
+        {
+   reset(__a.release());
+   return *this;
+ }
+# 172 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      ~auto_ptr() { delete _M_ptr; }
+# 182 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      element_type&
+      operator*() const throw()
+      {
+ ;
+ return *_M_ptr;
+      }
+
+
+
+
+
+
+
+      element_type*
+      operator->() const throw()
+      {
+ ;
+ return _M_ptr;
+      }
+# 212 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      element_type*
+      get() const throw() { return _M_ptr; }
+# 226 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      element_type*
+      release() throw()
+      {
+ element_type* __tmp = _M_ptr;
+ _M_ptr = 0;
+ return __tmp;
+      }
+# 241 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      void
+      reset(element_type* __p = 0) throw()
+      {
+ if (__p != _M_ptr)
+   {
+     delete _M_ptr;
+     _M_ptr = __p;
+   }
+      }
+# 266 "/usr/include/c++/10.2.0/backward/auto_ptr.h" 3
+      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
+      : _M_ptr(__ref._M_ptr) { }
+
+      auto_ptr&
+      operator=(auto_ptr_ref<element_type> __ref) throw()
+      {
+ if (__ref._M_ptr != this->get())
+   {
+     delete _M_ptr;
+     _M_ptr = __ref._M_ptr;
+   }
+ return *this;
+      }
+
+      template<typename _Tp1>
+        operator auto_ptr_ref<_Tp1>() throw()
+        { return auto_ptr_ref<_Tp1>(this->release()); }
+
+      template<typename _Tp1>
+        operator auto_ptr<_Tp1>() throw()
+        { return auto_ptr<_Tp1>(this->release()); }
+    } __attribute__ ((__deprecated__));
+
+
+
+  template<>
+    class auto_ptr<void>
+    {
+    public:
+      typedef void element_type;
+    } __attribute__ ((__deprecated__));
+
+
+  template<_Lock_policy _Lp>
+  template<typename _Tp>
+    inline
+    __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
+    : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
+    { __r.release(); }
+
+  template<typename _Tp, _Lock_policy _Lp>
+  template<typename _Tp1, typename>
+    inline
+    __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
+    : _M_ptr(__r.get()), _M_refcount()
+    {
+     
+      static_assert( sizeof(_Tp1) > 0, "incomplete type" );
+      _Tp1* __tmp = __r.get();
+      _M_refcount = __shared_count<_Lp>(std::move(__r));
+      _M_enable_shared_from_this_with(__tmp);
+    }
+
+  template<typename _Tp>
+  template<typename _Tp1, typename>
+    inline
+    shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
+    : __shared_ptr<_Tp>(std::move(__r)) { }
+
+  template<typename _Tp, typename _Dp>
+  template<typename _Up, typename>
+    inline
+    unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
+    : _M_t(__u.release(), deleter_type()) { }
+
+
+#pragma GCC diagnostic pop
+
+
+}
+# 88 "/usr/include/c++/10.2.0/memory" 2 3
+# 100 "/usr/include/c++/10.2.0/memory" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 122 "/usr/include/c++/10.2.0/memory" 3
+inline void*
+align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
+{
+
+  const auto __intptr = reinterpret_cast<uintptr_t>(__ptr);
+
+
+
+
+
+
+  const auto __aligned = (__intptr - 1u + __align) & -__align;
+  const auto __diff = __aligned - __intptr;
+  if ((__size + __diff) > __space)
+    return nullptr;
+  else
+    {
+      __space -= __diff;
+      return __ptr = reinterpret_cast<void*>(__aligned);
+    }
+}
+# 158 "/usr/include/c++/10.2.0/memory" 3
+enum class pointer_safety { relaxed, preferred, strict };
+
+
+inline void
+declare_reachable(void*) { }
+
+
+template <typename _Tp>
+  inline _Tp*
+  undeclare_reachable(_Tp* __p) { return __p; }
+
+
+inline void
+declare_no_pointers(char*, size_t) { }
+
+
+inline void
+undeclare_no_pointers(char*, size_t) { }
+
+
+inline pointer_safety
+get_pointer_safety() noexcept { return pointer_safety::relaxed; }
+# 400 "/usr/include/c++/10.2.0/memory" 3
+
+}
+# 16 "/home/ted/dev/openrct2/src/openrct2/Context.h" 2
+
+
+
+# 18 "/home/ted/dev/openrct2/src/openrct2/Context.h"
+struct IObjectManager;
+struct IObjectRepository;
+struct IScenarioRepository;
+enum class DrawingEngine : int32_t;
+enum class CursorID : uint8_t;
+
+namespace OpenRCT2
+{
+    struct IStream;
+}
+struct ITrackDesignRepository;
+struct IGameStateSnapshots;
+
+class Intent;
+struct rct_window;
+using rct_windowclass = uint8_t;
+struct NewVersionInfo;
+
+struct CursorState
+{
+    ScreenCoordsXY position;
+    uint8_t left, middle, right, any;
+    int32_t wheel;
+    int32_t old;
+    bool touch, touchIsDouble;
+    uint32_t touchDownTimestamp;
+};
+
+struct TextInputSession
+{
+    utf8* Buffer;
+    size_t BufferSize;
+    size_t Size;
+    size_t Length;
+    size_t SelectionStart;
+    size_t SelectionSize;
+
+    const utf8* ImeBuffer;
+};
+
+struct Resolution
+{
+    int32_t Width;
+    int32_t Height;
+};
+
+enum
+{
+    CURSOR_UP = 0,
+    CURSOR_DOWN = 1,
+    CURSOR_CHANGED = 2,
+    CURSOR_RELEASED = CURSOR_UP | CURSOR_CHANGED,
+    CURSOR_PRESSED = CURSOR_DOWN | CURSOR_CHANGED,
+};
+
+namespace OpenRCT2
+{
+    class GameState;
+
+    struct IPlatformEnvironment;
+    struct IReplayManager;
+
+    namespace Audio
+    {
+        struct IAudioContext;
+    }
+
+    namespace Drawing
+    {
+        struct IDrawingEngine;
+    }
+
+    namespace Localisation
+    {
+        class LocalisationService;
+    }
+
+    namespace Scripting
+    {
+        class ScriptEngine;
+    }
+
+    namespace Ui
+    {
+        struct IUiContext;
+    }
+
+    namespace Paint
+    {
+        struct Painter;
+    }
+
+
+
+
+    struct IContext
+    {
+        virtual ~IContext() = default;
+
+        virtual std::shared_ptr<Audio::IAudioContext> GetAudioContext() = 0;
+        virtual std::shared_ptr<Ui::IUiContext> GetUiContext() = 0;
+        virtual GameState* GetGameState() = 0;
+        virtual std::shared_ptr<IPlatformEnvironment> GetPlatformEnvironment() = 0;
+        virtual Localisation::LocalisationService& GetLocalisationService() = 0;
+        virtual IObjectManager& GetObjectManager() = 0;
+        virtual IObjectRepository& GetObjectRepository() = 0;
+
+
+
+        virtual ITrackDesignRepository* GetTrackDesignRepository() = 0;
+        virtual IScenarioRepository* GetScenarioRepository() = 0;
+        virtual IReplayManager* GetReplayManager() = 0;
+        virtual IGameStateSnapshots* GetGameStateSnapshots() = 0;
+        virtual DrawingEngine GetDrawingEngineType() = 0;
+        virtual Drawing::IDrawingEngine* GetDrawingEngine() = 0;
+        virtual Paint::Painter* GetPainter() = 0;
+
+        virtual int32_t RunOpenRCT2(int argc, const char** argv) = 0;
+
+        virtual bool Initialise() = 0;
+        virtual void InitialiseDrawingEngine() = 0;
+        virtual void DisposeDrawingEngine() = 0;
+        virtual bool LoadParkFromFile(const std::string& path, bool loadTitleScreenOnFail = false) = 0;
+        virtual bool LoadParkFromStream(
+            IStream* stream, const std::string& path, bool loadTitleScreenFirstOnFail = false) = 0;
+        virtual void WriteLine(const std::string& s) = 0;
+        virtual void WriteErrorLine(const std::string& s) = 0;
+        virtual void Finish() = 0;
+        virtual void Quit() = 0;
+
+        virtual bool HasNewVersionInfo() const = 0;
+        virtual const NewVersionInfo* GetNewVersionInfo() const = 0;
+
+
+
+        virtual std::string GetPathLegacy(int32_t pathId) = 0;
+
+        virtual void SetTimeScale(float newScale) = 0;
+        virtual float GetTimeScale() const = 0;
+    };
+
+    std::unique_ptr<IContext> CreateContext();
+    std::unique_ptr<IContext> CreateContext(
+        const std::shared_ptr<IPlatformEnvironment>& env, const std::shared_ptr<Audio::IAudioContext>& audioContext,
+        const std::shared_ptr<Ui::IUiContext>& uiContext);
+    IContext* GetContext();
+}
+
+enum
+{
+
+    GAME_UPDATE_TIME_MS = 25,
+
+    GAME_UPDATE_FPS = 40,
+
+    GAME_MAX_UPDATES = 4,
+
+    GAME_UPDATE_MAX_THRESHOLD = GAME_UPDATE_TIME_MS * GAME_MAX_UPDATES,
+};
+
+constexpr float GAME_MIN_TIME_SCALE = 0.1f;
+constexpr float GAME_MAX_TIME_SCALE = 5.0f;
+
+
+
+
+
+enum
+{
+    PATH_ID_G1,
+    PATH_ID_PLUGIN,
+    PATH_ID_CSS1,
+    PATH_ID_CSS2,
+    PATH_ID_CSS4,
+    PATH_ID_CSS5,
+    PATH_ID_CSS6,
+    PATH_ID_CSS7,
+    PATH_ID_CSS8,
+    PATH_ID_CSS9,
+    PATH_ID_CSS11,
+    PATH_ID_CSS12,
+    PATH_ID_CSS13,
+    PATH_ID_CSS14,
+    PATH_ID_CSS15,
+    PATH_ID_CSS3,
+    PATH_ID_CSS17,
+    PATH_ID_CSS18,
+    PATH_ID_CSS19,
+    PATH_ID_CSS20,
+    PATH_ID_CSS21,
+    PATH_ID_CSS22,
+    PATH_ID_SCORES,
+    PATH_ID_CSS23,
+    PATH_ID_CSS24,
+    PATH_ID_CSS25,
+    PATH_ID_CSS26,
+    PATH_ID_CSS27,
+    PATH_ID_CSS28,
+    PATH_ID_CSS29,
+    PATH_ID_CSS30,
+    PATH_ID_CSS31,
+    PATH_ID_CSS32,
+    PATH_ID_CSS33,
+    PATH_ID_CSS34,
+    PATH_ID_CSS35,
+    PATH_ID_CSS36,
+    PATH_ID_CSS37,
+    PATH_ID_CSS38,
+    PATH_ID_CUSTOM1,
+    PATH_ID_CUSTOM2,
+    PATH_ID_CSS39,
+    PATH_ID_CSS40,
+    PATH_ID_CSS41,
+    PATH_ID_SIXFLAGS_MAGICMOUNTAIN,
+    PATH_ID_CSS42,
+    PATH_ID_CSS43,
+    PATH_ID_CSS44,
+    PATH_ID_CSS45,
+    PATH_ID_CSS46,
+    PATH_ID_CSS50,
+    PATH_ID_END,
+};
+
+void context_init();
+void context_setcurrentcursor(CursorID cursor);
+void context_update_cursor_scale();
+void context_hide_cursor();
+void context_show_cursor();
+ScreenCoordsXY context_get_cursor_position();
+ScreenCoordsXY context_get_cursor_position_scaled();
+void context_set_cursor_position(const ScreenCoordsXY& cursorPosition);
+const CursorState* context_get_cursor_state();
+const uint8_t* context_get_keys_state();
+const uint8_t* context_get_keys_pressed();
+TextInputSession* context_start_text_input(utf8* buffer, size_t maxLength);
+void context_stop_text_input();
+bool context_is_input_active();
+void context_trigger_resize();
+void context_set_fullscreen_mode(int32_t mode);
+void context_recreate_window();
+int32_t context_get_width();
+int32_t context_get_height();
+bool context_has_focus();
+void context_set_cursor_trap(bool value);
+rct_window* context_open_window(rct_windowclass wc);
+rct_window* context_open_detail_window(uint8_t type, int32_t id);
+rct_window* context_open_window_view(uint8_t view);
+rct_window* context_show_error(rct_string_id title, rct_string_id message, const class Formatter& args);
+rct_window* context_open_intent(Intent* intent);
+void context_broadcast_intent(Intent* intent);
+void context_force_close_window_by_class(rct_windowclass wc);
+void context_update_map_tooltip();
+void context_handle_input();
+void context_input_handle_keyboard(bool isTitle);
+void context_quit();
+const utf8* context_get_path_legacy(int32_t pathId);
+bool context_load_park_from_file(const utf8* path);
+bool context_load_park_from_stream(void* stream);
+# 14 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/GameState.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/GameState.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/Date.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/Date.h"
+       
+
+
+
+namespace OpenRCT2
+{
+
+
+
+    class Date final
+    {
+    private:
+        uint16_t _monthTicks = 0;
+        uint32_t _monthsElapsed = 0;
+
+    public:
+        Date() = default;
+        Date(uint32_t monthsElapsed, uint16_t monthTicks);
+
+        static Date FromYMD(int32_t year, int32_t month = 0, int32_t day = 0);
+
+        void Update();
+
+        uint16_t GetMonthTicks() const;
+        uint32_t GetMonthsElapsed() const;
+        int32_t GetDay() const;
+        int32_t GetMonth() const;
+        int32_t GetYear() const;
+
+        bool IsDayStart() const;
+        bool IsWeekStart() const;
+        bool IsFortnightStart() const;
+        bool IsMonthStart() const;
+
+        static int32_t GetDaysInMonth(int32_t month);
+    };
+}
+# 13 "/home/ted/dev/openrct2/src/openrct2/GameState.h" 2
+
+
+# 1 "/usr/include/c++/10.2.0/chrono" 1 3
+# 33 "/usr/include/c++/10.2.0/chrono" 3
+       
+# 34 "/usr/include/c++/10.2.0/chrono" 3
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/ratio" 1 3
+# 33 "/usr/include/c++/10.2.0/ratio" 3
+       
+# 34 "/usr/include/c++/10.2.0/ratio" 3
+# 42 "/usr/include/c++/10.2.0/ratio" 3
+
+# 42 "/usr/include/c++/10.2.0/ratio" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 56 "/usr/include/c++/10.2.0/ratio" 3
+  template<intmax_t _Pn>
+    struct __static_sign
+    : integral_constant<intmax_t, (_Pn < 0) ? -1 : 1>
+    { };
+
+  template<intmax_t _Pn>
+    struct __static_abs
+    : integral_constant<intmax_t, _Pn * __static_sign<_Pn>::value>
+    { };
+
+  template<intmax_t _Pn, intmax_t _Qn>
+    struct __static_gcd
+    : __static_gcd<_Qn, (_Pn % _Qn)>
+    { };
+
+  template<intmax_t _Pn>
+    struct __static_gcd<_Pn, 0>
+    : integral_constant<intmax_t, __static_abs<_Pn>::value>
+    { };
+
+  template<intmax_t _Qn>
+    struct __static_gcd<0, _Qn>
+    : integral_constant<intmax_t, __static_abs<_Qn>::value>
+    { };
+
+
+
+
+
+
+
+  template<intmax_t _Pn, intmax_t _Qn>
+    struct __safe_multiply
+    {
+    private:
+      static const uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
+
+      static const uintmax_t __a0 = __static_abs<_Pn>::value % __c;
+      static const uintmax_t __a1 = __static_abs<_Pn>::value / __c;
+      static const uintmax_t __b0 = __static_abs<_Qn>::value % __c;
+      static const uintmax_t __b1 = __static_abs<_Qn>::value / __c;
+
+      static_assert(__a1 == 0 || __b1 == 0,
+      "overflow in multiplication");
+      static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1),
+      "overflow in multiplication");
+      static_assert(__b0 * __a0 <= 0x7fffffffffffffffL,
+      "overflow in multiplication");
+      static_assert((__a0 * __b1 + __b0 * __a1) * __c
+      <= 0x7fffffffffffffffL - __b0 * __a0,
+      "overflow in multiplication");
+
+    public:
+      static const intmax_t value = _Pn * _Qn;
+    };
+
+
+
+  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
+    struct __big_less
+    : integral_constant<bool, (__hi1 < __hi2
+          || (__hi1 == __hi2 && __lo1 < __lo2))>
+    { };
+
+  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
+    struct __big_add
+    {
+      static constexpr uintmax_t __lo = __lo1 + __lo2;
+      static constexpr uintmax_t __hi = (__hi1 + __hi2 +
+      (__lo1 + __lo2 < __lo1));
+    };
+
+
+  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
+    struct __big_sub
+    {
+      static_assert(!__big_less<__hi1, __lo1, __hi2, __lo2>::value,
+      "Internal library error");
+      static constexpr uintmax_t __lo = __lo1 - __lo2;
+      static constexpr uintmax_t __hi = (__hi1 - __hi2 -
+      (__lo1 < __lo2));
+    };
+
+
+  template<uintmax_t __x, uintmax_t __y>
+    struct __big_mul
+    {
+    private:
+      static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
+      static constexpr uintmax_t __x0 = __x % __c;
+      static constexpr uintmax_t __x1 = __x / __c;
+      static constexpr uintmax_t __y0 = __y % __c;
+      static constexpr uintmax_t __y1 = __y / __c;
+      static constexpr uintmax_t __x0y0 = __x0 * __y0;
+      static constexpr uintmax_t __x0y1 = __x0 * __y1;
+      static constexpr uintmax_t __x1y0 = __x1 * __y0;
+      static constexpr uintmax_t __x1y1 = __x1 * __y1;
+      static constexpr uintmax_t __mix = __x0y1 + __x1y0;
+      static constexpr uintmax_t __mix_lo = __mix * __c;
+      static constexpr uintmax_t __mix_hi
+      = __mix / __c + ((__mix < __x0y1) ? __c : 0);
+      typedef __big_add<__mix_hi, __mix_lo, __x1y1, __x0y0> _Res;
+    public:
+      static constexpr uintmax_t __hi = _Res::__hi;
+      static constexpr uintmax_t __lo = _Res::__lo;
+    };
+
+
+
+  template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
+    struct __big_div_impl
+    {
+    private:
+      static_assert(__d >= (uintmax_t(1) << (sizeof(intmax_t) * 8 - 1)),
+      "Internal library error");
+      static_assert(__n1 < __d, "Internal library error");
+      static constexpr uintmax_t __c = uintmax_t(1) << (sizeof(intmax_t) * 4);
+      static constexpr uintmax_t __d1 = __d / __c;
+      static constexpr uintmax_t __d0 = __d % __c;
+
+      static constexpr uintmax_t __q1x = __n1 / __d1;
+      static constexpr uintmax_t __r1x = __n1 % __d1;
+      static constexpr uintmax_t __m = __q1x * __d0;
+      static constexpr uintmax_t __r1y = __r1x * __c + __n0 / __c;
+      static constexpr uintmax_t __r1z = __r1y + __d;
+      static constexpr uintmax_t __r1
+      = ((__r1y < __m) ? ((__r1z >= __d) && (__r1z < __m))
+  ? (__r1z + __d) : __r1z : __r1y) - __m;
+      static constexpr uintmax_t __q1
+      = __q1x - ((__r1y < __m)
+   ? ((__r1z >= __d) && (__r1z < __m)) ? 2 : 1 : 0);
+      static constexpr uintmax_t __q0x = __r1 / __d1;
+      static constexpr uintmax_t __r0x = __r1 % __d1;
+      static constexpr uintmax_t __n = __q0x * __d0;
+      static constexpr uintmax_t __r0y = __r0x * __c + __n0 % __c;
+      static constexpr uintmax_t __r0z = __r0y + __d;
+      static constexpr uintmax_t __r0
+      = ((__r0y < __n) ? ((__r0z >= __d) && (__r0z < __n))
+  ? (__r0z + __d) : __r0z : __r0y) - __n;
+      static constexpr uintmax_t __q0
+      = __q0x - ((__r0y < __n) ? ((__r0z >= __d)
+      && (__r0z < __n)) ? 2 : 1 : 0);
+
+    public:
+      static constexpr uintmax_t __quot = __q1 * __c + __q0;
+      static constexpr uintmax_t __rem = __r0;
+
+    private:
+      typedef __big_mul<__quot, __d> _Prod;
+      typedef __big_add<_Prod::__hi, _Prod::__lo, 0, __rem> _Sum;
+      static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
+      "Internal library error");
+  };
+
+  template<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
+    struct __big_div
+    {
+    private:
+      static_assert(__d != 0, "Internal library error");
+      static_assert(sizeof (uintmax_t) == sizeof (unsigned long long),
+      "This library calls __builtin_clzll on uintmax_t, which "
+      "is unsafe on your platform. Please complain to "
+      "http://gcc.gnu.org/bugzilla/");
+      static constexpr int __shift = __builtin_clzll(__d);
+      static constexpr int __coshift_ = sizeof(uintmax_t) * 8 - __shift;
+      static constexpr int __coshift = (__shift != 0) ? __coshift_ : 0;
+      static constexpr uintmax_t __c1 = uintmax_t(1) << __shift;
+      static constexpr uintmax_t __c2 = uintmax_t(1) << __coshift;
+      static constexpr uintmax_t __new_d = __d * __c1;
+      static constexpr uintmax_t __new_n0 = __n0 * __c1;
+      static constexpr uintmax_t __n1_shifted = (__n1 % __d) * __c1;
+      static constexpr uintmax_t __n0_top = (__shift != 0) ? (__n0 / __c2) : 0;
+      static constexpr uintmax_t __new_n1 = __n1_shifted + __n0_top;
+      typedef __big_div_impl<__new_n1, __new_n0, __new_d> _Res;
+
+    public:
+      static constexpr uintmax_t __quot_hi = __n1 / __d;
+      static constexpr uintmax_t __quot_lo = _Res::__quot;
+      static constexpr uintmax_t __rem = _Res::__rem / __c1;
+
+    private:
+      typedef __big_mul<__quot_lo, __d> _P0;
+      typedef __big_mul<__quot_hi, __d> _P1;
+      typedef __big_add<_P0::__hi, _P0::__lo, _P1::__lo, __rem> _Sum;
+
+      static_assert(_P1::__hi == 0, "Internal library error");
+      static_assert(_Sum::__hi >= _P0::__hi, "Internal library error");
+
+      static_assert(_Sum::__hi == __n1 && _Sum::__lo == __n0,
+      "Internal library error");
+      static_assert(__rem < __d, "Internal library error");
+    };
+# 265 "/usr/include/c++/10.2.0/ratio" 3
+  template<intmax_t _Num, intmax_t _Den = 1>
+    struct ratio
+    {
+      static_assert(_Den != 0, "denominator cannot be zero");
+      static_assert(_Num >= -0x7fffffffffffffffL && _Den >= -0x7fffffffffffffffL,
+      "out of range");
+
+
+      static constexpr intmax_t num =
+        _Num * __static_sign<_Den>::value / __static_gcd<_Num, _Den>::value;
+
+      static constexpr intmax_t den =
+        __static_abs<_Den>::value / __static_gcd<_Num, _Den>::value;
+
+      typedef ratio<num, den> type;
+    };
+
+  template<intmax_t _Num, intmax_t _Den>
+    constexpr intmax_t ratio<_Num, _Den>::num;
+
+  template<intmax_t _Num, intmax_t _Den>
+    constexpr intmax_t ratio<_Num, _Den>::den;
+
+
+
+  template<typename _R1, typename _R2>
+    struct __ratio_multiply
+    {
+    private:
+      static const intmax_t __gcd1 =
+        __static_gcd<_R1::num, _R2::den>::value;
+      static const intmax_t __gcd2 =
+        __static_gcd<_R2::num, _R1::den>::value;
+
+    public:
+      typedef ratio<
+        __safe_multiply<(_R1::num / __gcd1),
+                        (_R2::num / __gcd2)>::value,
+        __safe_multiply<(_R1::den / __gcd2),
+                        (_R2::den / __gcd1)>::value> type;
+
+      static constexpr intmax_t num = type::num;
+      static constexpr intmax_t den = type::den;
+    };
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_multiply<_R1, _R2>::num;
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_multiply<_R1, _R2>::den;
+
+
+
+
+  template<typename _R1, typename _R2>
+    using ratio_multiply = typename __ratio_multiply<_R1, _R2>::type;
+
+
+
+  template<typename _R1, typename _R2>
+    struct __ratio_divide
+    {
+      static_assert(_R2::num != 0, "division by 0");
+
+      typedef typename __ratio_multiply<
+        _R1,
+        ratio<_R2::den, _R2::num>>::type type;
+
+      static constexpr intmax_t num = type::num;
+      static constexpr intmax_t den = type::den;
+    };
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_divide<_R1, _R2>::num;
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_divide<_R1, _R2>::den;
+
+
+
+
+  template<typename _R1, typename _R2>
+    using ratio_divide = typename __ratio_divide<_R1, _R2>::type;
+
+
+  template<typename _R1, typename _R2>
+    struct ratio_equal
+    : integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den>
+    { };
+
+
+  template<typename _R1, typename _R2>
+    struct ratio_not_equal
+    : integral_constant<bool, !ratio_equal<_R1, _R2>::value>
+    { };
+
+
+
+
+  template<typename _R1, typename _R2,
+           typename _Left = __big_mul<_R1::num,_R2::den>,
+           typename _Right = __big_mul<_R2::num,_R1::den> >
+    struct __ratio_less_impl_1
+    : integral_constant<bool, __big_less<_Left::__hi, _Left::__lo,
+           _Right::__hi, _Right::__lo>::value>
+    { };
+
+  template<typename _R1, typename _R2,
+    bool = (_R1::num == 0 || _R2::num == 0
+     || (__static_sign<_R1::num>::value
+         != __static_sign<_R2::num>::value)),
+    bool = (__static_sign<_R1::num>::value == -1
+     && __static_sign<_R2::num>::value == -1)>
+    struct __ratio_less_impl
+    : __ratio_less_impl_1<_R1, _R2>::type
+    { };
+
+  template<typename _R1, typename _R2>
+    struct __ratio_less_impl<_R1, _R2, true, false>
+    : integral_constant<bool, _R1::num < _R2::num>
+    { };
+
+  template<typename _R1, typename _R2>
+    struct __ratio_less_impl<_R1, _R2, false, true>
+    : __ratio_less_impl_1<ratio<-_R2::num, _R2::den>,
+           ratio<-_R1::num, _R1::den> >::type
+    { };
+
+
+
+
+  template<typename _R1, typename _R2>
+    struct ratio_less
+    : __ratio_less_impl<_R1, _R2>::type
+    { };
+
+
+  template<typename _R1, typename _R2>
+    struct ratio_less_equal
+    : integral_constant<bool, !ratio_less<_R2, _R1>::value>
+    { };
+
+
+  template<typename _R1, typename _R2>
+    struct ratio_greater
+    : integral_constant<bool, ratio_less<_R2, _R1>::value>
+    { };
+
+
+  template<typename _R1, typename _R2>
+    struct ratio_greater_equal
+    : integral_constant<bool, !ratio_less<_R1, _R2>::value>
+    { };
+# 438 "/usr/include/c++/10.2.0/ratio" 3
+  template<typename _R1, typename _R2,
+      bool = (_R1::num >= 0),
+      bool = (_R2::num >= 0),
+      bool = ratio_less<ratio<__static_abs<_R1::num>::value, _R1::den>,
+        ratio<__static_abs<_R2::num>::value, _R2::den> >::value>
+    struct __ratio_add_impl
+    {
+    private:
+      typedef typename __ratio_add_impl<
+        ratio<-_R1::num, _R1::den>,
+        ratio<-_R2::num, _R2::den> >::type __t;
+    public:
+      typedef ratio<-__t::num, __t::den> type;
+    };
+
+
+  template<typename _R1, typename _R2, bool __b>
+    struct __ratio_add_impl<_R1, _R2, true, true, __b>
+    {
+    private:
+      static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
+      static constexpr uintmax_t __d2 = _R2::den / __g;
+      typedef __big_mul<_R1::den, __d2> __d;
+      typedef __big_mul<_R1::num, _R2::den / __g> __x;
+      typedef __big_mul<_R2::num, _R1::den / __g> __y;
+      typedef __big_add<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
+      static_assert(__n::__hi >= __x::__hi, "Internal library error");
+      typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
+      static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
+      typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
+      static_assert(__n_final::__rem == 0, "Internal library error");
+      static_assert(__n_final::__quot_hi == 0 &&
+        __n_final::__quot_lo <= 0x7fffffffffffffffL, "overflow in addition");
+      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
+      static_assert(__d_final::__hi == 0 &&
+        __d_final::__lo <= 0x7fffffffffffffffL, "overflow in addition");
+    public:
+      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
+    };
+
+  template<typename _R1, typename _R2>
+    struct __ratio_add_impl<_R1, _R2, false, true, true>
+    : __ratio_add_impl<_R2, _R1>
+    { };
+
+
+  template<typename _R1, typename _R2>
+    struct __ratio_add_impl<_R1, _R2, true, false, false>
+    {
+    private:
+      static constexpr uintmax_t __g = __static_gcd<_R1::den, _R2::den>::value;
+      static constexpr uintmax_t __d2 = _R2::den / __g;
+      typedef __big_mul<_R1::den, __d2> __d;
+      typedef __big_mul<_R1::num, _R2::den / __g> __x;
+      typedef __big_mul<-_R2::num, _R1::den / __g> __y;
+      typedef __big_sub<__x::__hi, __x::__lo, __y::__hi, __y::__lo> __n;
+      typedef __big_div<__n::__hi, __n::__lo, __g> __ng;
+      static constexpr uintmax_t __g2 = __static_gcd<__ng::__rem, __g>::value;
+      typedef __big_div<__n::__hi, __n::__lo, __g2> __n_final;
+      static_assert(__n_final::__rem == 0, "Internal library error");
+      static_assert(__n_final::__quot_hi == 0 &&
+        __n_final::__quot_lo <= 0x7fffffffffffffffL, "overflow in addition");
+      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
+      static_assert(__d_final::__hi == 0 &&
+        __d_final::__lo <= 0x7fffffffffffffffL, "overflow in addition");
+    public:
+      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
+    };
+
+  template<typename _R1, typename _R2>
+    struct __ratio_add
+    {
+      typedef typename __ratio_add_impl<_R1, _R2>::type type;
+      static constexpr intmax_t num = type::num;
+      static constexpr intmax_t den = type::den;
+    };
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_add<_R1, _R2>::num;
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_add<_R1, _R2>::den;
+
+
+
+
+  template<typename _R1, typename _R2>
+    using ratio_add = typename __ratio_add<_R1, _R2>::type;
+
+
+
+  template<typename _R1, typename _R2>
+    struct __ratio_subtract
+    {
+      typedef typename __ratio_add<
+        _R1,
+        ratio<-_R2::num, _R2::den>>::type type;
+
+      static constexpr intmax_t num = type::num;
+      static constexpr intmax_t den = type::den;
+    };
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_subtract<_R1, _R2>::num;
+
+  template<typename _R1, typename _R2>
+    constexpr intmax_t __ratio_subtract<_R1, _R2>::den;
+
+
+
+
+  template<typename _R1, typename _R2>
+    using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type;
+
+
+  typedef ratio<1, 1000000000000000000> atto;
+  typedef ratio<1, 1000000000000000> femto;
+  typedef ratio<1, 1000000000000> pico;
+  typedef ratio<1, 1000000000> nano;
+  typedef ratio<1, 1000000> micro;
+  typedef ratio<1, 1000> milli;
+  typedef ratio<1, 100> centi;
+  typedef ratio<1, 10> deci;
+  typedef ratio< 10, 1> deca;
+  typedef ratio< 100, 1> hecto;
+  typedef ratio< 1000, 1> kilo;
+  typedef ratio< 1000000, 1> mega;
+  typedef ratio< 1000000000, 1> giga;
+  typedef ratio< 1000000000000, 1> tera;
+  typedef ratio< 1000000000000000, 1> peta;
+  typedef ratio< 1000000000000000000, 1> exa;
+
+
+
+}
+# 40 "/usr/include/c++/10.2.0/chrono" 2 3
+
+
+# 1 "/usr/include/c++/10.2.0/ctime" 1 3
+# 39 "/usr/include/c++/10.2.0/ctime" 3
+       
+# 40 "/usr/include/c++/10.2.0/ctime" 3
+# 58 "/usr/include/c++/10.2.0/ctime" 3
+namespace std
+{
+  using ::clock_t;
+  using ::time_t;
+  using ::tm;
+
+  using ::clock;
+  using ::difftime;
+  using ::mktime;
+  using ::time;
+  using ::asctime;
+  using ::ctime;
+  using ::gmtime;
+  using ::localtime;
+  using ::strftime;
+}
+# 43 "/usr/include/c++/10.2.0/chrono" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/parse_numbers.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/parse_numbers.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/parse_numbers.h" 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+namespace __parse_int
+{
+  template<unsigned _Base, char _Dig>
+    struct _Digit;
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '0'> : integral_constant<unsigned, 0>
+    {
+      using __valid = true_type;
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '1'> : integral_constant<unsigned, 1>
+    {
+      using __valid = true_type;
+    };
+
+  template<unsigned _Base, unsigned _Val>
+    struct _Digit_impl : integral_constant<unsigned, _Val>
+    {
+      static_assert(_Base > _Val, "invalid digit");
+      using __valid = true_type;
+    };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '2'> : _Digit_impl<_Base, 2>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '3'> : _Digit_impl<_Base, 3>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '4'> : _Digit_impl<_Base, 4>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '5'> : _Digit_impl<_Base, 5>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '6'> : _Digit_impl<_Base, 6>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '7'> : _Digit_impl<_Base, 7>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '8'> : _Digit_impl<_Base, 8>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '9'> : _Digit_impl<_Base, 9>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'a'> : _Digit_impl<_Base, 0xa>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'A'> : _Digit_impl<_Base, 0xa>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'b'> : _Digit_impl<_Base, 0xb>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'B'> : _Digit_impl<_Base, 0xb>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'c'> : _Digit_impl<_Base, 0xc>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'C'> : _Digit_impl<_Base, 0xc>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'd'> : _Digit_impl<_Base, 0xd>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'D'> : _Digit_impl<_Base, 0xd>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'e'> : _Digit_impl<_Base, 0xe>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'E'> : _Digit_impl<_Base, 0xe>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'f'> : _Digit_impl<_Base, 0xf>
+    { };
+
+  template<unsigned _Base>
+    struct _Digit<_Base, 'F'> : _Digit_impl<_Base, 0xf>
+    { };
+
+
+  template<unsigned _Base>
+    struct _Digit<_Base, '\''> : integral_constant<unsigned, 0>
+    {
+      using __valid = false_type;
+    };
+
+
+
+  template<unsigned long long _Val>
+    using __ull_constant = integral_constant<unsigned long long, _Val>;
+
+  template<unsigned _Base, char _Dig, char... _Digs>
+    struct _Power_help
+    {
+      using __next = typename _Power_help<_Base, _Digs...>::type;
+      using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
+      using type
+ = __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>;
+    };
+
+  template<unsigned _Base, char _Dig>
+    struct _Power_help<_Base, _Dig>
+    {
+      using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
+      using type = __ull_constant<__valid_digit::value>;
+    };
+
+  template<unsigned _Base, char... _Digs>
+    struct _Power : _Power_help<_Base, _Digs...>::type
+    { };
+
+  template<unsigned _Base>
+    struct _Power<_Base> : __ull_constant<0>
+    { };
+
+
+
+  template<unsigned _Base, unsigned long long _Pow, char _Dig, char... _Digs>
+    struct _Number_help
+    {
+      using __digit = _Digit<_Base, _Dig>;
+      using __valid_digit = typename __digit::__valid;
+      using __next = _Number_help<_Base,
+      __valid_digit::value ? _Pow / _Base : _Pow,
+      _Digs...>;
+      using type = __ull_constant<_Pow * __digit::value + __next::type::value>;
+      static_assert((type::value / _Pow) == __digit::value,
+      "integer literal does not fit in unsigned long long");
+    };
+
+
+  template<unsigned _Base, unsigned long long _Pow, char _Dig, char..._Digs>
+    struct _Number_help<_Base, _Pow, '\'', _Dig, _Digs...>
+    : _Number_help<_Base, _Pow, _Dig, _Digs...>
+    { };
+
+
+  template<unsigned _Base, char _Dig>
+    struct _Number_help<_Base, 1ULL, _Dig>
+    {
+      using type = __ull_constant<_Digit<_Base, _Dig>::value>;
+    };
+
+  template<unsigned _Base, char... _Digs>
+    struct _Number
+    : _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type
+    { };
+
+  template<unsigned _Base>
+    struct _Number<_Base>
+    : __ull_constant<0>
+    { };
+
+
+
+  template<char... _Digs>
+    struct _Parse_int;
+
+  template<char... _Digs>
+    struct _Parse_int<'0', 'b', _Digs...>
+    : _Number<2U, _Digs...>::type
+    { };
+
+  template<char... _Digs>
+    struct _Parse_int<'0', 'B', _Digs...>
+    : _Number<2U, _Digs...>::type
+    { };
+
+  template<char... _Digs>
+    struct _Parse_int<'0', 'x', _Digs...>
+    : _Number<16U, _Digs...>::type
+    { };
+
+  template<char... _Digs>
+    struct _Parse_int<'0', 'X', _Digs...>
+    : _Number<16U, _Digs...>::type
+    { };
+
+  template<char... _Digs>
+    struct _Parse_int<'0', _Digs...>
+    : _Number<8U, _Digs...>::type
+    { };
+
+  template<char... _Digs>
+    struct _Parse_int
+    : _Number<10U, _Digs...>::type
+    { };
+
+}
+
+
+namespace __select_int
+{
+  template<unsigned long long _Val, typename... _Ints>
+    struct _Select_int_base;
+
+  template<unsigned long long _Val, typename _IntType, typename... _Ints>
+    struct _Select_int_base<_Val, _IntType, _Ints...>
+    : conditional_t<(_Val <= __detail::__int_limits<_IntType>::max()),
+      integral_constant<_IntType, _Val>,
+      _Select_int_base<_Val, _Ints...>>
+    { };
+
+  template<unsigned long long _Val>
+    struct _Select_int_base<_Val>
+    { };
+
+  template<char... _Digs>
+    using _Select_int = typename _Select_int_base<
+ __parse_int::_Parse_int<_Digs...>::value,
+ unsigned char,
+ unsigned short,
+ unsigned int,
+ unsigned long,
+ unsigned long long
+      >::type;
+
+}
+
+
+}
+# 44 "/usr/include/c++/10.2.0/chrono" 2 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 68 "/usr/include/c++/10.2.0/chrono" 3
+  namespace chrono
+  {
+    template<typename _Rep, typename _Period = ratio<1>>
+      struct duration;
+
+    template<typename _Clock, typename _Dur = typename _Clock::duration>
+      struct time_point;
+  }
+
+
+
+
+
+  template<typename _CT, typename _Period1, typename _Period2, typename = void>
+    struct __duration_common_type
+    { };
+
+  template<typename _CT, typename _Period1, typename _Period2>
+    struct __duration_common_type<_CT, _Period1, _Period2,
+      __void_t<typename _CT::type>>
+    {
+    private:
+      using __gcd_num = __static_gcd<_Period1::num, _Period2::num>;
+      using __gcd_den = __static_gcd<_Period1::den, _Period2::den>;
+      using __cr = typename _CT::type;
+      using __r = ratio<__gcd_num::value,
+   (_Period1::den / __gcd_den::value) * _Period2::den>;
+
+    public:
+      using type = chrono::duration<__cr, __r>;
+    };
+
+  template<typename _Period1, typename _Period2>
+    struct __duration_common_type<__failure_type, _Period1, _Period2>
+    { typedef __failure_type type; };
+
+
+
+
+
+  template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
+    struct common_type<chrono::duration<_Rep1, _Period1>,
+         chrono::duration<_Rep2, _Period2>>
+    : __duration_common_type<common_type<_Rep1, _Rep2>, _Period1, _Period2>
+    { };
+
+
+
+
+
+  template<typename _CT, typename _Clock, typename = void>
+    struct __timepoint_common_type
+    { };
+
+  template<typename _CT, typename _Clock>
+    struct __timepoint_common_type<_CT, _Clock, __void_t<typename _CT::type>>
+    {
+      using type = chrono::time_point<_Clock, typename _CT::type>;
+    };
+
+
+
+
+
+  template<typename _Clock, typename _Duration1, typename _Duration2>
+    struct common_type<chrono::time_point<_Clock, _Duration1>,
+         chrono::time_point<_Clock, _Duration2>>
+    : __timepoint_common_type<common_type<_Duration1, _Duration2>, _Clock>
+    { };
+
+
+
+  namespace chrono
+  {
+
+
+
+
+
+
+    template<typename _ToDur, typename _CF, typename _CR,
+      bool _NumIsOne = false, bool _DenIsOne = false>
+      struct __duration_cast_impl
+      {
+ template<typename _Rep, typename _Period>
+   static constexpr _ToDur
+   __cast(const duration<_Rep, _Period>& __d)
+   {
+     typedef typename _ToDur::rep __to_rep;
+     return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
+       * static_cast<_CR>(_CF::num)
+       / static_cast<_CR>(_CF::den)));
+   }
+      };
+
+    template<typename _ToDur, typename _CF, typename _CR>
+      struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
+      {
+ template<typename _Rep, typename _Period>
+   static constexpr _ToDur
+   __cast(const duration<_Rep, _Period>& __d)
+   {
+     typedef typename _ToDur::rep __to_rep;
+     return _ToDur(static_cast<__to_rep>(__d.count()));
+   }
+      };
+
+    template<typename _ToDur, typename _CF, typename _CR>
+      struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
+      {
+ template<typename _Rep, typename _Period>
+   static constexpr _ToDur
+   __cast(const duration<_Rep, _Period>& __d)
+   {
+     typedef typename _ToDur::rep __to_rep;
+     return _ToDur(static_cast<__to_rep>(
+       static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
+   }
+      };
+
+    template<typename _ToDur, typename _CF, typename _CR>
+      struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
+      {
+ template<typename _Rep, typename _Period>
+   static constexpr _ToDur
+   __cast(const duration<_Rep, _Period>& __d)
+   {
+     typedef typename _ToDur::rep __to_rep;
+     return _ToDur(static_cast<__to_rep>(
+       static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
+   }
+      };
+
+    template<typename _Tp>
+      struct __is_duration
+      : std::false_type
+      { };
+
+    template<typename _Rep, typename _Period>
+      struct __is_duration<duration<_Rep, _Period>>
+      : std::true_type
+      { };
+
+    template<typename _Tp>
+      using __enable_if_is_duration
+ = typename enable_if<__is_duration<_Tp>::value, _Tp>::type;
+
+    template<typename _Tp>
+      using __disable_if_is_duration
+ = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type;
+
+
+
+
+    template<typename _ToDur, typename _Rep, typename _Period>
+      constexpr __enable_if_is_duration<_ToDur>
+      duration_cast(const duration<_Rep, _Period>& __d)
+      {
+ typedef typename _ToDur::period __to_period;
+ typedef typename _ToDur::rep __to_rep;
+ typedef ratio_divide<_Period, __to_period> __cf;
+ typedef typename common_type<__to_rep, _Rep, intmax_t>::type
+          __cr;
+ typedef __duration_cast_impl<_ToDur, __cf, __cr,
+          __cf::num == 1, __cf::den == 1> __dc;
+ return __dc::__cast(__d);
+      }
+
+
+    template<typename _Rep>
+      struct treat_as_floating_point
+      : is_floating_point<_Rep>
+      { };
+# 359 "/usr/include/c++/10.2.0/chrono" 3
+    template<typename _Rep>
+      struct duration_values
+      {
+ static constexpr _Rep
+ zero() noexcept
+ { return _Rep(0); }
+
+ static constexpr _Rep
+ max() noexcept
+ { return numeric_limits<_Rep>::max(); }
+
+ static constexpr _Rep
+ min() noexcept
+ { return numeric_limits<_Rep>::lowest(); }
+      };
+
+
+
+    template<typename _Tp>
+      struct __is_ratio
+      : std::false_type
+      { };
+
+    template<intmax_t _Num, intmax_t _Den>
+      struct __is_ratio<ratio<_Num, _Den>>
+      : std::true_type
+      { };
+
+
+
+
+    template<typename _Rep, typename _Period>
+      struct duration
+      {
+      private:
+ template<typename _Rep2>
+   using __is_float = treat_as_floating_point<_Rep2>;
+
+
+ template<typename _Period2>
+   using __is_harmonic
+     = __bool_constant<ratio_divide<_Period2, _Period>::den == 1>;
+
+      public:
+
+ typedef _Rep rep;
+ typedef _Period period;
+
+ static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
+ static_assert(__is_ratio<_Period>::value,
+        "period must be a specialization of ratio");
+ static_assert(_Period::num > 0, "period must be positive");
+
+
+ constexpr duration() = default;
+
+ duration(const duration&) = default;
+
+
+
+ template<typename _Rep2, typename = _Require<
+   is_convertible<const _Rep2&, rep>,
+   __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>>
+   constexpr explicit duration(const _Rep2& __rep)
+   : __r(static_cast<rep>(__rep)) { }
+
+ template<typename _Rep2, typename _Period2, typename = _Require<
+   __or_<__is_float<rep>,
+         __and_<__is_harmonic<_Period2>,
+         __not_<__is_float<_Rep2>>>>>>
+   constexpr duration(const duration<_Rep2, _Period2>& __d)
+   : __r(duration_cast<duration>(__d).count()) { }
+
+ ~duration() = default;
+ duration& operator=(const duration&) = default;
+
+
+ constexpr rep
+ count() const
+ { return __r; }
+
+
+ constexpr duration
+ operator+() const
+ { return *this; }
+
+ constexpr duration
+ operator-() const
+ { return duration(-__r); }
+
+ duration&
+ operator++()
+ {
+   ++__r;
+   return *this;
+ }
+
+ duration
+ operator++(int)
+ { return duration(__r++); }
+
+ duration&
+ operator--()
+ {
+   --__r;
+   return *this;
+ }
+
+ duration
+ operator--(int)
+ { return duration(__r--); }
+
+ duration&
+ operator+=(const duration& __d)
+ {
+   __r += __d.count();
+   return *this;
+ }
+
+ duration&
+ operator-=(const duration& __d)
+ {
+   __r -= __d.count();
+   return *this;
+ }
+
+ duration&
+ operator*=(const rep& __rhs)
+ {
+   __r *= __rhs;
+   return *this;
+ }
+
+ duration&
+ operator/=(const rep& __rhs)
+ {
+   __r /= __rhs;
+   return *this;
+ }
+
+
+ template<typename _Rep2 = rep>
+  
+   typename enable_if<!treat_as_floating_point<_Rep2>::value,
+        duration&>::type
+   operator%=(const rep& __rhs)
+   {
+     __r %= __rhs;
+     return *this;
+   }
+
+ template<typename _Rep2 = rep>
+  
+   typename enable_if<!treat_as_floating_point<_Rep2>::value,
+        duration&>::type
+   operator%=(const duration& __d)
+   {
+     __r %= __d.count();
+     return *this;
+   }
+
+
+ static constexpr duration
+ zero() noexcept
+ { return duration(duration_values<rep>::zero()); }
+
+ static constexpr duration
+ min() noexcept
+ { return duration(duration_values<rep>::min()); }
+
+ static constexpr duration
+ max() noexcept
+ { return duration(duration_values<rep>::max()); }
+
+      private:
+ rep __r;
+      };
+
+
+
+
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+         duration<_Rep2, _Period2>>::type
+      operator+(const duration<_Rep1, _Period1>& __lhs,
+  const duration<_Rep2, _Period2>& __rhs)
+      {
+ typedef duration<_Rep1, _Period1> __dur1;
+ typedef duration<_Rep2, _Period2> __dur2;
+ typedef typename common_type<__dur1,__dur2>::type __cd;
+ return __cd(__cd(__lhs).count() + __cd(__rhs).count());
+      }
+
+
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+         duration<_Rep2, _Period2>>::type
+      operator-(const duration<_Rep1, _Period1>& __lhs,
+  const duration<_Rep2, _Period2>& __rhs)
+      {
+ typedef duration<_Rep1, _Period1> __dur1;
+ typedef duration<_Rep2, _Period2> __dur2;
+ typedef typename common_type<__dur1,__dur2>::type __cd;
+ return __cd(__cd(__lhs).count() - __cd(__rhs).count());
+      }
+# 575 "/usr/include/c++/10.2.0/chrono" 3
+    template<typename _Rep1, typename _Rep2,
+      typename _CRep = typename common_type<_Rep1, _Rep2>::type>
+      using __common_rep_t = typename
+ enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type;
+
+
+
+
+
+
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period>
+      operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+      {
+ typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+   __cd;
+ return __cd(__cd(__d).count() * __s);
+      }
+
+
+    template<typename _Rep1, typename _Rep2, typename _Period>
+      constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period>
+      operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
+      { return __d * __s; }
+
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      constexpr
+      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
+      operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+      {
+ typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+   __cd;
+ return __cd(__cd(__d).count() / __s);
+      }
+
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr typename common_type<_Rep1, _Rep2>::type
+      operator/(const duration<_Rep1, _Period1>& __lhs,
+  const duration<_Rep2, _Period2>& __rhs)
+      {
+ typedef duration<_Rep1, _Period1> __dur1;
+ typedef duration<_Rep2, _Period2> __dur2;
+ typedef typename common_type<__dur1,__dur2>::type __cd;
+ return __cd(__lhs).count() / __cd(__rhs).count();
+      }
+
+
+    template<typename _Rep1, typename _Period, typename _Rep2>
+      constexpr
+      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
+      operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+      {
+ typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+   __cd;
+ return __cd(__cd(__d).count() % __s);
+      }
+
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr typename common_type<duration<_Rep1, _Period1>,
+         duration<_Rep2, _Period2>>::type
+      operator%(const duration<_Rep1, _Period1>& __lhs,
+  const duration<_Rep2, _Period2>& __rhs)
+      {
+ typedef duration<_Rep1, _Period1> __dur1;
+ typedef duration<_Rep2, _Period2> __dur2;
+ typedef typename common_type<__dur1,__dur2>::type __cd;
+ return __cd(__cd(__lhs).count() % __cd(__rhs).count());
+      }
+
+
+
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr bool
+      operator==(const duration<_Rep1, _Period1>& __lhs,
+   const duration<_Rep2, _Period2>& __rhs)
+      {
+ typedef duration<_Rep1, _Period1> __dur1;
+ typedef duration<_Rep2, _Period2> __dur2;
+ typedef typename common_type<__dur1,__dur2>::type __ct;
+ return __ct(__lhs).count() == __ct(__rhs).count();
+      }
+
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr bool
+      operator<(const duration<_Rep1, _Period1>& __lhs,
+  const duration<_Rep2, _Period2>& __rhs)
+      {
+ typedef duration<_Rep1, _Period1> __dur1;
+ typedef duration<_Rep2, _Period2> __dur2;
+ typedef typename common_type<__dur1,__dur2>::type __ct;
+ return __ct(__lhs).count() < __ct(__rhs).count();
+      }
+# 685 "/usr/include/c++/10.2.0/chrono" 3
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr bool
+      operator!=(const duration<_Rep1, _Period1>& __lhs,
+   const duration<_Rep2, _Period2>& __rhs)
+      { return !(__lhs == __rhs); }
+
+
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr bool
+      operator<=(const duration<_Rep1, _Period1>& __lhs,
+   const duration<_Rep2, _Period2>& __rhs)
+      { return !(__rhs < __lhs); }
+
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr bool
+      operator>(const duration<_Rep1, _Period1>& __lhs,
+  const duration<_Rep2, _Period2>& __rhs)
+      { return __rhs < __lhs; }
+
+    template<typename _Rep1, typename _Period1,
+      typename _Rep2, typename _Period2>
+      constexpr bool
+      operator>=(const duration<_Rep1, _Period1>& __lhs,
+   const duration<_Rep2, _Period2>& __rhs)
+      { return !(__lhs < __rhs); }
+# 727 "/usr/include/c++/10.2.0/chrono" 3
+    using nanoseconds = duration<int64_t, nano>;
+
+
+    using microseconds = duration<int64_t, micro>;
+
+
+    using milliseconds = duration<int64_t, milli>;
+
+
+    using seconds = duration<int64_t>;
+
+
+    using minutes = duration<int64_t, ratio< 60>>;
+
+
+    using hours = duration<int64_t, ratio<3600>>;
+# 761 "/usr/include/c++/10.2.0/chrono" 3
+    template<typename _Clock, typename _Dur>
+      struct time_point
+      {
+ static_assert(__is_duration<_Dur>::value,
+     "duration must be a specialization of std::chrono::duration");
+
+ typedef _Clock clock;
+ typedef _Dur duration;
+ typedef typename duration::rep rep;
+ typedef typename duration::period period;
+
+ constexpr time_point() : __d(duration::zero())
+ { }
+
+ constexpr explicit time_point(const duration& __dur)
+ : __d(__dur)
+ { }
+
+
+ template<typename _Dur2,
+   typename = _Require<is_convertible<_Dur2, _Dur>>>
+   constexpr time_point(const time_point<clock, _Dur2>& __t)
+   : __d(__t.time_since_epoch())
+   { }
+
+
+ constexpr duration
+ time_since_epoch() const
+ { return __d; }
+
+
+ time_point&
+ operator+=(const duration& __dur)
+ {
+   __d += __dur;
+   return *this;
+ }
+
+ time_point&
+ operator-=(const duration& __dur)
+ {
+   __d -= __dur;
+   return *this;
+ }
+
+
+ static constexpr time_point
+ min() noexcept
+ { return time_point(duration::min()); }
+
+ static constexpr time_point
+ max() noexcept
+ { return time_point(duration::max()); }
+
+      private:
+ duration __d;
+      };
+
+
+    template<typename _ToDur, typename _Clock, typename _Dur>
+      constexpr typename enable_if<__is_duration<_ToDur>::value,
+       time_point<_Clock, _ToDur>>::type
+      time_point_cast(const time_point<_Clock, _Dur>& __t)
+      {
+ typedef time_point<_Clock, _ToDur> __time_point;
+ return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
+      }
+# 863 "/usr/include/c++/10.2.0/chrono" 3
+    template<typename _Clock, typename _Dur1,
+      typename _Rep2, typename _Period2>
+      constexpr time_point<_Clock,
+ typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
+      operator+(const time_point<_Clock, _Dur1>& __lhs,
+  const duration<_Rep2, _Period2>& __rhs)
+      {
+ typedef duration<_Rep2, _Period2> __dur2;
+ typedef typename common_type<_Dur1,__dur2>::type __ct;
+ typedef time_point<_Clock, __ct> __time_point;
+ return __time_point(__lhs.time_since_epoch() + __rhs);
+      }
+
+
+    template<typename _Rep1, typename _Period1,
+      typename _Clock, typename _Dur2>
+      constexpr time_point<_Clock,
+ typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
+      operator+(const duration<_Rep1, _Period1>& __lhs,
+  const time_point<_Clock, _Dur2>& __rhs)
+      {
+ typedef duration<_Rep1, _Period1> __dur1;
+ typedef typename common_type<__dur1,_Dur2>::type __ct;
+ typedef time_point<_Clock, __ct> __time_point;
+ return __time_point(__rhs.time_since_epoch() + __lhs);
+      }
+
+
+    template<typename _Clock, typename _Dur1,
+      typename _Rep2, typename _Period2>
+      constexpr time_point<_Clock,
+ typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
+      operator-(const time_point<_Clock, _Dur1>& __lhs,
+  const duration<_Rep2, _Period2>& __rhs)
+      {
+ typedef duration<_Rep2, _Period2> __dur2;
+ typedef typename common_type<_Dur1,__dur2>::type __ct;
+ typedef time_point<_Clock, __ct> __time_point;
+ return __time_point(__lhs.time_since_epoch() -__rhs);
+      }
+
+
+
+
+
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr typename common_type<_Dur1, _Dur2>::type
+      operator-(const time_point<_Clock, _Dur1>& __lhs,
+  const time_point<_Clock, _Dur2>& __rhs)
+      { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator==(const time_point<_Clock, _Dur1>& __lhs,
+   const time_point<_Clock, _Dur2>& __rhs)
+      { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
+# 929 "/usr/include/c++/10.2.0/chrono" 3
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator!=(const time_point<_Clock, _Dur1>& __lhs,
+   const time_point<_Clock, _Dur2>& __rhs)
+      { return !(__lhs == __rhs); }
+
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator<(const time_point<_Clock, _Dur1>& __lhs,
+  const time_point<_Clock, _Dur2>& __rhs)
+      { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator<=(const time_point<_Clock, _Dur1>& __lhs,
+   const time_point<_Clock, _Dur2>& __rhs)
+      { return !(__rhs < __lhs); }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator>(const time_point<_Clock, _Dur1>& __lhs,
+  const time_point<_Clock, _Dur2>& __rhs)
+      { return __rhs < __lhs; }
+
+    template<typename _Clock, typename _Dur1, typename _Dur2>
+      constexpr bool
+      operator>=(const time_point<_Clock, _Dur1>& __lhs,
+   const time_point<_Clock, _Dur2>& __rhs)
+      { return !(__lhs < __rhs); }
+# 980 "/usr/include/c++/10.2.0/chrono" 3
+    inline namespace _V2 {
+
+
+
+
+
+
+
+    struct system_clock
+    {
+      typedef chrono::nanoseconds duration;
+      typedef duration::rep rep;
+      typedef duration::period period;
+      typedef chrono::time_point<system_clock, duration> time_point;
+
+      static_assert(system_clock::duration::min()
+      < system_clock::duration::zero(),
+      "a clock's minimum duration cannot be less than its epoch");
+
+      static constexpr bool is_steady = false;
+
+      static time_point
+      now() noexcept;
+
+
+      static std::time_t
+      to_time_t(const time_point& __t) noexcept
+      {
+ return std::time_t(duration_cast<chrono::seconds>
+      (__t.time_since_epoch()).count());
+      }
+
+      static time_point
+      from_time_t(std::time_t __t) noexcept
+      {
+ typedef chrono::time_point<system_clock, seconds> __from;
+ return time_point_cast<system_clock::duration>
+        (__from(chrono::seconds(__t)));
+      }
+    };
+# 1028 "/usr/include/c++/10.2.0/chrono" 3
+    struct steady_clock
+    {
+      typedef chrono::nanoseconds duration;
+      typedef duration::rep rep;
+      typedef duration::period period;
+      typedef chrono::time_point<steady_clock, duration> time_point;
+
+      static constexpr bool is_steady = true;
+
+      static time_point
+      now() noexcept;
+    };
+# 1050 "/usr/include/c++/10.2.0/chrono" 3
+    using high_resolution_clock = system_clock;
+
+    }
+# 1081 "/usr/include/c++/10.2.0/chrono" 3
+  }
+
+
+
+
+
+  inline namespace literals
+  {
+# 1112 "/usr/include/c++/10.2.0/chrono" 3
+  inline namespace chrono_literals
+  {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+
+    template<typename _Dur, char... _Digits>
+      constexpr _Dur __check_overflow()
+      {
+ using _Val = __parse_int::_Parse_int<_Digits...>;
+ constexpr typename _Dur::rep __repval = _Val::value;
+ static_assert(__repval >= 0 && __repval == _Val::value,
+        "literal value cannot be represented by duration type");
+ return _Dur(__repval);
+      }
+
+
+
+    constexpr chrono::duration<long double, ratio<3600,1>>
+    operator""h(long double __hours)
+    { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
+
+
+    template <char... _Digits>
+      constexpr chrono::hours
+      operator""h()
+      { return __check_overflow<chrono::hours, _Digits...>(); }
+
+
+    constexpr chrono::duration<long double, ratio<60,1>>
+    operator""min(long double __mins)
+    { return chrono::duration<long double, ratio<60,1>>{__mins}; }
+
+
+    template <char... _Digits>
+      constexpr chrono::minutes
+      operator""min()
+      { return __check_overflow<chrono::minutes, _Digits...>(); }
+
+
+    constexpr chrono::duration<long double>
+    operator""s(long double __secs)
+    { return chrono::duration<long double>{__secs}; }
+
+
+    template <char... _Digits>
+      constexpr chrono::seconds
+      operator""s()
+      { return __check_overflow<chrono::seconds, _Digits...>(); }
+
+
+    constexpr chrono::duration<long double, milli>
+    operator""ms(long double __msecs)
+    { return chrono::duration<long double, milli>{__msecs}; }
+
+
+    template <char... _Digits>
+      constexpr chrono::milliseconds
+      operator""ms()
+      { return __check_overflow<chrono::milliseconds, _Digits...>(); }
+
+
+    constexpr chrono::duration<long double, micro>
+    operator""us(long double __usecs)
+    { return chrono::duration<long double, micro>{__usecs}; }
+
+
+    template <char... _Digits>
+      constexpr chrono::microseconds
+      operator""us()
+      { return __check_overflow<chrono::microseconds, _Digits...>(); }
+
+
+    constexpr chrono::duration<long double, nano>
+    operator""ns(long double __nsecs)
+    { return chrono::duration<long double, nano>{__nsecs}; }
+
+
+    template <char... _Digits>
+      constexpr chrono::nanoseconds
+      operator""ns()
+      { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
+
+#pragma GCC diagnostic pop
+  }
+  }
+
+  namespace chrono
+  {
+    using namespace literals::chrono_literals;
+  }
+# 1266 "/usr/include/c++/10.2.0/chrono" 3
+
+}
+# 16 "/home/ted/dev/openrct2/src/openrct2/GameState.h" 2
+
+# 1 "/usr/include/c++/10.2.0/unordered_map" 1 3
+# 32 "/usr/include/c++/10.2.0/unordered_map" 3
+       
+# 33 "/usr/include/c++/10.2.0/unordered_map" 3
+# 46 "/usr/include/c++/10.2.0/unordered_map" 3
+# 1 "/usr/include/c++/10.2.0/bits/hashtable.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/hashtable.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/hashtable.h" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 1 3
+# 38 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    class _Hashtable;
+
+namespace __detail
+{
+
+
+
+
+
+  template<typename _Key, typename _Value,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _Traits>
+    struct _Hashtable_base;
+
+
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+    std::input_iterator_tag)
+    { return __first != __last ? 1 : 0; }
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last,
+    std::forward_iterator_tag)
+    { return std::distance(__first, __last); }
+
+  template<class _Iterator>
+    inline typename std::iterator_traits<_Iterator>::difference_type
+    __distance_fw(_Iterator __first, _Iterator __last)
+    { return __distance_fw(__first, __last,
+      std::__iterator_category(__first)); }
+
+  struct _Identity
+  {
+    template<typename _Tp>
+      _Tp&&
+      operator()(_Tp&& __x) const
+      { return std::forward<_Tp>(__x); }
+  };
+
+  struct _Select1st
+  {
+    template<typename _Tp>
+      auto
+      operator()(_Tp&& __x) const
+      -> decltype(std::get<0>(std::forward<_Tp>(__x)))
+      { return std::get<0>(std::forward<_Tp>(__x)); }
+  };
+
+  template<typename _NodeAlloc>
+    struct _Hashtable_alloc;
+
+
+
+  template<typename _NodeAlloc>
+    struct _ReuseOrAllocNode
+    {
+    private:
+      using __node_alloc_type = _NodeAlloc;
+      using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>;
+      using __node_alloc_traits =
+ typename __hashtable_alloc::__node_alloc_traits;
+      using __node_type = typename __hashtable_alloc::__node_type;
+
+    public:
+      _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h)
+      : _M_nodes(__nodes), _M_h(__h) { }
+      _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete;
+
+      ~_ReuseOrAllocNode()
+      { _M_h._M_deallocate_nodes(_M_nodes); }
+
+      template<typename _Arg>
+ __node_type*
+ operator()(_Arg&& __arg) const
+ {
+   if (_M_nodes)
+     {
+       __node_type* __node = _M_nodes;
+       _M_nodes = _M_nodes->_M_next();
+       __node->_M_nxt = nullptr;
+       auto& __a = _M_h._M_node_allocator();
+       __node_alloc_traits::destroy(__a, __node->_M_valptr());
+       try
+  {
+    __node_alloc_traits::construct(__a, __node->_M_valptr(),
+       std::forward<_Arg>(__arg));
+  }
+       catch(...)
+  {
+    _M_h._M_deallocate_node_ptr(__node);
+    throw;
+  }
+       return __node;
+     }
+   return _M_h._M_allocate_node(std::forward<_Arg>(__arg));
+ }
+
+    private:
+      mutable __node_type* _M_nodes;
+      __hashtable_alloc& _M_h;
+    };
+
+
+
+  template<typename _NodeAlloc>
+    struct _AllocNode
+    {
+    private:
+      using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>;
+      using __node_type = typename __hashtable_alloc::__node_type;
+
+    public:
+      _AllocNode(__hashtable_alloc& __h)
+      : _M_h(__h) { }
+
+      template<typename _Arg>
+ __node_type*
+ operator()(_Arg&& __arg) const
+ { return _M_h._M_allocate_node(std::forward<_Arg>(__arg)); }
+
+    private:
+      __hashtable_alloc& _M_h;
+    };
+# 198 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<bool _Cache_hash_code, bool _Constant_iterators, bool _Unique_keys>
+    struct _Hashtable_traits
+    {
+      using __hash_cached = __bool_constant<_Cache_hash_code>;
+      using __constant_iterators = __bool_constant<_Constant_iterators>;
+      using __unique_keys = __bool_constant<_Unique_keys>;
+    };
+# 214 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  struct _Hash_node_base
+  {
+    _Hash_node_base* _M_nxt;
+
+    _Hash_node_base() noexcept : _M_nxt() { }
+
+    _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { }
+  };
+
+
+
+
+
+
+  template<typename _Value>
+    struct _Hash_node_value_base : _Hash_node_base
+    {
+      typedef _Value value_type;
+
+      __gnu_cxx::__aligned_buffer<_Value> _M_storage;
+
+      _Value*
+      _M_valptr() noexcept
+      { return _M_storage._M_ptr(); }
+
+      const _Value*
+      _M_valptr() const noexcept
+      { return _M_storage._M_ptr(); }
+
+      _Value&
+      _M_v() noexcept
+      { return *_M_valptr(); }
+
+      const _Value&
+      _M_v() const noexcept
+      { return *_M_valptr(); }
+    };
+
+
+
+
+  template<typename _Value, bool _Cache_hash_code>
+    struct _Hash_node;
+
+
+
+
+
+
+  template<typename _Value>
+    struct _Hash_node<_Value, true> : _Hash_node_value_base<_Value>
+    {
+      std::size_t _M_hash_code;
+
+      _Hash_node*
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
+    };
+
+
+
+
+
+
+  template<typename _Value>
+    struct _Hash_node<_Value, false> : _Hash_node_value_base<_Value>
+    {
+      _Hash_node*
+      _M_next() const noexcept
+      { return static_cast<_Hash_node*>(this->_M_nxt); }
+    };
+
+
+  template<typename _Value, bool _Cache_hash_code>
+    struct _Node_iterator_base
+    {
+      using __node_type = _Hash_node<_Value, _Cache_hash_code>;
+
+      __node_type* _M_cur;
+
+      _Node_iterator_base(__node_type* __p) noexcept
+      : _M_cur(__p) { }
+
+      void
+      _M_incr() noexcept
+      { _M_cur = _M_cur->_M_next(); }
+    };
+
+  template<typename _Value, bool _Cache_hash_code>
+    inline bool
+    operator==(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
+        const _Node_iterator_base<_Value, _Cache_hash_code >& __y)
+    noexcept
+    { return __x._M_cur == __y._M_cur; }
+
+  template<typename _Value, bool _Cache_hash_code>
+    inline bool
+    operator!=(const _Node_iterator_base<_Value, _Cache_hash_code>& __x,
+        const _Node_iterator_base<_Value, _Cache_hash_code>& __y)
+    noexcept
+    { return __x._M_cur != __y._M_cur; }
+
+
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+    private:
+      using __base_type = _Node_iterator_base<_Value, __cache>;
+      using __node_type = typename __base_type::__node_type;
+
+    public:
+      typedef _Value value_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      using pointer = typename std::conditional<__constant_iterators,
+      const _Value*, _Value*>::type;
+
+      using reference = typename std::conditional<__constant_iterators,
+        const _Value&, _Value&>::type;
+
+      _Node_iterator() noexcept
+      : __base_type(0) { }
+
+      explicit
+      _Node_iterator(__node_type* __p) noexcept
+      : __base_type(__p) { }
+
+      reference
+      operator*() const noexcept
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const noexcept
+      { return this->_M_cur->_M_valptr(); }
+
+      _Node_iterator&
+      operator++() noexcept
+      {
+ this->_M_incr();
+ return *this;
+      }
+
+      _Node_iterator
+      operator++(int) noexcept
+      {
+ _Node_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+
+
+  template<typename _Value, bool __constant_iterators, bool __cache>
+    struct _Node_const_iterator
+    : public _Node_iterator_base<_Value, __cache>
+    {
+    private:
+      using __base_type = _Node_iterator_base<_Value, __cache>;
+      using __node_type = typename __base_type::__node_type;
+
+    public:
+      typedef _Value value_type;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      typedef const _Value* pointer;
+      typedef const _Value& reference;
+
+      _Node_const_iterator() noexcept
+      : __base_type(0) { }
+
+      explicit
+      _Node_const_iterator(__node_type* __p) noexcept
+      : __base_type(__p) { }
+
+      _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators,
+      __cache>& __x) noexcept
+      : __base_type(__x._M_cur) { }
+
+      reference
+      operator*() const noexcept
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const noexcept
+      { return this->_M_cur->_M_valptr(); }
+
+      _Node_const_iterator&
+      operator++() noexcept
+      {
+ this->_M_incr();
+ return *this;
+      }
+
+      _Node_const_iterator
+      operator++(int) noexcept
+      {
+ _Node_const_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+
+
+
+
+
+
+  struct _Mod_range_hashing
+  {
+    typedef std::size_t first_argument_type;
+    typedef std::size_t second_argument_type;
+    typedef std::size_t result_type;
+
+    result_type
+    operator()(first_argument_type __num,
+        second_argument_type __den) const noexcept
+    { return __num % __den; }
+  };
+
+
+
+
+
+
+  struct _Default_ranged_hash { };
+
+
+
+  struct _Prime_rehash_policy
+  {
+    using __has_load_factor = true_type;
+
+    _Prime_rehash_policy(float __z = 1.0) noexcept
+    : _M_max_load_factor(__z), _M_next_resize(0) { }
+
+    float
+    max_load_factor() const noexcept
+    { return _M_max_load_factor; }
+
+
+    std::size_t
+    _M_next_bkt(std::size_t __n) const;
+
+
+    std::size_t
+    _M_bkt_for_elements(std::size_t __n) const
+    { return __builtin_ceill(__n / (long double)_M_max_load_factor); }
+
+
+
+
+
+    std::pair<bool, std::size_t>
+    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
+     std::size_t __n_ins) const;
+
+    typedef std::size_t _State;
+
+    _State
+    _M_state() const
+    { return _M_next_resize; }
+
+    void
+    _M_reset() noexcept
+    { _M_next_resize = 0; }
+
+    void
+    _M_reset(_State __state)
+    { _M_next_resize = __state; }
+
+    static const std::size_t _S_growth_factor = 2;
+
+    float _M_max_load_factor;
+    mutable std::size_t _M_next_resize;
+  };
+
+
+  struct _Mask_range_hashing
+  {
+    typedef std::size_t first_argument_type;
+    typedef std::size_t second_argument_type;
+    typedef std::size_t result_type;
+
+    result_type
+    operator()(first_argument_type __num,
+        second_argument_type __den) const noexcept
+    { return __num & (__den - 1); }
+  };
+
+
+  inline std::size_t
+  __clp2(std::size_t __n) noexcept
+  {
+
+    if (__n < 2)
+      return __n;
+    const unsigned __lz = sizeof(size_t) > sizeof(long)
+      ? __builtin_clzll(__n - 1ull)
+      : __builtin_clzl(__n - 1ul);
+
+    return (size_t(1) << (numeric_limits<size_t>::digits - __lz - 1)) << 1;
+  }
+
+
+
+  struct _Power2_rehash_policy
+  {
+    using __has_load_factor = true_type;
+
+    _Power2_rehash_policy(float __z = 1.0) noexcept
+    : _M_max_load_factor(__z), _M_next_resize(0) { }
+
+    float
+    max_load_factor() const noexcept
+    { return _M_max_load_factor; }
+
+
+
+    std::size_t
+    _M_next_bkt(std::size_t __n) noexcept
+    {
+      if (__n == 0)
+
+
+
+ return 1;
+
+      const auto __max_width = std::min<size_t>(sizeof(size_t), 8);
+      const auto __max_bkt = size_t(1) << (__max_width * 8 - 1);
+      std::size_t __res = __clp2(__n);
+
+      if (__res == 0)
+ __res = __max_bkt;
+      else if (__res == 1)
+
+
+
+ __res = 2;
+
+      if (__res == __max_bkt)
+
+
+
+ _M_next_resize = numeric_limits<size_t>::max();
+      else
+ _M_next_resize
+   = __builtin_floorl(__res * (long double)_M_max_load_factor);
+
+      return __res;
+    }
+
+
+    std::size_t
+    _M_bkt_for_elements(std::size_t __n) const noexcept
+    { return __builtin_ceill(__n / (long double)_M_max_load_factor); }
+
+
+
+
+
+    std::pair<bool, std::size_t>
+    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
+     std::size_t __n_ins) noexcept
+    {
+      if (__n_elt + __n_ins > _M_next_resize)
+ {
+
+
+
+   long double __min_bkts
+     = std::max<std::size_t>(__n_elt + __n_ins, _M_next_resize ? 0 : 11)
+       / (long double)_M_max_load_factor;
+   if (__min_bkts >= __n_bkt)
+     return { true,
+       _M_next_bkt(std::max<std::size_t>(__builtin_floorl(__min_bkts) + 1,
+      __n_bkt * _S_growth_factor)) };
+
+   _M_next_resize
+     = __builtin_floorl(__n_bkt * (long double)_M_max_load_factor);
+   return { false, 0 };
+ }
+      else
+ return { false, 0 };
+    }
+
+    typedef std::size_t _State;
+
+    _State
+    _M_state() const noexcept
+    { return _M_next_resize; }
+
+    void
+    _M_reset() noexcept
+    { _M_next_resize = 0; }
+
+    void
+    _M_reset(_State __state) noexcept
+    { _M_next_resize = __state; }
+
+    static const std::size_t _S_growth_factor = 2;
+
+    float _M_max_load_factor;
+    std::size_t _M_next_resize;
+  };
+# 640 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    bool _Unique_keys = _Traits::__unique_keys::value>
+    struct _Map_base { };
+
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
+    {
+      using mapped_type = typename std::tuple_element<1, _Pair>::type;
+    };
+
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+    {
+    private:
+      using __hashtable_base = __detail::_Hashtable_base<_Key, _Pair,
+        _Select1st,
+       _Equal, _H1, _H2, _Hash,
+         _Traits>;
+
+      using __hashtable = _Hashtable<_Key, _Pair, _Alloc,
+         _Select1st, _Equal,
+         _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+
+      using __hash_code = typename __hashtable_base::__hash_code;
+      using __node_type = typename __hashtable_base::__node_type;
+
+    public:
+      using key_type = typename __hashtable_base::key_type;
+      using iterator = typename __hashtable_base::iterator;
+      using mapped_type = typename std::tuple_element<1, _Pair>::type;
+
+      mapped_type&
+      operator[](const key_type& __k);
+
+      mapped_type&
+      operator[](key_type&& __k);
+
+
+
+      mapped_type&
+      at(const key_type& __k);
+
+      const mapped_type&
+      at(const key_type& __k) const;
+    };
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    operator[](const key_type& __k)
+    -> mapped_type&
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
+      if (__node_type* __node = __h->_M_find_node(__bkt, __k, __code))
+ return __node->_M_v().second;
+
+      typename __hashtable::_Scoped_node __node {
+ __h,
+ std::piecewise_construct,
+ std::tuple<const key_type&>(__k),
+ std::tuple<>()
+      };
+      auto __pos
+ = __h->_M_insert_unique_node(__k, __bkt, __code, __node._M_node);
+      __node._M_node = nullptr;
+      return __pos->second;
+    }
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    operator[](key_type&& __k)
+    -> mapped_type&
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
+      if (__node_type* __node = __h->_M_find_node(__bkt, __k, __code))
+ return __node->_M_v().second;
+
+      typename __hashtable::_Scoped_node __node {
+ __h,
+ std::piecewise_construct,
+ std::forward_as_tuple(std::move(__k)),
+ std::tuple<>()
+      };
+      auto __pos
+ = __h->_M_insert_unique_node(__k, __bkt, __code, __node._M_node);
+      __node._M_node = nullptr;
+      return __pos->second;
+    }
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    at(const key_type& __k)
+    -> mapped_type&
+    {
+      __hashtable* __h = static_cast<__hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__bkt, __k, __code);
+
+      if (!__p)
+ __throw_out_of_range(("_Map_base::at"));
+      return __p->_M_v().second;
+    }
+
+  template<typename _Key, typename _Pair, typename _Alloc, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    auto
+    _Map_base<_Key, _Pair, _Alloc, _Select1st, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    at(const key_type& __k) const
+    -> const mapped_type&
+    {
+      const __hashtable* __h = static_cast<const __hashtable*>(this);
+      __hash_code __code = __h->_M_hash_code(__k);
+      std::size_t __bkt = __h->_M_bucket_index(__k, __code);
+      __node_type* __p = __h->_M_find_node(__bkt, __k, __code);
+
+      if (!__p)
+ __throw_out_of_range(("_Map_base::at"));
+      return __p->_M_v().second;
+    }
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Insert_base
+    {
+    protected:
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+         _Equal, _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+
+      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
+            _Equal, _H1, _H2, _Hash,
+            _Traits>;
+
+      using value_type = typename __hashtable_base::value_type;
+      using iterator = typename __hashtable_base::iterator;
+      using const_iterator = typename __hashtable_base::const_iterator;
+      using size_type = typename __hashtable_base::size_type;
+
+      using __unique_keys = typename __hashtable_base::__unique_keys;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+      using __node_type = _Hash_node<_Value, _Traits::__hash_cached::value>;
+      using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
+      using __node_gen_type = _AllocNode<__node_alloc_type>;
+
+      __hashtable&
+      _M_conjure_hashtable()
+      { return *(static_cast<__hashtable*>(this)); }
+
+      template<typename _InputIterator, typename _NodeGetter>
+ void
+ _M_insert_range(_InputIterator __first, _InputIterator __last,
+   const _NodeGetter&, true_type);
+
+      template<typename _InputIterator, typename _NodeGetter>
+ void
+ _M_insert_range(_InputIterator __first, _InputIterator __last,
+   const _NodeGetter&, false_type);
+
+    public:
+      __ireturn_type
+      insert(const value_type& __v)
+      {
+ __hashtable& __h = _M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(__v, __node_gen, __unique_keys());
+      }
+
+      iterator
+      insert(const_iterator __hint, const value_type& __v)
+      {
+ __hashtable& __h = _M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(__hint, __v, __node_gen, __unique_keys());
+      }
+
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ {
+   __hashtable& __h = _M_conjure_hashtable();
+   __node_gen_type __node_gen(__h);
+   return _M_insert_range(__first, __last, __node_gen, __unique_keys());
+ }
+    };
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    template<typename _InputIterator, typename _NodeGetter>
+      void
+      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+      _RehashPolicy, _Traits>::
+      _M_insert_range(_InputIterator __first, _InputIterator __last,
+        const _NodeGetter& __node_gen, true_type)
+      {
+ size_type __n_elt = __detail::__distance_fw(__first, __last);
+ if (__n_elt == 0)
+   return;
+
+ __hashtable& __h = _M_conjure_hashtable();
+ for (; __first != __last; ++__first)
+   {
+     if (__h._M_insert(*__first, __node_gen, __unique_keys(),
+         __n_elt).second)
+       __n_elt = 1;
+     else if (__n_elt != 1)
+       --__n_elt;
+   }
+      }
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    template<typename _InputIterator, typename _NodeGetter>
+      void
+      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+      _RehashPolicy, _Traits>::
+      _M_insert_range(_InputIterator __first, _InputIterator __last,
+        const _NodeGetter& __node_gen, false_type)
+      {
+ using __rehash_type = typename __hashtable::__rehash_type;
+ using __rehash_state = typename __hashtable::__rehash_state;
+ using pair_type = std::pair<bool, std::size_t>;
+
+ size_type __n_elt = __detail::__distance_fw(__first, __last);
+ if (__n_elt == 0)
+   return;
+
+ __hashtable& __h = _M_conjure_hashtable();
+ __rehash_type& __rehash = __h._M_rehash_policy;
+ const __rehash_state& __saved_state = __rehash._M_state();
+ pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count,
+       __h._M_element_count,
+       __n_elt);
+
+ if (__do_rehash.first)
+   __h._M_rehash(__do_rehash.second, __saved_state);
+
+ for (; __first != __last; ++__first)
+   __h._M_insert(*__first, __node_gen, __unique_keys());
+      }
+
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    bool _Constant_iterators = _Traits::__constant_iterators::value>
+    struct _Insert;
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+     _RehashPolicy, _Traits, true>
+    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+      _H1, _H2, _Hash, _RehashPolicy, _Traits>
+    {
+      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
+     _Equal, _H1, _H2, _Hash,
+     _RehashPolicy, _Traits>;
+
+      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
+            _Equal, _H1, _H2, _Hash,
+            _Traits>;
+
+      using value_type = typename __base_type::value_type;
+      using iterator = typename __base_type::iterator;
+      using const_iterator = typename __base_type::const_iterator;
+
+      using __unique_keys = typename __base_type::__unique_keys;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+      using __hashtable = typename __base_type::__hashtable;
+      using __node_gen_type = typename __base_type::__node_gen_type;
+
+      using __base_type::insert;
+
+      __ireturn_type
+      insert(value_type&& __v)
+      {
+ __hashtable& __h = this->_M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(std::move(__v), __node_gen, __unique_keys());
+      }
+
+      iterator
+      insert(const_iterator __hint, value_type&& __v)
+      {
+ __hashtable& __h = this->_M_conjure_hashtable();
+ __node_gen_type __node_gen(__h);
+ return __h._M_insert(__hint, std::move(__v), __node_gen,
+        __unique_keys());
+      }
+    };
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, _H1, _H2, _Hash,
+     _RehashPolicy, _Traits, false>
+    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+      _H1, _H2, _Hash, _RehashPolicy, _Traits>
+    {
+      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
+           _Equal, _H1, _H2, _Hash,
+           _RehashPolicy, _Traits>;
+      using value_type = typename __base_type::value_type;
+      using iterator = typename __base_type::iterator;
+      using const_iterator = typename __base_type::const_iterator;
+
+      using __unique_keys = typename __base_type::__unique_keys;
+      using __hashtable = typename __base_type::__hashtable;
+      using __ireturn_type = typename __base_type::__ireturn_type;
+
+      using __base_type::insert;
+
+      template<typename _Pair>
+ using __is_cons = std::is_constructible<value_type, _Pair&&>;
+
+      template<typename _Pair>
+ using _IFcons = std::enable_if<__is_cons<_Pair>::value>;
+
+      template<typename _Pair>
+ using _IFconsp = typename _IFcons<_Pair>::type;
+
+      template<typename _Pair, typename = _IFconsp<_Pair>>
+ __ireturn_type
+ insert(_Pair&& __v)
+ {
+   __hashtable& __h = this->_M_conjure_hashtable();
+   return __h._M_emplace(__unique_keys(), std::forward<_Pair>(__v));
+ }
+
+      template<typename _Pair, typename = _IFconsp<_Pair>>
+ iterator
+ insert(const_iterator __hint, _Pair&& __v)
+ {
+   __hashtable& __h = this->_M_conjure_hashtable();
+   return __h._M_emplace(__hint, __unique_keys(),
+    std::forward<_Pair>(__v));
+ }
+   };
+
+  template<typename _Policy>
+    using __has_load_factor = typename _Policy::__has_load_factor;
+
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    typename =
+      __detected_or_t<false_type, __has_load_factor, _RehashPolicy>>
+    struct _Rehash_base;
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits,
+        false_type>
+    {
+    };
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits,
+   true_type>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
+         _Equal, _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+
+      float
+      max_load_factor() const noexcept
+      {
+ const __hashtable* __this = static_cast<const __hashtable*>(this);
+ return __this->__rehash_policy().max_load_factor();
+      }
+
+      void
+      max_load_factor(float __z)
+      {
+ __hashtable* __this = static_cast<__hashtable*>(this);
+ __this->__rehash_policy(_RehashPolicy(__z));
+      }
+
+      void
+      reserve(std::size_t __n)
+      {
+ __hashtable* __this = static_cast<__hashtable*>(this);
+ __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n));
+      }
+    };
+
+
+
+
+
+
+
+  template<int _Nm, typename _Tp,
+    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
+    struct _Hashtable_ebo_helper;
+
+
+  template<int _Nm, typename _Tp>
+    struct _Hashtable_ebo_helper<_Nm, _Tp, true>
+    : private _Tp
+    {
+      _Hashtable_ebo_helper() = default;
+
+      template<typename _OtherTp>
+ _Hashtable_ebo_helper(_OtherTp&& __tp)
+ : _Tp(std::forward<_OtherTp>(__tp))
+ { }
+
+      const _Tp& _M_cget() const { return static_cast<const _Tp&>(*this); }
+      _Tp& _M_get() { return static_cast<_Tp&>(*this); }
+    };
+
+
+  template<int _Nm, typename _Tp>
+    struct _Hashtable_ebo_helper<_Nm, _Tp, false>
+    {
+      _Hashtable_ebo_helper() = default;
+
+      template<typename _OtherTp>
+ _Hashtable_ebo_helper(_OtherTp&& __tp)
+ : _M_tp(std::forward<_OtherTp>(__tp))
+ { }
+
+      const _Tp& _M_cget() const { return _M_tp; }
+      _Tp& _M_get() { return _M_tp; }
+
+    private:
+      _Tp _M_tp;
+    };
+
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __cache_hash_code>
+    struct _Local_iterator_base;
+# 1172 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __cache_hash_code>
+    struct _Hash_code_base;
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, false>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _Hash>
+    {
+    private:
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>;
+
+    protected:
+      typedef void* __hash_code;
+      typedef _Hash_node<_Value, false> __node_type;
+
+
+
+      _Hash_code_base() = default;
+
+      _Hash_code_base(const _ExtractKey& __ex, const _H1&, const _H2&,
+        const _Hash& __h)
+      : __ebo_extract_key(__ex), __ebo_hash(__h) { }
+
+      __hash_code
+      _M_hash_code(const _Key& __key) const
+      { return 0; }
+
+      std::size_t
+      _M_bucket_index(const _Key& __k, __hash_code,
+        std::size_t __bkt_count) const
+      { return _M_ranged_hash()(__k, __bkt_count); }
+
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const
+ noexcept( noexcept(declval<const _Hash&>()(declval<const _Key&>(),
+         (std::size_t)0)) )
+      { return _M_ranged_hash()(_M_extract()(__p->_M_v()), __bkt_count); }
+
+      void
+      _M_store_code(__node_type*, __hash_code) const
+      { }
+
+      void
+      _M_copy_code(__node_type*, const __node_type*) const
+      { }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+ std::swap(__ebo_extract_key::_M_get(),
+    __x.__ebo_extract_key::_M_get());
+ std::swap(__ebo_hash::_M_get(), __x.__ebo_hash::_M_get());
+      }
+
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_M_cget(); }
+
+      const _Hash&
+      _M_ranged_hash() const { return __ebo_hash::_M_cget(); }
+    };
+
+
+
+
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash, true>;
+
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, false>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _H1>,
+      private _Hashtable_ebo_helper<2, _H2>
+    {
+    private:
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
+      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
+
+
+      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, false>;
+
+    public:
+      typedef _H1 hasher;
+
+      hasher
+      hash_function() const
+      { return _M_h1(); }
+
+    protected:
+      typedef std::size_t __hash_code;
+      typedef _Hash_node<_Value, false> __node_type;
+
+
+
+      _Hash_code_base() = default;
+
+      _Hash_code_base(const _ExtractKey& __ex,
+        const _H1& __h1, const _H2& __h2,
+        const _Default_ranged_hash&)
+      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
+
+      __hash_code
+      _M_hash_code(const _Key& __k) const
+      {
+ static_assert(__is_invocable<const _H1&, const _Key&>{},
+     "hash function must be invocable with an argument of key type");
+ return _M_h1()(__k);
+      }
+
+      std::size_t
+      _M_bucket_index(const _Key&, __hash_code __c,
+        std::size_t __bkt_count) const
+      { return _M_h2()(__c, __bkt_count); }
+
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const
+ noexcept( noexcept(declval<const _H1&>()(declval<const _Key&>()))
+    && noexcept(declval<const _H2&>()((__hash_code)0,
+          (std::size_t)0)) )
+      { return _M_h2()(_M_h1()(_M_extract()(__p->_M_v())), __bkt_count); }
+
+      void
+      _M_store_code(__node_type*, __hash_code) const
+      { }
+
+      void
+      _M_copy_code(__node_type*, const __node_type*) const
+      { }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+ std::swap(__ebo_extract_key::_M_get(),
+    __x.__ebo_extract_key::_M_get());
+ std::swap(__ebo_h1::_M_get(), __x.__ebo_h1::_M_get());
+ std::swap(__ebo_h2::_M_get(), __x.__ebo_h2::_M_get());
+      }
+
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_M_cget(); }
+
+      const _H1&
+      _M_h1() const { return __ebo_h1::_M_cget(); }
+
+      const _H2&
+      _M_h2() const { return __ebo_h2::_M_cget(); }
+    };
+
+
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2>
+    struct _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, true>
+    : private _Hashtable_ebo_helper<0, _ExtractKey>,
+      private _Hashtable_ebo_helper<1, _H1>,
+      private _Hashtable_ebo_helper<2, _H2>
+    {
+    private:
+
+      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, _H1, _H2,
+      _Default_ranged_hash, true>;
+
+      using __ebo_extract_key = _Hashtable_ebo_helper<0, _ExtractKey>;
+      using __ebo_h1 = _Hashtable_ebo_helper<1, _H1>;
+      using __ebo_h2 = _Hashtable_ebo_helper<2, _H2>;
+
+    public:
+      typedef _H1 hasher;
+
+      hasher
+      hash_function() const
+      { return _M_h1(); }
+
+    protected:
+      typedef std::size_t __hash_code;
+      typedef _Hash_node<_Value, true> __node_type;
+
+
+      _Hash_code_base() = default;
+      _Hash_code_base(const _ExtractKey& __ex,
+        const _H1& __h1, const _H2& __h2,
+        const _Default_ranged_hash&)
+      : __ebo_extract_key(__ex), __ebo_h1(__h1), __ebo_h2(__h2) { }
+
+      __hash_code
+      _M_hash_code(const _Key& __k) const
+      {
+ static_assert(__is_invocable<const _H1&, const _Key&>{},
+     "hash function must be invocable with an argument of key type");
+ return _M_h1()(__k);
+      }
+
+      std::size_t
+      _M_bucket_index(const _Key&, __hash_code __c,
+        std::size_t __bkt_count) const
+      { return _M_h2()(__c, __bkt_count); }
+
+      std::size_t
+      _M_bucket_index(const __node_type* __p, std::size_t __bkt_count) const
+ noexcept( noexcept(declval<const _H2&>()((__hash_code)0,
+       (std::size_t)0)) )
+      { return _M_h2()(__p->_M_hash_code, __bkt_count); }
+
+      void
+      _M_store_code(__node_type* __n, __hash_code __c) const
+      { __n->_M_hash_code = __c; }
+
+      void
+      _M_copy_code(__node_type* __to, const __node_type* __from) const
+      { __to->_M_hash_code = __from->_M_hash_code; }
+
+      void
+      _M_swap(_Hash_code_base& __x)
+      {
+ std::swap(__ebo_extract_key::_M_get(),
+    __x.__ebo_extract_key::_M_get());
+ std::swap(__ebo_h1::_M_get(), __x.__ebo_h1::_M_get());
+ std::swap(__ebo_h2::_M_get(), __x.__ebo_h2::_M_get());
+      }
+
+      const _ExtractKey&
+      _M_extract() const { return __ebo_extract_key::_M_cget(); }
+
+      const _H1&
+      _M_h1() const { return __ebo_h1::_M_cget(); }
+
+      const _H2&
+      _M_h2() const { return __ebo_h2::_M_cget(); }
+    };
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+    _H1, _H2, _Hash, true>
+    : private _Hashtable_ebo_helper<0, _H2>
+    {
+    protected:
+      using __base_type = _Hashtable_ebo_helper<0, _H2>;
+      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, true>;
+
+      _Local_iterator_base() = default;
+      _Local_iterator_base(const __hash_code_base& __base,
+      _Hash_node<_Value, true>* __p,
+      std::size_t __bkt, std::size_t __bkt_count)
+      : __base_type(__base._M_h2()),
+ _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) { }
+
+      void
+      _M_incr()
+      {
+ _M_cur = _M_cur->_M_next();
+ if (_M_cur)
+   {
+     std::size_t __bkt
+       = __base_type::_M_get()(_M_cur->_M_hash_code,
+        _M_bucket_count);
+     if (__bkt != _M_bucket)
+       _M_cur = nullptr;
+   }
+      }
+
+      _Hash_node<_Value, true>* _M_cur;
+      std::size_t _M_bucket;
+      std::size_t _M_bucket_count;
+
+    public:
+      const void*
+      _M_curr() const { return _M_cur; }
+
+      std::size_t
+      _M_get_bucket() const { return _M_bucket; }
+    };
+
+
+
+
+
+  template<typename _Tp, bool _IsEmpty = std::is_empty<_Tp>::value>
+    struct _Hash_code_storage
+    {
+      __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
+
+      _Tp*
+      _M_h() { return _M_storage._M_ptr(); }
+
+      const _Tp*
+      _M_h() const { return _M_storage._M_ptr(); }
+    };
+
+
+  template<typename _Tp>
+    struct _Hash_code_storage<_Tp, true>
+    {
+      static_assert( std::is_empty<_Tp>::value, "Type must be empty" );
+
+
+
+      _Tp*
+      _M_h() { return reinterpret_cast<_Tp*>(this); }
+
+      const _Tp*
+      _M_h() const { return reinterpret_cast<const _Tp*>(this); }
+    };
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    using __hash_code_for_local_iter
+      = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey,
+        _H1, _H2, _Hash, false>>;
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash>
+    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
+    _H1, _H2, _Hash, false>
+    : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _H1, _H2, _Hash>
+    {
+    protected:
+      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, false>;
+
+      _Local_iterator_base() : _M_bucket_count(-1) { }
+
+      _Local_iterator_base(const __hash_code_base& __base,
+      _Hash_node<_Value, false>* __p,
+      std::size_t __bkt, std::size_t __bkt_count)
+      : _M_cur(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
+      { _M_init(__base); }
+
+      ~_Local_iterator_base()
+      {
+ if (_M_bucket_count != -1)
+   _M_destroy();
+      }
+
+      _Local_iterator_base(const _Local_iterator_base& __iter)
+      : _M_cur(__iter._M_cur), _M_bucket(__iter._M_bucket),
+        _M_bucket_count(__iter._M_bucket_count)
+      {
+ if (_M_bucket_count != -1)
+   _M_init(*__iter._M_h());
+      }
+
+      _Local_iterator_base&
+      operator=(const _Local_iterator_base& __iter)
+      {
+ if (_M_bucket_count != -1)
+   _M_destroy();
+ _M_cur = __iter._M_cur;
+ _M_bucket = __iter._M_bucket;
+ _M_bucket_count = __iter._M_bucket_count;
+ if (_M_bucket_count != -1)
+   _M_init(*__iter._M_h());
+ return *this;
+      }
+
+      void
+      _M_incr()
+      {
+ _M_cur = _M_cur->_M_next();
+ if (_M_cur)
+   {
+     std::size_t __bkt = this->_M_h()->_M_bucket_index(_M_cur,
+             _M_bucket_count);
+     if (__bkt != _M_bucket)
+       _M_cur = nullptr;
+   }
+      }
+
+      _Hash_node<_Value, false>* _M_cur;
+      std::size_t _M_bucket;
+      std::size_t _M_bucket_count;
+
+      void
+      _M_init(const __hash_code_base& __base)
+      { ::new(this->_M_h()) __hash_code_base(__base); }
+
+      void
+      _M_destroy() { this->_M_h()->~__hash_code_base(); }
+
+    public:
+      const void*
+      _M_curr() const { return _M_cur; }
+
+      std::size_t
+      _M_get_bucket() const { return _M_bucket; }
+    };
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash, bool __cache>
+    inline bool
+    operator==(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __x,
+        const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __y)
+    { return __x._M_curr() == __y._M_curr(); }
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash, bool __cache>
+    inline bool
+    operator!=(const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __x,
+        const _Local_iterator_base<_Key, _Value, _ExtractKey,
+       _H1, _H2, _Hash, __cache>& __y)
+    { return __x._M_curr() != __y._M_curr(); }
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __constant_iterators, bool __cache>
+    struct _Local_iterator
+    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+      _H1, _H2, _Hash, __cache>
+    {
+    private:
+      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, __cache>;
+      using __hash_code_base = typename __base_type::__hash_code_base;
+    public:
+      typedef _Value value_type;
+      typedef typename std::conditional<__constant_iterators,
+     const _Value*, _Value*>::type
+             pointer;
+      typedef typename std::conditional<__constant_iterators,
+     const _Value&, _Value&>::type
+             reference;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      _Local_iterator() = default;
+
+      _Local_iterator(const __hash_code_base& __base,
+        _Hash_node<_Value, __cache>* __n,
+        std::size_t __bkt, std::size_t __bkt_count)
+      : __base_type(__base, __n, __bkt, __bkt_count)
+      { }
+
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const
+      { return this->_M_cur->_M_valptr(); }
+
+      _Local_iterator&
+      operator++()
+      {
+ this->_M_incr();
+ return *this;
+      }
+
+      _Local_iterator
+      operator++(int)
+      {
+ _Local_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+
+
+  template<typename _Key, typename _Value, typename _ExtractKey,
+    typename _H1, typename _H2, typename _Hash,
+    bool __constant_iterators, bool __cache>
+    struct _Local_const_iterator
+    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
+      _H1, _H2, _Hash, __cache>
+    {
+    private:
+      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
+            _H1, _H2, _Hash, __cache>;
+      using __hash_code_base = typename __base_type::__hash_code_base;
+
+    public:
+      typedef _Value value_type;
+      typedef const _Value* pointer;
+      typedef const _Value& reference;
+      typedef std::ptrdiff_t difference_type;
+      typedef std::forward_iterator_tag iterator_category;
+
+      _Local_const_iterator() = default;
+
+      _Local_const_iterator(const __hash_code_base& __base,
+       _Hash_node<_Value, __cache>* __n,
+       std::size_t __bkt, std::size_t __bkt_count)
+      : __base_type(__base, __n, __bkt, __bkt_count)
+      { }
+
+      _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey,
+        _H1, _H2, _Hash,
+        __constant_iterators,
+        __cache>& __x)
+      : __base_type(__x)
+      { }
+
+      reference
+      operator*() const
+      { return this->_M_cur->_M_v(); }
+
+      pointer
+      operator->() const
+      { return this->_M_cur->_M_valptr(); }
+
+      _Local_const_iterator&
+      operator++()
+      {
+ this->_M_incr();
+ return *this;
+      }
+
+      _Local_const_iterator
+      operator++(int)
+      {
+ _Local_const_iterator __tmp(*this);
+ this->_M_incr();
+ return __tmp;
+      }
+    };
+# 1722 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<typename _Key, typename _Value,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _Traits>
+  struct _Hashtable_base
+  : public _Hash_code_base<_Key, _Value, _ExtractKey, _H1, _H2, _Hash,
+      _Traits::__hash_cached::value>,
+    private _Hashtable_ebo_helper<0, _Equal>
+  {
+  public:
+    typedef _Key key_type;
+    typedef _Value value_type;
+    typedef _Equal key_equal;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+
+    using __traits_type = _Traits;
+    using __hash_cached = typename __traits_type::__hash_cached;
+    using __constant_iterators = typename __traits_type::__constant_iterators;
+    using __unique_keys = typename __traits_type::__unique_keys;
+
+    using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
+          _H1, _H2, _Hash,
+          __hash_cached::value>;
+
+    using __hash_code = typename __hash_code_base::__hash_code;
+    using __node_type = typename __hash_code_base::__node_type;
+
+    using iterator = __detail::_Node_iterator<value_type,
+           __constant_iterators::value,
+           __hash_cached::value>;
+
+    using const_iterator = __detail::_Node_const_iterator<value_type,
+         __constant_iterators::value,
+         __hash_cached::value>;
+
+    using local_iterator = __detail::_Local_iterator<key_type, value_type,
+        _ExtractKey, _H1, _H2, _Hash,
+        __constant_iterators::value,
+           __hash_cached::value>;
+
+    using const_local_iterator = __detail::_Local_const_iterator<key_type,
+         value_type,
+     _ExtractKey, _H1, _H2, _Hash,
+     __constant_iterators::value,
+     __hash_cached::value>;
+
+    using __ireturn_type = typename std::conditional<__unique_keys::value,
+           std::pair<iterator, bool>,
+           iterator>::type;
+  private:
+    using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>;
+
+    template<typename _NodeT>
+      struct _Equal_hash_code
+      {
+       static bool
+       _S_equals(__hash_code, const _NodeT&)
+       { return true; }
+      };
+
+    template<typename _Ptr2>
+      struct _Equal_hash_code<_Hash_node<_Ptr2, true>>
+      {
+       static bool
+       _S_equals(__hash_code __c, const _Hash_node<_Ptr2, true>& __n)
+       { return __c == __n._M_hash_code; }
+      };
+
+  protected:
+    _Hashtable_base() = default;
+    _Hashtable_base(const _ExtractKey& __ex, const _H1& __h1, const _H2& __h2,
+      const _Hash& __hash, const _Equal& __eq)
+    : __hash_code_base(__ex, __h1, __h2, __hash), _EqualEBO(__eq)
+    { }
+
+    bool
+    _M_equals(const _Key& __k, __hash_code __c, __node_type* __n) const
+    {
+      static_assert(__is_invocable<const _Equal&, const _Key&, const _Key&>{},
+   "key equality predicate must be invocable with two arguments of "
+   "key type");
+      return _Equal_hash_code<__node_type>::_S_equals(__c, *__n)
+ && _M_eq()(__k, this->_M_extract()(__n->_M_v()));
+    }
+
+    void
+    _M_swap(_Hashtable_base& __x)
+    {
+      __hash_code_base::_M_swap(__x);
+      std::swap(_EqualEBO::_M_get(), __x._EqualEBO::_M_get());
+    }
+
+    const _Equal&
+    _M_eq() const { return _EqualEBO::_M_cget(); }
+  };
+# 1826 "/usr/include/c++/10.2.0/bits/hashtable_policy.h" 3
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits,
+    bool _Unique_keys = _Traits::__unique_keys::value>
+    struct _Equality;
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+         _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+
+      bool
+      _M_equal(const __hashtable&) const;
+    };
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    bool
+    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, true>::
+    _M_equal(const __hashtable& __other) const
+    {
+      using __node_base = typename __hashtable::__node_base;
+      using __node_type = typename __hashtable::__node_type;
+      const __hashtable* __this = static_cast<const __hashtable*>(this);
+      if (__this->size() != __other.size())
+ return false;
+
+      for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx)
+ {
+   std::size_t __ybkt = __other._M_bucket_index(__itx._M_cur);
+   __node_base* __prev_n = __other._M_buckets[__ybkt];
+   if (!__prev_n)
+     return false;
+
+   for (__node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);;
+        __n = __n->_M_next())
+     {
+       if (__n->_M_v() == *__itx)
+  break;
+
+       if (!__n->_M_nxt
+    || __other._M_bucket_index(__n->_M_next()) != __ybkt)
+  return false;
+     }
+ }
+
+      return true;
+    }
+
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>
+    {
+      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+         _H1, _H2, _Hash, _RehashPolicy, _Traits>;
+
+      bool
+      _M_equal(const __hashtable&) const;
+    };
+
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    bool
+    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+       _H1, _H2, _Hash, _RehashPolicy, _Traits, false>::
+    _M_equal(const __hashtable& __other) const
+    {
+      using __node_base = typename __hashtable::__node_base;
+      using __node_type = typename __hashtable::__node_type;
+      const __hashtable* __this = static_cast<const __hashtable*>(this);
+      if (__this->size() != __other.size())
+ return false;
+
+      for (auto __itx = __this->begin(); __itx != __this->end();)
+ {
+   std::size_t __x_count = 1;
+   auto __itx_end = __itx;
+   for (++__itx_end; __itx_end != __this->end()
+   && __this->key_eq()(_ExtractKey()(*__itx),
+         _ExtractKey()(*__itx_end));
+        ++__itx_end)
+     ++__x_count;
+
+   std::size_t __ybkt = __other._M_bucket_index(__itx._M_cur);
+   __node_base* __y_prev_n = __other._M_buckets[__ybkt];
+   if (!__y_prev_n)
+     return false;
+
+   __node_type* __y_n = static_cast<__node_type*>(__y_prev_n->_M_nxt);
+   for (;; __y_n = __y_n->_M_next())
+     {
+       if (__this->key_eq()(_ExtractKey()(__y_n->_M_v()),
+       _ExtractKey()(*__itx)))
+  break;
+
+       if (!__y_n->_M_nxt
+    || __other._M_bucket_index(__y_n->_M_next()) != __ybkt)
+  return false;
+     }
+
+   typename __hashtable::const_iterator __ity(__y_n);
+   for (auto __ity_end = __ity; __ity_end != __other.end(); ++__ity_end)
+     if (--__x_count == 0)
+       break;
+
+   if (__x_count != 0)
+     return false;
+
+   if (!std::is_permutation(__itx, __itx_end, __ity))
+     return false;
+
+   __itx = __itx_end;
+ }
+      return true;
+    }
+
+
+
+
+
+  template<typename _NodeAlloc>
+    struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc>
+    {
+    private:
+      using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>;
+    public:
+      using __node_type = typename _NodeAlloc::value_type;
+      using __node_alloc_type = _NodeAlloc;
+
+      using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>;
+
+      using __value_alloc_traits = typename __node_alloc_traits::template
+ rebind_traits<typename __node_type::value_type>;
+
+      using __node_base = __detail::_Hash_node_base;
+      using __bucket_type = __node_base*;
+      using __bucket_alloc_type =
+ __alloc_rebind<__node_alloc_type, __bucket_type>;
+      using __bucket_alloc_traits = std::allocator_traits<__bucket_alloc_type>;
+
+      _Hashtable_alloc() = default;
+      _Hashtable_alloc(const _Hashtable_alloc&) = default;
+      _Hashtable_alloc(_Hashtable_alloc&&) = default;
+
+      template<typename _Alloc>
+ _Hashtable_alloc(_Alloc&& __a)
+ : __ebo_node_alloc(std::forward<_Alloc>(__a))
+ { }
+
+      __node_alloc_type&
+      _M_node_allocator()
+      { return __ebo_node_alloc::_M_get(); }
+
+      const __node_alloc_type&
+      _M_node_allocator() const
+      { return __ebo_node_alloc::_M_cget(); }
+
+
+      template<typename... _Args>
+ __node_type*
+ _M_allocate_node(_Args&&... __args);
+
+
+      void
+      _M_deallocate_node(__node_type* __n);
+
+
+      void
+      _M_deallocate_node_ptr(__node_type* __n);
+
+
+
+      void
+      _M_deallocate_nodes(__node_type* __n);
+
+      __bucket_type*
+      _M_allocate_buckets(std::size_t __bkt_count);
+
+      void
+      _M_deallocate_buckets(__bucket_type*, std::size_t __bkt_count);
+    };
+
+
+
+  template<typename _NodeAlloc>
+    template<typename... _Args>
+      auto
+      _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args)
+      -> __node_type*
+      {
+ auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1);
+ __node_type* __n = std::__to_address(__nptr);
+ try
+   {
+     ::new ((void*)__n) __node_type;
+     __node_alloc_traits::construct(_M_node_allocator(),
+        __n->_M_valptr(),
+        std::forward<_Args>(__args)...);
+     return __n;
+   }
+ catch(...)
+   {
+     __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1);
+     throw;
+   }
+      }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_type* __n)
+    {
+      __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr());
+      _M_deallocate_node_ptr(__n);
+    }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node_ptr(__node_type* __n)
+    {
+      typedef typename __node_alloc_traits::pointer _Ptr;
+      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n);
+      __n->~__node_type();
+      __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1);
+    }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_type* __n)
+    {
+      while (__n)
+ {
+   __node_type* __tmp = __n;
+   __n = __n->_M_next();
+   _M_deallocate_node(__tmp);
+ }
+    }
+
+  template<typename _NodeAlloc>
+    typename _Hashtable_alloc<_NodeAlloc>::__bucket_type*
+    _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __bkt_count)
+    {
+      __bucket_alloc_type __alloc(_M_node_allocator());
+
+      auto __ptr = __bucket_alloc_traits::allocate(__alloc, __bkt_count);
+      __bucket_type* __p = std::__to_address(__ptr);
+      __builtin_memset(__p, 0, __bkt_count * sizeof(__bucket_type));
+      return __p;
+    }
+
+  template<typename _NodeAlloc>
+    void
+    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_buckets(__bucket_type* __bkts,
+       std::size_t __bkt_count)
+    {
+      typedef typename __bucket_alloc_traits::pointer _Ptr;
+      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts);
+      __bucket_alloc_type __alloc(_M_node_allocator());
+      __bucket_alloc_traits::deallocate(__alloc, __ptr, __bkt_count);
+    }
+
+
+}
+
+}
+# 36 "/usr/include/c++/10.2.0/bits/hashtable.h" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Tp, typename _Hash>
+    using __cache_default
+      = __not_<__and_<
+         __is_fast_hash<_Hash>,
+
+         __is_nothrow_invocable<const _Hash&, const _Tp&>>>;
+# 169 "/usr/include/c++/10.2.0/bits/hashtable.h" 3
+  template<typename _Key, typename _Value, typename _Alloc,
+    typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash,
+    typename _RehashPolicy, typename _Traits>
+    class _Hashtable
+    : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal,
+           _H1, _H2, _Hash, _Traits>,
+      public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+     _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+          _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+     _H1, _H2, _Hash, _RehashPolicy, _Traits>,
+      private __detail::_Hashtable_alloc<
+ __alloc_rebind<_Alloc,
+         __detail::_Hash_node<_Value,
+         _Traits::__hash_cached::value>>>
+    {
+      static_assert(is_same<typename remove_cv<_Value>::type, _Value>::value,
+   "unordered container must have a non-const, non-volatile value_type");
+
+
+
+
+
+      using __traits_type = _Traits;
+      using __hash_cached = typename __traits_type::__hash_cached;
+      using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>;
+      using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>;
+
+      using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>;
+
+      using __value_alloc_traits =
+ typename __hashtable_alloc::__value_alloc_traits;
+      using __node_alloc_traits =
+ typename __hashtable_alloc::__node_alloc_traits;
+      using __node_base = typename __hashtable_alloc::__node_base;
+      using __bucket_type = typename __hashtable_alloc::__bucket_type;
+
+    public:
+      typedef _Key key_type;
+      typedef _Value value_type;
+      typedef _Alloc allocator_type;
+      typedef _Equal key_equal;
+
+
+
+      typedef typename __value_alloc_traits::pointer pointer;
+      typedef typename __value_alloc_traits::const_pointer const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+
+    private:
+      using __rehash_type = _RehashPolicy;
+      using __rehash_state = typename __rehash_type::_State;
+
+      using __constant_iterators = typename __traits_type::__constant_iterators;
+      using __unique_keys = typename __traits_type::__unique_keys;
+
+      using __key_extract = typename std::conditional<
+          __constant_iterators::value,
+                 __detail::_Identity,
+          __detail::_Select1st>::type;
+
+      using __hashtable_base = __detail::
+          _Hashtable_base<_Key, _Value, _ExtractKey,
+           _Equal, _H1, _H2, _Hash, _Traits>;
+
+      using __hash_code_base = typename __hashtable_base::__hash_code_base;
+      using __hash_code = typename __hashtable_base::__hash_code;
+      using __ireturn_type = typename __hashtable_base::__ireturn_type;
+
+      using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey,
+          _Equal, _H1, _H2, _Hash,
+          _RehashPolicy, _Traits>;
+
+      using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc,
+         _ExtractKey, _Equal,
+         _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+
+      using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey,
+         _Equal, _H1, _H2, _Hash,
+         _RehashPolicy, _Traits>;
+
+      using __reuse_or_alloc_node_gen_t =
+ __detail::_ReuseOrAllocNode<__node_alloc_type>;
+      using __alloc_node_gen_t =
+ __detail::_AllocNode<__node_alloc_type>;
+
+
+      struct _Scoped_node
+      {
+
+ _Scoped_node(__node_type* __n, __hashtable_alloc* __h)
+ : _M_h(__h), _M_node(__n) { }
+
+
+ template<typename... _Args>
+   _Scoped_node(__hashtable_alloc* __h, _Args&&... __args)
+   : _M_h(__h),
+     _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...))
+   { }
+
+
+ ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); };
+
+ _Scoped_node(const _Scoped_node&) = delete;
+ _Scoped_node& operator=(const _Scoped_node&) = delete;
+
+ __hashtable_alloc* _M_h;
+ __node_type* _M_node;
+      };
+
+      template<typename _Ht>
+ static constexpr
+ typename conditional<std::is_lvalue_reference<_Ht>::value,
+        const value_type&, value_type&&>::type
+ __fwd_value_for(value_type& __val) noexcept
+ { return std::move(__val); }
+
+
+      template<typename _Cond>
+ using __if_hash_cached = __or_<__not_<__hash_cached>, _Cond>;
+
+      template<typename _Cond>
+ using __if_hash_not_cached = __or_<__hash_cached, _Cond>;
+
+
+
+
+
+      struct __hash_code_base_access : __hash_code_base
+      { using __hash_code_base::_M_bucket_index; };
+
+
+
+      static_assert(noexcept(declval<const __hash_code_base_access&>()
+        ._M_bucket_index((const __node_type*)nullptr,
+           (std::size_t)0)),
+      "Cache the hash code or qualify your functors involved"
+      " in hash code and bucket index computation with noexcept");
+
+
+
+      static_assert(__if_hash_cached<is_default_constructible<_H2>>::value,
+      "Functor used to map hash code to bucket index"
+      " must be default constructible");
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa,
+        bool _Unique_keysa>
+ friend struct __detail::_Map_base;
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa>
+ friend struct __detail::_Insert_base;
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa,
+        bool _Constant_iteratorsa>
+ friend struct __detail::_Insert;
+
+      template<typename _Keya, typename _Valuea, typename _Alloca,
+        typename _ExtractKeya, typename _Equala,
+        typename _H1a, typename _H2a, typename _Hasha,
+        typename _RehashPolicya, typename _Traitsa,
+        bool _Unique_keysa>
+ friend struct __detail::_Equality;
+
+    public:
+      using size_type = typename __hashtable_base::size_type;
+      using difference_type = typename __hashtable_base::difference_type;
+
+      using iterator = typename __hashtable_base::iterator;
+      using const_iterator = typename __hashtable_base::const_iterator;
+
+      using local_iterator = typename __hashtable_base::local_iterator;
+      using const_local_iterator = typename __hashtable_base::
+       const_local_iterator;
+
+
+
+
+
+
+    private:
+      __bucket_type* _M_buckets = &_M_single_bucket;
+      size_type _M_bucket_count = 1;
+      __node_base _M_before_begin;
+      size_type _M_element_count = 0;
+      _RehashPolicy _M_rehash_policy;
+
+
+
+
+
+
+
+      __bucket_type _M_single_bucket = nullptr;
+
+      bool
+      _M_uses_single_bucket(__bucket_type* __bkts) const
+      { return __builtin_expect(__bkts == &_M_single_bucket, false); }
+
+      bool
+      _M_uses_single_bucket() const
+      { return _M_uses_single_bucket(_M_buckets); }
+
+      __hashtable_alloc&
+      _M_base_alloc() { return *this; }
+
+      __bucket_type*
+      _M_allocate_buckets(size_type __bkt_count)
+      {
+ if (__builtin_expect(__bkt_count == 1, false))
+   {
+     _M_single_bucket = nullptr;
+     return &_M_single_bucket;
+   }
+
+ return __hashtable_alloc::_M_allocate_buckets(__bkt_count);
+      }
+
+      void
+      _M_deallocate_buckets(__bucket_type* __bkts, size_type __bkt_count)
+      {
+ if (_M_uses_single_bucket(__bkts))
+   return;
+
+ __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count);
+      }
+
+      void
+      _M_deallocate_buckets()
+      { _M_deallocate_buckets(_M_buckets, _M_bucket_count); }
+
+
+
+      __node_type*
+      _M_bucket_begin(size_type __bkt) const;
+
+      __node_type*
+      _M_begin() const
+      { return static_cast<__node_type*>(_M_before_begin._M_nxt); }
+
+
+
+      template<typename _Ht>
+ void
+ _M_assign_elements(_Ht&&);
+
+      template<typename _Ht, typename _NodeGenerator>
+ void
+ _M_assign(_Ht&&, const _NodeGenerator&);
+
+      void
+      _M_move_assign(_Hashtable&&, true_type);
+
+      void
+      _M_move_assign(_Hashtable&&, false_type);
+
+      void
+      _M_reset() noexcept;
+
+      _Hashtable(const _H1& __h1, const _H2& __h2, const _Hash& __h,
+   const _Equal& __eq, const _ExtractKey& __exk,
+   const allocator_type& __a)
+      : __hashtable_base(__exk, __h1, __h2, __h, __eq),
+ __hashtable_alloc(__node_alloc_type(__a))
+      { }
+
+    public:
+
+      _Hashtable() = default;
+      _Hashtable(size_type __bkt_count_hint,
+   const _H1&, const _H2&, const _Hash&,
+   const _Equal&, const _ExtractKey&,
+   const allocator_type&);
+
+      template<typename _InputIterator>
+ _Hashtable(_InputIterator __first, _InputIterator __last,
+     size_type __bkt_count_hint,
+     const _H1&, const _H2&, const _Hash&,
+     const _Equal&, const _ExtractKey&,
+     const allocator_type&);
+
+      _Hashtable(const _Hashtable&);
+
+      _Hashtable(_Hashtable&&) noexcept;
+
+      _Hashtable(const _Hashtable&, const allocator_type&);
+
+      _Hashtable(_Hashtable&&, const allocator_type&);
+
+
+      explicit
+      _Hashtable(const allocator_type& __a)
+      : __hashtable_alloc(__node_alloc_type(__a))
+      { }
+
+      explicit
+      _Hashtable(size_type __bkt_count_hint,
+   const _H1& __hf = _H1(),
+   const key_equal& __eql = key_equal(),
+   const allocator_type& __a = allocator_type())
+      : _Hashtable(__bkt_count_hint, __hf, _H2(), _Hash(), __eql,
+     __key_extract(), __a)
+      { }
+
+      template<typename _InputIterator>
+ _Hashtable(_InputIterator __f, _InputIterator __l,
+     size_type __bkt_count_hint = 0,
+     const _H1& __hf = _H1(),
+     const key_equal& __eql = key_equal(),
+     const allocator_type& __a = allocator_type())
+ : _Hashtable(__f, __l, __bkt_count_hint, __hf, _H2(), _Hash(), __eql,
+       __key_extract(), __a)
+ { }
+
+      _Hashtable(initializer_list<value_type> __l,
+   size_type __bkt_count_hint = 0,
+   const _H1& __hf = _H1(),
+   const key_equal& __eql = key_equal(),
+   const allocator_type& __a = allocator_type())
+      : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint,
+     __hf, _H2(), _Hash(), __eql,
+     __key_extract(), __a)
+      { }
+
+      _Hashtable&
+      operator=(const _Hashtable& __ht);
+
+      _Hashtable&
+      operator=(_Hashtable&& __ht)
+      noexcept(__node_alloc_traits::_S_nothrow_move()
+        && is_nothrow_move_assignable<_H1>::value
+        && is_nothrow_move_assignable<_Equal>::value)
+      {
+        constexpr bool __move_storage =
+   __node_alloc_traits::_S_propagate_on_move_assign()
+   || __node_alloc_traits::_S_always_equal();
+ _M_move_assign(std::move(__ht), __bool_constant<__move_storage>());
+ return *this;
+      }
+
+      _Hashtable&
+      operator=(initializer_list<value_type> __l)
+      {
+ __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);
+ _M_before_begin._M_nxt = nullptr;
+ clear();
+ this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys());
+ return *this;
+      }
+
+      ~_Hashtable() noexcept;
+
+      void
+      swap(_Hashtable&)
+      noexcept(__and_<__is_nothrow_swappable<_H1>,
+                   __is_nothrow_swappable<_Equal>>::value);
+
+
+      iterator
+      begin() noexcept
+      { return iterator(_M_begin()); }
+
+      const_iterator
+      begin() const noexcept
+      { return const_iterator(_M_begin()); }
+
+      iterator
+      end() noexcept
+      { return iterator(nullptr); }
+
+      const_iterator
+      end() const noexcept
+      { return const_iterator(nullptr); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return const_iterator(_M_begin()); }
+
+      const_iterator
+      cend() const noexcept
+      { return const_iterator(nullptr); }
+
+      size_type
+      size() const noexcept
+      { return _M_element_count; }
+
+      bool
+      empty() const noexcept
+      { return size() == 0; }
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(this->_M_node_allocator()); }
+
+      size_type
+      max_size() const noexcept
+      { return __node_alloc_traits::max_size(this->_M_node_allocator()); }
+
+
+      key_equal
+      key_eq() const
+      { return this->_M_eq(); }
+
+
+
+
+      size_type
+      bucket_count() const noexcept
+      { return _M_bucket_count; }
+
+      size_type
+      max_bucket_count() const noexcept
+      { return max_size(); }
+
+      size_type
+      bucket_size(size_type __bkt) const
+      { return std::distance(begin(__bkt), end(__bkt)); }
+
+      size_type
+      bucket(const key_type& __k) const
+      { return _M_bucket_index(__k, this->_M_hash_code(__k)); }
+
+      local_iterator
+      begin(size_type __bkt)
+      {
+ return local_iterator(*this, _M_bucket_begin(__bkt),
+         __bkt, _M_bucket_count);
+      }
+
+      local_iterator
+      end(size_type __bkt)
+      { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); }
+
+      const_local_iterator
+      begin(size_type __bkt) const
+      {
+ return const_local_iterator(*this, _M_bucket_begin(__bkt),
+        __bkt, _M_bucket_count);
+      }
+
+      const_local_iterator
+      end(size_type __bkt) const
+      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }
+
+
+      const_local_iterator
+      cbegin(size_type __bkt) const
+      {
+ return const_local_iterator(*this, _M_bucket_begin(__bkt),
+        __bkt, _M_bucket_count);
+      }
+
+      const_local_iterator
+      cend(size_type __bkt) const
+      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }
+
+      float
+      load_factor() const noexcept
+      {
+ return static_cast<float>(size()) / static_cast<float>(bucket_count());
+      }
+
+
+
+
+
+
+      const _RehashPolicy&
+      __rehash_policy() const
+      { return _M_rehash_policy; }
+
+      void
+      __rehash_policy(const _RehashPolicy& __pol)
+      { _M_rehash_policy = __pol; }
+
+
+      iterator
+      find(const key_type& __k);
+
+      const_iterator
+      find(const key_type& __k) const;
+
+      size_type
+      count(const key_type& __k) const;
+
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __k);
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __k) const;
+
+    protected:
+
+      size_type
+      _M_bucket_index(__node_type* __n) const noexcept
+      { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); }
+
+      size_type
+      _M_bucket_index(const key_type& __k, __hash_code __c) const
+      { return __hash_code_base::_M_bucket_index(__k, __c, _M_bucket_count); }
+
+
+
+      __node_base*
+      _M_find_before_node(size_type, const key_type&, __hash_code) const;
+
+      __node_type*
+      _M_find_node(size_type __bkt, const key_type& __key,
+     __hash_code __c) const
+      {
+ __node_base* __before_n = _M_find_before_node(__bkt, __key, __c);
+ if (__before_n)
+   return static_cast<__node_type*>(__before_n->_M_nxt);
+ return nullptr;
+      }
+
+
+      void
+      _M_insert_bucket_begin(size_type, __node_type*);
+
+
+      void
+      _M_remove_bucket_begin(size_type __bkt, __node_type* __next_n,
+        size_type __next_bkt);
+
+
+      __node_base*
+      _M_get_previous_node(size_type __bkt, __node_base* __n);
+
+
+
+
+      iterator
+      _M_insert_unique_node(const key_type& __k, size_type __bkt,
+       __hash_code __code, __node_type* __n,
+       size_type __n_elt = 1);
+
+
+
+      iterator
+      _M_insert_multi_node(__node_type* __hint, const key_type& __k,
+      __hash_code __code, __node_type* __n);
+
+      template<typename... _Args>
+ std::pair<iterator, bool>
+ _M_emplace(true_type, _Args&&... __args);
+
+      template<typename... _Args>
+ iterator
+ _M_emplace(false_type __uk, _Args&&... __args)
+ { return _M_emplace(cend(), __uk, std::forward<_Args>(__args)...); }
+
+
+      template<typename... _Args>
+ iterator
+ _M_emplace(const_iterator, true_type __uk, _Args&&... __args)
+ { return _M_emplace(__uk, std::forward<_Args>(__args)...).first; }
+
+      template<typename... _Args>
+ iterator
+ _M_emplace(const_iterator, false_type, _Args&&... __args);
+
+      template<typename _Arg, typename _NodeGenerator>
+ std::pair<iterator, bool>
+ _M_insert(_Arg&&, const _NodeGenerator&, true_type, size_type = 1);
+
+      template<typename _Arg, typename _NodeGenerator>
+ iterator
+ _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen,
+    false_type __uk)
+ {
+   return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen,
+      __uk);
+ }
+
+
+      template<typename _Arg, typename _NodeGenerator>
+ iterator
+ _M_insert(const_iterator, _Arg&& __arg,
+    const _NodeGenerator& __node_gen, true_type __uk)
+ {
+   return
+     _M_insert(std::forward<_Arg>(__arg), __node_gen, __uk).first;
+ }
+
+
+      template<typename _Arg, typename _NodeGenerator>
+ iterator
+ _M_insert(const_iterator, _Arg&&,
+    const _NodeGenerator&, false_type);
+
+      size_type
+      _M_erase(true_type, const key_type&);
+
+      size_type
+      _M_erase(false_type, const key_type&);
+
+      iterator
+      _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n);
+
+    public:
+
+      template<typename... _Args>
+ __ireturn_type
+ emplace(_Args&&... __args)
+ { return _M_emplace(__unique_keys(), std::forward<_Args>(__args)...); }
+
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __hint, _Args&&... __args)
+ {
+   return _M_emplace(__hint, __unique_keys(),
+       std::forward<_Args>(__args)...);
+ }
+
+
+
+
+      iterator
+      erase(const_iterator);
+
+
+      iterator
+      erase(iterator __it)
+      { return erase(const_iterator(__it)); }
+
+      size_type
+      erase(const key_type& __k)
+      { return _M_erase(__unique_keys(), __k); }
+
+      iterator
+      erase(const_iterator, const_iterator);
+
+      void
+      clear() noexcept;
+
+
+
+      void rehash(size_type __bkt_count);
+# 962 "/usr/include/c++/10.2.0/bits/hashtable.h" 3
+    private:
+
+      void _M_rehash_aux(size_type __bkt_count, true_type);
+
+
+      void _M_rehash_aux(size_type __bkt_count, false_type);
+
+
+
+      void _M_rehash(size_type __bkt_count, const __rehash_state& __state);
+    };
+
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_bucket_begin(size_type __bkt) const
+    -> __node_type*
+    {
+      __node_base* __n = _M_buckets[__bkt];
+      return __n ? static_cast<__node_type*>(__n->_M_nxt) : nullptr;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(size_type __bkt_count_hint,
+        const _H1& __h1, const _H2& __h2, const _Hash& __h,
+        const _Equal& __eq, const _ExtractKey& __exk,
+        const allocator_type& __a)
+    : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
+    {
+      auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint);
+      if (__bkt_count > _M_bucket_count)
+ {
+   _M_buckets = _M_allocate_buckets(__bkt_count);
+   _M_bucket_count = __bkt_count;
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _InputIterator>
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _Hashtable(_InputIterator __f, _InputIterator __l,
+   size_type __bkt_count_hint,
+   const _H1& __h1, const _H2& __h2, const _Hash& __h,
+   const _Equal& __eq, const _ExtractKey& __exk,
+   const allocator_type& __a)
+      : _Hashtable(__h1, __h2, __h, __eq, __exk, __a)
+      {
+ auto __nb_elems = __detail::__distance_fw(__f, __l);
+ auto __bkt_count =
+   _M_rehash_policy._M_next_bkt(
+     std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems),
+       __bkt_count_hint));
+
+ if (__bkt_count > _M_bucket_count)
+   {
+     _M_buckets = _M_allocate_buckets(__bkt_count);
+     _M_bucket_count = __bkt_count;
+   }
+
+ for (; __f != __l; ++__f)
+   this->insert(*__f);
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    operator=(const _Hashtable& __ht)
+    -> _Hashtable&
+    {
+      if (&__ht == this)
+ return *this;
+
+      if (__node_alloc_traits::_S_propagate_on_copy_assign())
+ {
+   auto& __this_alloc = this->_M_node_allocator();
+   auto& __that_alloc = __ht._M_node_allocator();
+   if (!__node_alloc_traits::_S_always_equal()
+       && __this_alloc != __that_alloc)
+     {
+
+       this->_M_deallocate_nodes(_M_begin());
+       _M_before_begin._M_nxt = nullptr;
+       _M_deallocate_buckets();
+       _M_buckets = nullptr;
+       std::__alloc_on_copy(__this_alloc, __that_alloc);
+       __hashtable_base::operator=(__ht);
+       _M_bucket_count = __ht._M_bucket_count;
+       _M_element_count = __ht._M_element_count;
+       _M_rehash_policy = __ht._M_rehash_policy;
+       __alloc_node_gen_t __alloc_node_gen(*this);
+       try
+  {
+    _M_assign(__ht, __alloc_node_gen);
+  }
+       catch(...)
+  {
+
+
+    _M_reset();
+    throw;
+  }
+       return *this;
+     }
+   std::__alloc_on_copy(__this_alloc, __that_alloc);
+ }
+
+
+      _M_assign_elements(__ht);
+      return *this;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Ht>
+      void
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_assign_elements(_Ht&& __ht)
+      {
+ __bucket_type* __former_buckets = nullptr;
+ std::size_t __former_bucket_count = _M_bucket_count;
+ const __rehash_state& __former_state = _M_rehash_policy._M_state();
+
+ if (_M_bucket_count != __ht._M_bucket_count)
+   {
+     __former_buckets = _M_buckets;
+     _M_buckets = _M_allocate_buckets(__ht._M_bucket_count);
+     _M_bucket_count = __ht._M_bucket_count;
+   }
+ else
+   __builtin_memset(_M_buckets, 0,
+      _M_bucket_count * sizeof(__bucket_type));
+
+ try
+   {
+     __hashtable_base::operator=(std::forward<_Ht>(__ht));
+     _M_element_count = __ht._M_element_count;
+     _M_rehash_policy = __ht._M_rehash_policy;
+     __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);
+     _M_before_begin._M_nxt = nullptr;
+     _M_assign(std::forward<_Ht>(__ht), __roan);
+     if (__former_buckets)
+       _M_deallocate_buckets(__former_buckets, __former_bucket_count);
+   }
+ catch(...)
+   {
+     if (__former_buckets)
+       {
+
+  _M_deallocate_buckets();
+  _M_rehash_policy._M_reset(__former_state);
+  _M_buckets = __former_buckets;
+  _M_bucket_count = __former_bucket_count;
+       }
+     __builtin_memset(_M_buckets, 0,
+        _M_bucket_count * sizeof(__bucket_type));
+     throw;
+   }
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Ht, typename _NodeGenerator>
+      void
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_assign(_Ht&& __ht, const _NodeGenerator& __node_gen)
+      {
+ __bucket_type* __buckets = nullptr;
+ if (!_M_buckets)
+   _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count);
+
+ try
+   {
+     if (!__ht._M_before_begin._M_nxt)
+       return;
+
+
+
+     __node_type* __ht_n = __ht._M_begin();
+     __node_type* __this_n
+       = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v()));
+     this->_M_copy_code(__this_n, __ht_n);
+     _M_before_begin._M_nxt = __this_n;
+     _M_buckets[_M_bucket_index(__this_n)] = &_M_before_begin;
+
+
+     __node_base* __prev_n = __this_n;
+     for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next())
+       {
+  __this_n = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v()));
+  __prev_n->_M_nxt = __this_n;
+  this->_M_copy_code(__this_n, __ht_n);
+  size_type __bkt = _M_bucket_index(__this_n);
+  if (!_M_buckets[__bkt])
+    _M_buckets[__bkt] = __prev_n;
+  __prev_n = __this_n;
+       }
+   }
+ catch(...)
+   {
+     clear();
+     if (__buckets)
+       _M_deallocate_buckets();
+     throw;
+   }
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_reset() noexcept
+    {
+      _M_rehash_policy._M_reset();
+      _M_bucket_count = 1;
+      _M_single_bucket = nullptr;
+      _M_buckets = &_M_single_bucket;
+      _M_before_begin._M_nxt = nullptr;
+      _M_element_count = 0;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_move_assign(_Hashtable&& __ht, true_type)
+    {
+      this->_M_deallocate_nodes(_M_begin());
+      _M_deallocate_buckets();
+      __hashtable_base::operator=(std::move(__ht));
+      _M_rehash_policy = __ht._M_rehash_policy;
+      if (!__ht._M_uses_single_bucket())
+ _M_buckets = __ht._M_buckets;
+      else
+ {
+   _M_buckets = &_M_single_bucket;
+   _M_single_bucket = __ht._M_single_bucket;
+ }
+      _M_bucket_count = __ht._M_bucket_count;
+      _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
+      _M_element_count = __ht._M_element_count;
+      std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator());
+
+
+
+      if (_M_begin())
+ _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+      __ht._M_reset();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_move_assign(_Hashtable&& __ht, false_type)
+    {
+      if (__ht._M_node_allocator() == this->_M_node_allocator())
+ _M_move_assign(std::move(__ht), true_type());
+      else
+ {
+
+   _M_assign_elements(std::move(__ht));
+   __ht.clear();
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(const _Hashtable& __ht)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(
+ __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())),
+      _M_buckets(nullptr),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      __alloc_node_gen_t __alloc_node_gen(*this);
+      _M_assign(__ht, __alloc_node_gen);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(_Hashtable&& __ht) noexcept
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(std::move(__ht._M_base_alloc())),
+      _M_buckets(__ht._M_buckets),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_before_begin(__ht._M_before_begin._M_nxt),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+
+      if (__ht._M_uses_single_bucket())
+ {
+   _M_buckets = &_M_single_bucket;
+   _M_single_bucket = __ht._M_single_bucket;
+ }
+
+
+
+      if (_M_begin())
+ _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+
+      __ht._M_reset();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(const _Hashtable& __ht, const allocator_type& __a)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(__node_alloc_type(__a)),
+      _M_buckets(),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      __alloc_node_gen_t __alloc_node_gen(*this);
+      _M_assign(__ht, __alloc_node_gen);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
+    : __hashtable_base(__ht),
+      __map_base(__ht),
+      __rehash_base(__ht),
+      __hashtable_alloc(__node_alloc_type(__a)),
+      _M_buckets(nullptr),
+      _M_bucket_count(__ht._M_bucket_count),
+      _M_element_count(__ht._M_element_count),
+      _M_rehash_policy(__ht._M_rehash_policy)
+    {
+      if (__ht._M_node_allocator() == this->_M_node_allocator())
+ {
+   if (__ht._M_uses_single_bucket())
+     {
+       _M_buckets = &_M_single_bucket;
+       _M_single_bucket = __ht._M_single_bucket;
+     }
+   else
+     _M_buckets = __ht._M_buckets;
+
+   _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt;
+
+
+   if (_M_begin())
+     _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+   __ht._M_reset();
+ }
+      else
+ {
+   __alloc_node_gen_t __alloc_gen(*this);
+
+   using _Fwd_Ht = typename
+     conditional<__move_if_noexcept_cond<value_type>::value,
+   const _Hashtable&, _Hashtable&&>::type;
+   _M_assign(std::forward<_Fwd_Ht>(__ht), __alloc_gen);
+   __ht.clear();
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    ~_Hashtable() noexcept
+    {
+      clear();
+      _M_deallocate_buckets();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    swap(_Hashtable& __x)
+    noexcept(__and_<__is_nothrow_swappable<_H1>,
+                 __is_nothrow_swappable<_Equal>>::value)
+    {
+
+
+
+      this->_M_swap(__x);
+
+      std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator());
+      std::swap(_M_rehash_policy, __x._M_rehash_policy);
+
+
+      if (this->_M_uses_single_bucket())
+ {
+   if (!__x._M_uses_single_bucket())
+     {
+       _M_buckets = __x._M_buckets;
+       __x._M_buckets = &__x._M_single_bucket;
+     }
+ }
+      else if (__x._M_uses_single_bucket())
+ {
+   __x._M_buckets = _M_buckets;
+   _M_buckets = &_M_single_bucket;
+ }
+      else
+ std::swap(_M_buckets, __x._M_buckets);
+
+      std::swap(_M_bucket_count, __x._M_bucket_count);
+      std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt);
+      std::swap(_M_element_count, __x._M_element_count);
+      std::swap(_M_single_bucket, __x._M_single_bucket);
+
+
+
+      if (_M_begin())
+ _M_buckets[_M_bucket_index(_M_begin())] = &_M_before_begin;
+
+      if (__x._M_begin())
+ __x._M_buckets[__x._M_bucket_index(__x._M_begin())]
+   = &__x._M_before_begin;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    find(const key_type& __k)
+    -> iterator
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__bkt, __k, __code);
+      return __p ? iterator(__p) : end();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    find(const key_type& __k) const
+    -> const_iterator
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__bkt, __k, __code);
+      return __p ? const_iterator(__p) : end();
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    count(const key_type& __k) const
+    -> size_type
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_bucket_begin(__bkt);
+      if (!__p)
+ return 0;
+
+      std::size_t __result = 0;
+      for (;; __p = __p->_M_next())
+ {
+   if (this->_M_equals(__k, __code, __p))
+     ++__result;
+   else if (__result)
+
+
+
+     break;
+   if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __bkt)
+     break;
+ }
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    equal_range(const key_type& __k)
+    -> pair<iterator, iterator>
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__bkt, __k, __code);
+
+      if (__p)
+ {
+   __node_type* __p1 = __p->_M_next();
+   while (__p1 && _M_bucket_index(__p1) == __bkt
+   && this->_M_equals(__k, __code, __p1))
+     __p1 = __p1->_M_next();
+
+   return std::make_pair(iterator(__p), iterator(__p1));
+ }
+      else
+ return std::make_pair(end(), end());
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    equal_range(const key_type& __k) const
+    -> pair<const_iterator, const_iterator>
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+      __node_type* __p = _M_find_node(__bkt, __k, __code);
+
+      if (__p)
+ {
+   __node_type* __p1 = __p->_M_next();
+   while (__p1 && _M_bucket_index(__p1) == __bkt
+   && this->_M_equals(__k, __code, __p1))
+     __p1 = __p1->_M_next();
+
+   return std::make_pair(const_iterator(__p), const_iterator(__p1));
+ }
+      else
+ return std::make_pair(end(), end());
+    }
+
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_find_before_node(size_type __bkt, const key_type& __k,
+   __hash_code __code) const
+    -> __node_base*
+    {
+      __node_base* __prev_p = _M_buckets[__bkt];
+      if (!__prev_p)
+ return nullptr;
+
+      for (__node_type* __p = static_cast<__node_type*>(__prev_p->_M_nxt);;
+    __p = __p->_M_next())
+ {
+   if (this->_M_equals(__k, __code, __p))
+     return __prev_p;
+
+   if (!__p->_M_nxt || _M_bucket_index(__p->_M_next()) != __bkt)
+     break;
+   __prev_p = __p;
+ }
+      return nullptr;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_bucket_begin(size_type __bkt, __node_type* __node)
+    {
+      if (_M_buckets[__bkt])
+ {
+
+
+   __node->_M_nxt = _M_buckets[__bkt]->_M_nxt;
+   _M_buckets[__bkt]->_M_nxt = __node;
+ }
+      else
+ {
+
+
+
+   __node->_M_nxt = _M_before_begin._M_nxt;
+   _M_before_begin._M_nxt = __node;
+   if (__node->_M_nxt)
+
+
+     _M_buckets[_M_bucket_index(__node->_M_next())] = __node;
+   _M_buckets[__bkt] = &_M_before_begin;
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_remove_bucket_begin(size_type __bkt, __node_type* __next,
+      size_type __next_bkt)
+    {
+      if (!__next || __next_bkt != __bkt)
+ {
+
+
+   if (__next)
+     _M_buckets[__next_bkt] = _M_buckets[__bkt];
+
+
+   if (&_M_before_begin == _M_buckets[__bkt])
+     _M_before_begin._M_nxt = __next;
+   _M_buckets[__bkt] = nullptr;
+ }
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_get_previous_node(size_type __bkt, __node_base* __n)
+    -> __node_base*
+    {
+      __node_base* __prev_n = _M_buckets[__bkt];
+      while (__prev_n->_M_nxt != __n)
+ __prev_n = __prev_n->_M_nxt;
+      return __prev_n;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename... _Args>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_emplace(true_type, _Args&&... __args)
+      -> pair<iterator, bool>
+      {
+
+ _Scoped_node __node { this, std::forward<_Args>(__args)... };
+ const key_type& __k = this->_M_extract()(__node._M_node->_M_v());
+ __hash_code __code = this->_M_hash_code(__k);
+ size_type __bkt = _M_bucket_index(__k, __code);
+ if (__node_type* __p = _M_find_node(__bkt, __k, __code))
+
+   return std::make_pair(iterator(__p), false);
+
+
+ auto __pos = _M_insert_unique_node(__k, __bkt, __code, __node._M_node);
+ __node._M_node = nullptr;
+ return { __pos, true };
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename... _Args>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_emplace(const_iterator __hint, false_type, _Args&&... __args)
+      -> iterator
+      {
+
+ _Scoped_node __node { this, std::forward<_Args>(__args)... };
+ const key_type& __k = this->_M_extract()(__node._M_node->_M_v());
+
+ __hash_code __code = this->_M_hash_code(__k);
+ auto __pos
+   = _M_insert_multi_node(__hint._M_cur, __k, __code, __node._M_node);
+ __node._M_node = nullptr;
+ return __pos;
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_unique_node(const key_type& __k, size_type __bkt,
+     __hash_code __code, __node_type* __node,
+     size_type __n_elt)
+    -> iterator
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::pair<bool, std::size_t> __do_rehash
+ = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count,
+       __n_elt);
+
+      if (__do_rehash.first)
+ {
+   _M_rehash(__do_rehash.second, __saved_state);
+   __bkt = _M_bucket_index(__k, __code);
+ }
+
+      this->_M_store_code(__node, __code);
+
+
+      _M_insert_bucket_begin(__bkt, __node);
+      ++_M_element_count;
+      return iterator(__node);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_insert_multi_node(__node_type* __hint, const key_type& __k,
+    __hash_code __code, __node_type* __node)
+    -> iterator
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      std::pair<bool, std::size_t> __do_rehash
+ = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);
+
+      if (__do_rehash.first)
+ _M_rehash(__do_rehash.second, __saved_state);
+
+      this->_M_store_code(__node, __code);
+      size_type __bkt = _M_bucket_index(__k, __code);
+
+
+
+      __node_base* __prev
+ = __builtin_expect(__hint != nullptr, false)
+   && this->_M_equals(__k, __code, __hint)
+     ? __hint
+     : _M_find_before_node(__bkt, __k, __code);
+      if (__prev)
+ {
+
+   __node->_M_nxt = __prev->_M_nxt;
+   __prev->_M_nxt = __node;
+   if (__builtin_expect(__prev == __hint, false))
+
+
+     if (__node->_M_nxt
+  && !this->_M_equals(__k, __code, __node->_M_next()))
+       {
+  size_type __next_bkt = _M_bucket_index(__node->_M_next());
+  if (__next_bkt != __bkt)
+    _M_buckets[__next_bkt] = __node;
+       }
+ }
+      else
+
+
+
+ _M_insert_bucket_begin(__bkt, __node);
+      ++_M_element_count;
+      return iterator(__node);
+    }
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Arg, typename _NodeGenerator>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_insert(_Arg&& __v, const _NodeGenerator& __node_gen, true_type,
+  size_type __n_elt)
+      -> pair<iterator, bool>
+      {
+ const key_type& __k = this->_M_extract()(__v);
+ __hash_code __code = this->_M_hash_code(__k);
+ size_type __bkt = _M_bucket_index(__k, __code);
+
+ if (__node_type* __node = _M_find_node(__bkt, __k, __code))
+   return { iterator(__node), false };
+
+ _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this };
+ auto __pos
+   = _M_insert_unique_node(__k, __bkt, __code, __node._M_node, __n_elt);
+ __node._M_node = nullptr;
+ return { __pos, true };
+      }
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    template<typename _Arg, typename _NodeGenerator>
+      auto
+      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+   _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+      _M_insert(const_iterator __hint, _Arg&& __v,
+  const _NodeGenerator& __node_gen, false_type)
+      -> iterator
+      {
+
+
+ __hash_code __code = this->_M_hash_code(this->_M_extract()(__v));
+
+
+ _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this };
+ const key_type& __k = this->_M_extract()(__node._M_node->_M_v());
+ auto __pos
+   = _M_insert_multi_node(__hint._M_cur, __k, __code, __node._M_node);
+ __node._M_node = nullptr;
+ return __pos;
+      }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    erase(const_iterator __it)
+    -> iterator
+    {
+      __node_type* __n = __it._M_cur;
+      std::size_t __bkt = _M_bucket_index(__n);
+
+
+
+
+      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
+      return _M_erase(__bkt, __prev_n, __n);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(size_type __bkt, __node_base* __prev_n, __node_type* __n)
+    -> iterator
+    {
+      if (__prev_n == _M_buckets[__bkt])
+ _M_remove_bucket_begin(__bkt, __n->_M_next(),
+    __n->_M_nxt ? _M_bucket_index(__n->_M_next()) : 0);
+      else if (__n->_M_nxt)
+ {
+   size_type __next_bkt = _M_bucket_index(__n->_M_next());
+   if (__next_bkt != __bkt)
+     _M_buckets[__next_bkt] = __prev_n;
+ }
+
+      __prev_n->_M_nxt = __n->_M_nxt;
+      iterator __result(__n->_M_next());
+      this->_M_deallocate_node(__n);
+      --_M_element_count;
+
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(true_type, const key_type& __k)
+    -> size_type
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+
+
+      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
+      if (!__prev_n)
+ return 0;
+
+
+      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
+      _M_erase(__bkt, __prev_n, __n);
+      return 1;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_erase(false_type, const key_type& __k)
+    -> size_type
+    {
+      __hash_code __code = this->_M_hash_code(__k);
+      std::size_t __bkt = _M_bucket_index(__k, __code);
+
+
+      __node_base* __prev_n = _M_find_before_node(__bkt, __k, __code);
+      if (!__prev_n)
+ return 0;
+
+
+
+
+
+
+
+      __node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);
+      __node_type* __n_last = __n;
+      std::size_t __n_last_bkt = __bkt;
+      do
+ {
+   __n_last = __n_last->_M_next();
+   if (!__n_last)
+     break;
+   __n_last_bkt = _M_bucket_index(__n_last);
+ }
+      while (__n_last_bkt == __bkt && this->_M_equals(__k, __code, __n_last));
+
+
+      size_type __result = 0;
+      do
+ {
+   __node_type* __p = __n->_M_next();
+   this->_M_deallocate_node(__n);
+   __n = __p;
+   ++__result;
+   --_M_element_count;
+ }
+      while (__n != __n_last);
+
+      if (__prev_n == _M_buckets[__bkt])
+ _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt);
+      else if (__n_last && __n_last_bkt != __bkt)
+ _M_buckets[__n_last_bkt] = __prev_n;
+      __prev_n->_M_nxt = __n_last;
+      return __result;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    auto
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    erase(const_iterator __first, const_iterator __last)
+    -> iterator
+    {
+      __node_type* __n = __first._M_cur;
+      __node_type* __last_n = __last._M_cur;
+      if (__n == __last_n)
+ return iterator(__n);
+
+      std::size_t __bkt = _M_bucket_index(__n);
+
+      __node_base* __prev_n = _M_get_previous_node(__bkt, __n);
+      bool __is_bucket_begin = __n == _M_bucket_begin(__bkt);
+      std::size_t __n_bkt = __bkt;
+      for (;;)
+ {
+   do
+     {
+       __node_type* __tmp = __n;
+       __n = __n->_M_next();
+       this->_M_deallocate_node(__tmp);
+       --_M_element_count;
+       if (!__n)
+  break;
+       __n_bkt = _M_bucket_index(__n);
+     }
+   while (__n != __last_n && __n_bkt == __bkt);
+   if (__is_bucket_begin)
+     _M_remove_bucket_begin(__bkt, __n, __n_bkt);
+   if (__n == __last_n)
+     break;
+   __is_bucket_begin = true;
+   __bkt = __n_bkt;
+ }
+
+      if (__n && (__n_bkt != __bkt || __is_bucket_begin))
+ _M_buckets[__n_bkt] = __prev_n;
+      __prev_n->_M_nxt = __n;
+      return iterator(__n);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    clear() noexcept
+    {
+      this->_M_deallocate_nodes(_M_begin());
+      __builtin_memset(_M_buckets, 0, _M_bucket_count * sizeof(__bucket_type));
+      _M_element_count = 0;
+      _M_before_begin._M_nxt = nullptr;
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    rehash(size_type __bkt_count)
+    {
+      const __rehash_state& __saved_state = _M_rehash_policy._M_state();
+      __bkt_count
+ = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1),
+     __bkt_count);
+      __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count);
+
+      if (__bkt_count != _M_bucket_count)
+ _M_rehash(__bkt_count, __saved_state);
+      else
+
+
+ _M_rehash_policy._M_reset(__saved_state);
+    }
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash(size_type __bkt_count, const __rehash_state& __state)
+    {
+      try
+ {
+   _M_rehash_aux(__bkt_count, __unique_keys());
+ }
+      catch(...)
+ {
+
+
+   _M_rehash_policy._M_reset(__state);
+   throw;
+ }
+    }
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash_aux(size_type __bkt_count, true_type)
+    {
+      __bucket_type* __new_buckets = _M_allocate_buckets(__bkt_count);
+      __node_type* __p = _M_begin();
+      _M_before_begin._M_nxt = nullptr;
+      std::size_t __bbegin_bkt = 0;
+      while (__p)
+ {
+   __node_type* __next = __p->_M_next();
+   std::size_t __bkt
+     = __hash_code_base::_M_bucket_index(__p, __bkt_count);
+   if (!__new_buckets[__bkt])
+     {
+       __p->_M_nxt = _M_before_begin._M_nxt;
+       _M_before_begin._M_nxt = __p;
+       __new_buckets[__bkt] = &_M_before_begin;
+       if (__p->_M_nxt)
+  __new_buckets[__bbegin_bkt] = __p;
+       __bbegin_bkt = __bkt;
+     }
+   else
+     {
+       __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
+       __new_buckets[__bkt]->_M_nxt = __p;
+     }
+   __p = __next;
+ }
+
+      _M_deallocate_buckets();
+      _M_bucket_count = __bkt_count;
+      _M_buckets = __new_buckets;
+    }
+
+
+
+  template<typename _Key, typename _Value,
+    typename _Alloc, typename _ExtractKey, typename _Equal,
+    typename _H1, typename _H2, typename _Hash, typename _RehashPolicy,
+    typename _Traits>
+    void
+    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
+        _H1, _H2, _Hash, _RehashPolicy, _Traits>::
+    _M_rehash_aux(size_type __bkt_count, false_type)
+    {
+      __bucket_type* __new_buckets = _M_allocate_buckets(__bkt_count);
+
+      __node_type* __p = _M_begin();
+      _M_before_begin._M_nxt = nullptr;
+      std::size_t __bbegin_bkt = 0;
+      std::size_t __prev_bkt = 0;
+      __node_type* __prev_p = nullptr;
+      bool __check_bucket = false;
+
+      while (__p)
+ {
+   __node_type* __next = __p->_M_next();
+   std::size_t __bkt
+     = __hash_code_base::_M_bucket_index(__p, __bkt_count);
+
+   if (__prev_p && __prev_bkt == __bkt)
+     {
+
+
+
+       __p->_M_nxt = __prev_p->_M_nxt;
+       __prev_p->_M_nxt = __p;
+
+
+
+
+
+
+       __check_bucket = true;
+     }
+   else
+     {
+       if (__check_bucket)
+  {
+
+
+    if (__prev_p->_M_nxt)
+      {
+        std::size_t __next_bkt
+   = __hash_code_base::_M_bucket_index(__prev_p->_M_next(),
+           __bkt_count);
+        if (__next_bkt != __prev_bkt)
+   __new_buckets[__next_bkt] = __prev_p;
+      }
+    __check_bucket = false;
+  }
+
+       if (!__new_buckets[__bkt])
+  {
+    __p->_M_nxt = _M_before_begin._M_nxt;
+    _M_before_begin._M_nxt = __p;
+    __new_buckets[__bkt] = &_M_before_begin;
+    if (__p->_M_nxt)
+      __new_buckets[__bbegin_bkt] = __p;
+    __bbegin_bkt = __bkt;
+  }
+       else
+  {
+    __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
+    __new_buckets[__bkt]->_M_nxt = __p;
+  }
+     }
+   __prev_p = __p;
+   __prev_bkt = __bkt;
+   __p = __next;
+ }
+
+      if (__check_bucket && __prev_p->_M_nxt)
+ {
+   std::size_t __next_bkt
+     = __hash_code_base::_M_bucket_index(__prev_p->_M_next(),
+      __bkt_count);
+   if (__next_bkt != __prev_bkt)
+     __new_buckets[__next_bkt] = __prev_p;
+ }
+
+      _M_deallocate_buckets();
+      _M_bucket_count = __bkt_count;
+      _M_buckets = __new_buckets;
+    }
+# 2225 "/usr/include/c++/10.2.0/bits/hashtable.h" 3
+
+}
+# 47 "/usr/include/c++/10.2.0/unordered_map" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/unordered_map.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<bool _Cache>
+    using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;
+
+  template<typename _Key,
+    typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = std::equal_to<_Key>,
+    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+    typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
+    using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
+                                        _Alloc, __detail::_Select1st,
+            _Pred, _Hash,
+            __detail::_Mod_range_hashing,
+            __detail::_Default_ranged_hash,
+            __detail::_Prime_rehash_policy, _Tr>;
+
+
+  template<bool _Cache>
+    using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;
+
+  template<typename _Key,
+    typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = std::equal_to<_Key>,
+    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
+    typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
+    using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
+      _Alloc, __detail::_Select1st,
+      _Pred, _Hash,
+      __detail::_Mod_range_hashing,
+      __detail::_Default_ranged_hash,
+      __detail::_Prime_rehash_policy, _Tr>;
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    class unordered_multimap;
+# 98 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+  template<typename _Key, typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
+    class unordered_map
+    {
+      typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
+      _Hashtable _M_h;
+
+    public:
+
+
+
+      typedef typename _Hashtable::key_type key_type;
+      typedef typename _Hashtable::value_type value_type;
+      typedef typename _Hashtable::mapped_type mapped_type;
+      typedef typename _Hashtable::hasher hasher;
+      typedef typename _Hashtable::key_equal key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+
+
+
+
+      typedef typename _Hashtable::pointer pointer;
+      typedef typename _Hashtable::const_pointer const_pointer;
+      typedef typename _Hashtable::reference reference;
+      typedef typename _Hashtable::const_reference const_reference;
+      typedef typename _Hashtable::iterator iterator;
+      typedef typename _Hashtable::const_iterator const_iterator;
+      typedef typename _Hashtable::local_iterator local_iterator;
+      typedef typename _Hashtable::const_local_iterator const_local_iterator;
+      typedef typename _Hashtable::size_type size_type;
+      typedef typename _Hashtable::difference_type difference_type;
+# 141 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_map() = default;
+# 150 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      explicit
+      unordered_map(size_type __n,
+      const hasher& __hf = hasher(),
+      const key_equal& __eql = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+# 171 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename _InputIterator>
+ unordered_map(_InputIterator __first, _InputIterator __last,
+        size_type __n = 0,
+        const hasher& __hf = hasher(),
+        const key_equal& __eql = key_equal(),
+        const allocator_type& __a = allocator_type())
+ : _M_h(__first, __last, __n, __hf, __eql, __a)
+ { }
+
+
+      unordered_map(const unordered_map&) = default;
+
+
+      unordered_map(unordered_map&&) = default;
+
+
+
+
+
+      explicit
+      unordered_map(const allocator_type& __a)
+ : _M_h(__a)
+      { }
+
+
+
+
+
+
+      unordered_map(const unordered_map& __umap,
+      const allocator_type& __a)
+      : _M_h(__umap._M_h, __a)
+      { }
+
+
+
+
+
+
+      unordered_map(unordered_map&& __umap,
+      const allocator_type& __a)
+      : _M_h(std::move(__umap._M_h), __a)
+      { }
+# 226 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_map(initializer_list<value_type> __l,
+      size_type __n = 0,
+      const hasher& __hf = hasher(),
+      const key_equal& __eql = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : _M_h(__l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_map(size_type __n, const allocator_type& __a)
+      : unordered_map(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(size_type __n, const hasher& __hf,
+      const allocator_type& __a)
+      : unordered_map(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+ unordered_map(_InputIterator __first, _InputIterator __last,
+        size_type __n,
+        const allocator_type& __a)
+ : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
+ { }
+
+      template<typename _InputIterator>
+ unordered_map(_InputIterator __first, _InputIterator __last,
+        size_type __n, const hasher& __hf,
+        const allocator_type& __a)
+   : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
+ { }
+
+      unordered_map(initializer_list<value_type> __l,
+      size_type __n,
+      const allocator_type& __a)
+      : unordered_map(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_map(initializer_list<value_type> __l,
+      size_type __n, const hasher& __hf,
+      const allocator_type& __a)
+      : unordered_map(__l, __n, __hf, key_equal(), __a)
+      { }
+
+
+      unordered_map&
+      operator=(const unordered_map&) = default;
+
+
+      unordered_map&
+      operator=(unordered_map&&) = default;
+# 288 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_map&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_h = __l;
+ return *this;
+      }
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+
+
+
+
+      bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+
+
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+# 385 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename... _Args>
+ std::pair<iterator, bool>
+ emplace(_Args&&... __args)
+ { return _M_h.emplace(std::forward<_Args>(__args)...); }
+# 416 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __pos, _Args&&... __args)
+ { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+# 578 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+
+
+
+      std::pair<iterator, bool>
+      insert(value_type&& __x)
+      { return _M_h.insert(std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value,
+        pair<iterator, bool>>
+ insert(_Pair&& __x)
+        { return _M_h.emplace(std::forward<_Pair>(__x)); }
+# 617 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+
+
+
+      iterator
+      insert(const_iterator __hint, value_type&& __x)
+      { return _M_h.insert(__hint, std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(const_iterator __hint, _Pair&& __x)
+ { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); }
+# 642 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_h.insert(__first, __last); }
+# 654 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+# 790 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+
+
+      iterator
+      erase(iterator __position)
+      { return _M_h.erase(__position); }
+# 812 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+# 830 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+# 854 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      swap(unordered_map& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+# 894 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+
+
+
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+# 918 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+# 936 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+# 960 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+# 982 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      mapped_type&
+      operator[](const key_type& __k)
+      { return _M_h[__k]; }
+
+      mapped_type&
+      operator[](key_type&& __k)
+      { return _M_h[std::move(__k)]; }
+# 999 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      mapped_type&
+      at(const key_type& __k)
+      { return _M_h.at(__k); }
+
+      const mapped_type&
+      at(const key_type& __k) const
+      { return _M_h.at(__k); }
+
+
+
+
+
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+
+
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+
+
+
+
+
+
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+
+
+
+
+
+
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+
+
+
+
+
+
+
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+# 1055 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+# 1070 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+# 1081 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+
+
+
+
+
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+
+
+
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+
+
+
+
+
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+# 1118 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+# 1129 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+
+      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
+        typename _Alloc1>
+        friend bool
+ operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&,
+     const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&);
+    };
+# 1245 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+  template<typename _Key, typename _Tp,
+    typename _Hash = hash<_Key>,
+    typename _Pred = equal_to<_Key>,
+    typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
+    class unordered_multimap
+    {
+      typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
+      _Hashtable _M_h;
+
+    public:
+
+
+
+      typedef typename _Hashtable::key_type key_type;
+      typedef typename _Hashtable::value_type value_type;
+      typedef typename _Hashtable::mapped_type mapped_type;
+      typedef typename _Hashtable::hasher hasher;
+      typedef typename _Hashtable::key_equal key_equal;
+      typedef typename _Hashtable::allocator_type allocator_type;
+
+
+
+
+      typedef typename _Hashtable::pointer pointer;
+      typedef typename _Hashtable::const_pointer const_pointer;
+      typedef typename _Hashtable::reference reference;
+      typedef typename _Hashtable::const_reference const_reference;
+      typedef typename _Hashtable::iterator iterator;
+      typedef typename _Hashtable::const_iterator const_iterator;
+      typedef typename _Hashtable::local_iterator local_iterator;
+      typedef typename _Hashtable::const_local_iterator const_local_iterator;
+      typedef typename _Hashtable::size_type size_type;
+      typedef typename _Hashtable::difference_type difference_type;
+# 1287 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_multimap() = default;
+# 1296 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      explicit
+      unordered_multimap(size_type __n,
+    const hasher& __hf = hasher(),
+    const key_equal& __eql = key_equal(),
+    const allocator_type& __a = allocator_type())
+      : _M_h(__n, __hf, __eql, __a)
+      { }
+# 1317 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename _InputIterator>
+ unordered_multimap(_InputIterator __first, _InputIterator __last,
+      size_type __n = 0,
+      const hasher& __hf = hasher(),
+      const key_equal& __eql = key_equal(),
+      const allocator_type& __a = allocator_type())
+ : _M_h(__first, __last, __n, __hf, __eql, __a)
+ { }
+
+
+      unordered_multimap(const unordered_multimap&) = default;
+
+
+      unordered_multimap(unordered_multimap&&) = default;
+
+
+
+
+
+      explicit
+      unordered_multimap(const allocator_type& __a)
+      : _M_h(__a)
+      { }
+
+
+
+
+
+
+      unordered_multimap(const unordered_multimap& __ummap,
+    const allocator_type& __a)
+      : _M_h(__ummap._M_h, __a)
+      { }
+
+
+
+
+
+
+      unordered_multimap(unordered_multimap&& __ummap,
+    const allocator_type& __a)
+      : _M_h(std::move(__ummap._M_h), __a)
+      { }
+# 1372 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_multimap(initializer_list<value_type> __l,
+    size_type __n = 0,
+    const hasher& __hf = hasher(),
+    const key_equal& __eql = key_equal(),
+    const allocator_type& __a = allocator_type())
+      : _M_h(__l, __n, __hf, __eql, __a)
+      { }
+
+      unordered_multimap(size_type __n, const allocator_type& __a)
+      : unordered_multimap(__n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(size_type __n, const hasher& __hf,
+    const allocator_type& __a)
+      : unordered_multimap(__n, __hf, key_equal(), __a)
+      { }
+
+      template<typename _InputIterator>
+ unordered_multimap(_InputIterator __first, _InputIterator __last,
+      size_type __n,
+      const allocator_type& __a)
+ : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
+ { }
+
+      template<typename _InputIterator>
+ unordered_multimap(_InputIterator __first, _InputIterator __last,
+      size_type __n, const hasher& __hf,
+      const allocator_type& __a)
+ : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
+ { }
+
+      unordered_multimap(initializer_list<value_type> __l,
+    size_type __n,
+    const allocator_type& __a)
+      : unordered_multimap(__l, __n, hasher(), key_equal(), __a)
+      { }
+
+      unordered_multimap(initializer_list<value_type> __l,
+    size_type __n, const hasher& __hf,
+    const allocator_type& __a)
+      : unordered_multimap(__l, __n, __hf, key_equal(), __a)
+      { }
+
+
+      unordered_multimap&
+      operator=(const unordered_multimap&) = default;
+
+
+      unordered_multimap&
+      operator=(unordered_multimap&&) = default;
+# 1434 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      unordered_multimap&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_h = __l;
+ return *this;
+      }
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return _M_h.get_allocator(); }
+
+
+
+
+      bool
+      empty() const noexcept
+      { return _M_h.empty(); }
+
+
+      size_type
+      size() const noexcept
+      { return _M_h.size(); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _M_h.max_size(); }
+
+
+
+
+
+
+
+      iterator
+      begin() noexcept
+      { return _M_h.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const noexcept
+      { return _M_h.begin(); }
+
+      const_iterator
+      cbegin() const noexcept
+      { return _M_h.begin(); }
+
+
+
+
+
+
+      iterator
+      end() noexcept
+      { return _M_h.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const noexcept
+      { return _M_h.end(); }
+
+      const_iterator
+      cend() const noexcept
+      { return _M_h.end(); }
+# 1526 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(_Args&&... __args)
+ { return _M_h.emplace(std::forward<_Args>(__args)...); }
+# 1553 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename... _Args>
+ iterator
+ emplace_hint(const_iterator __pos, _Args&&... __args)
+ { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
+# 1568 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      insert(const value_type& __x)
+      { return _M_h.insert(__x); }
+
+      iterator
+      insert(value_type&& __x)
+      { return _M_h.insert(std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(_Pair&& __x)
+        { return _M_h.emplace(std::forward<_Pair>(__x)); }
+# 1602 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      insert(const_iterator __hint, const value_type& __x)
+      { return _M_h.insert(__hint, __x); }
+
+
+
+      iterator
+      insert(const_iterator __hint, value_type&& __x)
+      { return _M_h.insert(__hint, std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(const_iterator __hint, _Pair&& __x)
+        { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); }
+# 1627 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_h.insert(__first, __last); }
+# 1640 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      insert(initializer_list<value_type> __l)
+      { _M_h.insert(__l); }
+# 1683 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      erase(const_iterator __position)
+      { return _M_h.erase(__position); }
+
+
+      iterator
+      erase(iterator __position)
+      { return _M_h.erase(__position); }
+# 1704 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_h.erase(__x); }
+# 1723 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_h.erase(__first, __last); }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      { _M_h.clear(); }
+# 1747 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      swap(unordered_multimap& __x)
+      noexcept( noexcept(_M_h.swap(__x._M_h)) )
+      { _M_h.swap(__x._M_h); }
+# 1789 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      hasher
+      hash_function() const
+      { return _M_h.hash_function(); }
+
+
+
+      key_equal
+      key_eq() const
+      { return _M_h.key_eq(); }
+# 1813 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_h.find(__x); }
+
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_h.find(__x); }
+
+
+
+
+
+
+
+      size_type
+      count(const key_type& __x) const
+      { return _M_h.count(__x); }
+# 1849 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_h.equal_range(__x); }
+
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_h.equal_range(__x); }
+
+
+
+
+
+      size_type
+      bucket_count() const noexcept
+      { return _M_h.bucket_count(); }
+
+
+      size_type
+      max_bucket_count() const noexcept
+      { return _M_h.max_bucket_count(); }
+
+
+
+
+
+
+      size_type
+      bucket_size(size_type __n) const
+      { return _M_h.bucket_size(__n); }
+
+
+
+
+
+
+      size_type
+      bucket(const key_type& __key) const
+      { return _M_h.bucket(__key); }
+
+
+
+
+
+
+
+      local_iterator
+      begin(size_type __n)
+      { return _M_h.begin(__n); }
+# 1905 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      const_local_iterator
+      begin(size_type __n) const
+      { return _M_h.begin(__n); }
+
+      const_local_iterator
+      cbegin(size_type __n) const
+      { return _M_h.cbegin(__n); }
+# 1920 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      local_iterator
+      end(size_type __n)
+      { return _M_h.end(__n); }
+# 1931 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      const_local_iterator
+      end(size_type __n) const
+      { return _M_h.end(__n); }
+
+      const_local_iterator
+      cend(size_type __n) const
+      { return _M_h.cend(__n); }
+
+
+
+
+
+      float
+      load_factor() const noexcept
+      { return _M_h.load_factor(); }
+
+
+
+      float
+      max_load_factor() const noexcept
+      { return _M_h.max_load_factor(); }
+
+
+
+
+
+      void
+      max_load_factor(float __z)
+      { _M_h.max_load_factor(__z); }
+# 1968 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      rehash(size_type __n)
+      { _M_h.rehash(__n); }
+# 1979 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+      void
+      reserve(size_type __n)
+      { _M_h.reserve(__n); }
+
+      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
+        typename _Alloc1>
+        friend bool
+ operator==(const unordered_multimap<_Key1, _Tp1,
+         _Hash1, _Pred1, _Alloc1>&,
+     const unordered_multimap<_Key1, _Tp1,
+         _Hash1, _Pred1, _Alloc1>&);
+    };
+# 2074 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+  unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline void
+    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+  unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return __x._M_h._M_equal(__y._M_h); }
+
+
+  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    inline bool
+    operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+
+# 2168 "/usr/include/c++/10.2.0/bits/unordered_map.h" 3
+
+}
+# 48 "/usr/include/c++/10.2.0/unordered_map" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/erase_if.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/erase_if.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/erase_if.h" 3
+
+
+
+namespace std
+{
+
+
+
+
+
+
+  namespace __detail
+  {
+    template<typename _Container, typename _Predicate>
+      typename _Container::size_type
+      __erase_nodes_if(_Container& __cont, _Predicate __pred)
+      {
+ typename _Container::size_type __num = 0;
+ for (auto __iter = __cont.begin(), __last = __cont.end();
+      __iter != __last;)
+   {
+     if (__pred(*__iter))
+       {
+  __iter = __cont.erase(__iter);
+  ++__num;
+       }
+     else
+       ++__iter;
+   }
+ return __num;
+      }
+  }
+
+
+}
+# 50 "/usr/include/c++/10.2.0/unordered_map" 2 3
+# 18 "/home/ted/dev/openrct2/src/openrct2/GameState.h" 2
+
+
+# 19 "/home/ted/dev/openrct2/src/openrct2/GameState.h"
+namespace OpenRCT2
+{
+    class Park;
+
+
+    enum class LogicTimePart
+    {
+        NetworkUpdate,
+        Date,
+        Scenario,
+        Climate,
+        MapTiles,
+        MapStashProvisionalElements,
+        MapPathWideFlags,
+        Peep,
+        MapRestoreProvisionalElements,
+        Vehicle,
+        Misc,
+        Ride,
+        Park,
+        Research,
+        RideRatings,
+        RideMeasurments,
+        News,
+        MapAnimation,
+        Sounds,
+        GameActions,
+        NetworkFlush,
+        Scripts,
+    };
+
+
+    constexpr size_t LOGIC_UPDATE_MEASUREMENTS_COUNT = 256;
+
+
+    using LogicTimingInfo = std::unordered_map<
+        LogicTimePart, std::array<std::chrono::duration<double>, LOGIC_UPDATE_MEASUREMENTS_COUNT>>;
+
+    struct LogicTimings
+    {
+        LogicTimingInfo TimingInfo;
+        size_t CurrentIdx{};
+    };
+
+
+
+
+    class GameState final
+    {
+    private:
+        std::unique_ptr<Park> _park;
+        Date _date;
+
+    public:
+        GameState();
+        GameState(const GameState&) = delete;
+
+        Date& GetDate()
+        {
+            return _date;
+        }
+        Park& GetPark()
+        {
+            return *_park;
+        }
+
+        void InitAll(int32_t mapSize);
+        void Update();
+        void UpdateLogic(LogicTimings* timings = nullptr);
+
+    private:
+        void CreateStateSnapshot();
+    };
+}
+# 15 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/OpenRCT2.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/OpenRCT2.h"
+       
+
+
+
+
+
+enum class PromptMode : uint8_t;
+
+enum class StartupAction
+{
+    None,
+    Intro,
+    Title,
+    Open,
+    Edit
+};
+
+enum
+{
+
+
+    SCREEN_FLAGS_PLAYING = 0,
+    SCREEN_FLAGS_TITLE_DEMO = 1,
+    SCREEN_FLAGS_SCENARIO_EDITOR = 2,
+    SCREEN_FLAGS_TRACK_DESIGNER = 4,
+    SCREEN_FLAGS_TRACK_MANAGER = 8,
+    SCREEN_FLAGS_EDITOR = (SCREEN_FLAGS_SCENARIO_EDITOR | SCREEN_FLAGS_TRACK_DESIGNER | SCREEN_FLAGS_TRACK_MANAGER),
+};
+
+extern StartupAction gOpenRCT2StartupAction;
+extern utf8 gOpenRCT2StartupActionPath[512];
+extern utf8 gCustomUserDataPath[260];
+extern utf8 gCustomOpenRCT2DataPath[260];
+extern utf8 gCustomRCT1DataPath[260];
+extern utf8 gCustomRCT2DataPath[260];
+extern utf8 gCustomPassword[260];
+extern bool gOpenRCT2Headless;
+extern bool gOpenRCT2NoGraphics;
+extern bool gOpenRCT2ShowChangelog;
+extern bool gOpenRCT2SilentBreakpad;
+extern utf8 gSilentRecordingName[260];
+
+
+extern int32_t gNetworkStart;
+extern std::string gNetworkStartHost;
+extern int32_t gNetworkStartPort;
+extern std::string gNetworkStartAddress;
+
+
+extern uint32_t gCurrentDrawCount;
+extern uint8_t gScreenFlags;
+extern uint32_t gScreenAge;
+extern PromptMode gSavePromptMode;
+
+void openrct2_write_full_version_info(utf8* buffer, size_t bufferSize);
+void openrct2_finish();
+
+int32_t cmdline_run(const char** argv, int32_t argc);
+# 16 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/ParkImporter.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/ParkImporter.h"
+       
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/String.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/String.hpp"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/String.hpp" 2
+
+# 1 "/usr/include/c++/10.2.0/cstdarg" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdarg" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdarg" 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdarg.h" 1 3 4
+# 44 "/usr/include/c++/10.2.0/cstdarg" 2 3
+# 53 "/usr/include/c++/10.2.0/cstdarg" 3
+
+# 53 "/usr/include/c++/10.2.0/cstdarg" 3
+namespace std
+{
+  using ::va_list;
+}
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/String.hpp" 2
+
+# 1 "/usr/include/c++/10.2.0/optional" 1 3
+# 32 "/usr/include/c++/10.2.0/optional" 3
+       
+# 33 "/usr/include/c++/10.2.0/optional" 3
+# 17 "/home/ted/dev/openrct2/src/openrct2/core/String.hpp" 2
+
+
+
+
+# 20 "/home/ted/dev/openrct2/src/openrct2/core/String.hpp"
+namespace CODE_PAGE
+{
+
+
+
+    constexpr int32_t CP_932 = 932;
+    constexpr int32_t CP_936 = 936;
+    constexpr int32_t CP_949 = 949;
+    constexpr int32_t CP_950 = 950;
+    constexpr int32_t CP_1252 = 1252;
+    constexpr int32_t CP_UTF8 = 65001;
+}
+
+namespace String
+{
+    constexpr const utf8* Empty = "";
+
+    std::string ToStd(const utf8* str);
+    std::string StdFormat_VA(const utf8* format, va_list args);
+    std::string StdFormat(const utf8* format, ...);
+    std::string ToUtf8(std::wstring_view src);
+    std::wstring ToWideChar(std::string_view src);
+
+
+
+
+
+    std::string_view ToStringView(const char* ch, size_t maxLen);
+
+    bool IsNullOrEmpty(const utf8* str);
+    int32_t Compare(const std::string& a, const std::string& b, bool ignoreCase = false);
+    int32_t Compare(const utf8* a, const utf8* b, bool ignoreCase = false);
+    bool Equals(std::string_view a, std::string_view b, bool ignoreCase = false);
+    bool Equals(const std::string& a, const std::string& b, bool ignoreCase = false);
+    bool Equals(const utf8* a, const utf8* b, bool ignoreCase = false);
+    bool StartsWith(std::string_view str, std::string_view match, bool ignoreCase = false);
+    bool EndsWith(std::string_view str, std::string_view match, bool ignoreCase = false);
+    size_t IndexOf(const utf8* str, utf8 match, size_t startIndex = 0);
+    ptrdiff_t LastIndexOf(const utf8* str, utf8 match);
+
+
+
+
+    size_t LengthOf(const utf8* str);
+
+
+
+
+    size_t SizeOf(const utf8* str);
+
+    utf8* Set(utf8* buffer, size_t bufferSize, const utf8* src);
+    utf8* Set(utf8* buffer, size_t bufferSize, const utf8* src, size_t srcSize);
+    utf8* Append(utf8* buffer, size_t bufferSize, const utf8* src);
+    utf8* Format(utf8* buffer, size_t bufferSize, const utf8* format, ...);
+    utf8* Format(const utf8* format, ...);
+    utf8* Format_VA(const utf8* format, va_list args);
+    utf8* AppendFormat(utf8* buffer, size_t bufferSize, const utf8* format, ...);
+    utf8* Duplicate(const std::string& src);
+    utf8* Duplicate(const utf8* src);
+
+
+
+
+    utf8* DiscardUse(utf8** ptr, utf8* replacement);
+
+
+
+
+    utf8* DiscardDuplicate(utf8** ptr, const utf8* replacement);
+
+
+
+
+
+    std::vector<std::string> Split(std::string_view s, std::string_view delimiter);
+
+    utf8* SkipBOM(utf8* buffer);
+    const utf8* SkipBOM(const utf8* buffer);
+
+    size_t GetCodepointLength(codepoint_t codepoint);
+    codepoint_t GetNextCodepoint(utf8* ptr, utf8** nextPtr = nullptr);
+    codepoint_t GetNextCodepoint(const utf8* ptr, const utf8** nextPtr = nullptr);
+    utf8* WriteCodepoint(utf8* dst, codepoint_t codepoint);
+    void AppendCodepoint(std::string& str, codepoint_t codepoint);
+
+    bool IsWhiteSpace(codepoint_t codepoint);
+    utf8* Trim(utf8* str);
+    const utf8* TrimStart(const utf8* str);
+    utf8* TrimStart(utf8* buffer, size_t bufferSize, const utf8* src);
+    std::string TrimStart(const std::string& s);
+    std::string Trim(const std::string& s);
+
+
+
+
+    std::string Convert(std::string_view src, int32_t srcCodePage, int32_t dstCodePage);
+
+
+
+
+    std::string ToUpper(std::string_view src);
+
+    template<typename T> std::optional<T> Parse(std::string_view input)
+    {
+        if (input.size() == 0)
+            return std::nullopt;
+
+        T result = 0;
+        for (size_t i = 0; i < input.size(); i++)
+        {
+            auto chr = input[i];
+            if (chr >= '0' && chr <= '9')
+            {
+                auto digit = chr - '0';
+                auto last = result;
+                result = static_cast<T>((result * 10) + digit);
+                if (result <= last)
+                {
+
+                    return std::nullopt;
+                }
+            }
+            else
+            {
+
+                return std::nullopt;
+            }
+        }
+        return result;
+    }
+
+
+
+
+    constexpr std::optional<int> UTF8GetCodePointSize(std::string_view v)
+    {
+        if (v.size() >= 1 && !(v[0] & 0x80))
+        {
+            return { 1 };
+        }
+        else if (v.size() >= 2 && ((v[0] & 0xE0) == 0xC0))
+        {
+            return { 2 };
+        }
+        else if (v.size() >= 3 && ((v[0] & 0xF0) == 0xE0))
+        {
+            return { 3 };
+        }
+        else if (v.size() >= 4 && ((v[0] & 0xF8) == 0xF0))
+        {
+            return { 4 };
+        }
+        return {};
+    }
+
+
+
+
+
+    std::string_view UTF8Truncate(std::string_view v, size_t size);
+
+}
+
+class CodepointView
+{
+private:
+    std::string_view _str;
+
+public:
+    class iterator
+    {
+    private:
+        std::string_view _str;
+        size_t _index;
+
+    public:
+        iterator(std::string_view str, size_t index)
+            : _str(str)
+            , _index(index)
+        {
+        }
+
+        bool operator==(const iterator& rhs) const
+        {
+            return _index == rhs._index;
+        }
+        bool operator!=(const iterator& rhs) const
+        {
+            return _index != rhs._index;
+        }
+        char32_t operator*() const
+        {
+            return GetNextCodepoint(&_str[_index], nullptr);
+        }
+        iterator& operator++()
+        {
+            if (_index < _str.size())
+            {
+                const utf8* nextch;
+                GetNextCodepoint(&_str[_index], &nextch);
+                _index = nextch - _str.data();
+            }
+            return *this;
+        }
+        iterator operator++(int)
+        {
+            auto result = *this;
+            if (_index < _str.size())
+            {
+                const utf8* nextch;
+                GetNextCodepoint(&_str[_index], &nextch);
+                _index = nextch - _str.data();
+            }
+            return result;
+        }
+
+        size_t GetIndex() const
+        {
+            return _index;
+        }
+
+        static char32_t GetNextCodepoint(const char* ch, const char** next);
+    };
+
+    CodepointView(std::string_view str)
+        : _str(str)
+    {
+    }
+
+    iterator begin() const
+    {
+        return iterator(_str, 0);
+    }
+
+    iterator end() const
+    {
+        return iterator(_str, _str.size());
+    }
+};
+# 14 "/home/ted/dev/openrct2/src/openrct2/ParkImporter.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/Object.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/Object.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/Object.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../core/JsonFwd.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../core/JsonFwd.hpp"
+       
+
+# 1 "/usr/include/nlohmann/json_fwd.hpp" 1 3 4
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/map" 1 3 4
+# 58 "/usr/include/c++/10.2.0/map" 3 4
+       
+# 59 "/usr/include/c++/10.2.0/map" 3
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_tree.h" 1 3
+# 61 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+       
+# 62 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+# 75 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+
+# 75 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 99 "/usr/include/c++/10.2.0/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 _Key_compare>
+    struct _Rb_tree_key_compare
+    {
+      _Key_compare _M_key_compare;
+
+      _Rb_tree_key_compare()
+      noexcept(is_nothrow_default_constructible<_Key_compare>::value)
+
+      : _M_key_compare()
+      { }
+
+      _Rb_tree_key_compare(const _Key_compare& __comp)
+      : _M_key_compare(__comp)
+      { }
+
+
+
+      _Rb_tree_key_compare(const _Rb_tree_key_compare&) = default;
+
+      _Rb_tree_key_compare(_Rb_tree_key_compare&& __x)
+ noexcept(is_nothrow_copy_constructible<_Key_compare>::value)
+      : _M_key_compare(__x._M_key_compare)
+      { }
+
+    };
+
+
+  struct _Rb_tree_header
+  {
+    _Rb_tree_node_base _M_header;
+    size_t _M_node_count;
+
+    _Rb_tree_header() noexcept
+    {
+      _M_header._M_color = _S_red;
+      _M_reset();
+    }
+
+
+    _Rb_tree_header(_Rb_tree_header&& __x) noexcept
+    {
+      if (__x._M_header._M_parent != nullptr)
+ _M_move_data(__x);
+      else
+ {
+   _M_header._M_color = _S_red;
+   _M_reset();
+ }
+    }
+
+
+    void
+    _M_move_data(_Rb_tree_header& __from)
+    {
+      _M_header._M_color = __from._M_header._M_color;
+      _M_header._M_parent = __from._M_header._M_parent;
+      _M_header._M_left = __from._M_header._M_left;
+      _M_header._M_right = __from._M_header._M_right;
+      _M_header._M_parent->_M_parent = &_M_header;
+      _M_node_count = __from._M_node_count;
+
+      __from._M_reset();
+    }
+
+    void
+    _M_reset()
+    {
+      _M_header._M_parent = 0;
+      _M_header._M_left = &_M_header;
+      _M_header._M_right = &_M_header;
+      _M_node_count = 0;
+    }
+  };
+
+  template<typename _Val>
+    struct _Rb_tree_node : public _Rb_tree_node_base
+    {
+      typedef _Rb_tree_node<_Val>* _Link_type;
+# 231 "/usr/include/c++/10.2.0/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;
+      }
+
+      friend bool
+      operator==(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node == __y._M_node; }
+
+
+      friend bool
+      operator!=(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node != __y._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;
+      }
+
+      friend bool
+      operator==(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node == __y._M_node; }
+
+
+      friend bool
+      operator!=(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node != __y._M_node; }
+
+
+      _Base_ptr _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 _Cmp, typename _SfinaeType, typename = __void_t<>>
+    struct __has_is_transparent
+    { };
+
+  template<typename _Cmp, typename _SfinaeType>
+    struct __has_is_transparent<_Cmp, _SfinaeType,
+    __void_t<typename _Cmp::is_transparent>>
+    { typedef void type; };
+
+  template<typename _Cmp, typename _SfinaeType>
+    using __has_is_transparent_t
+      = typename __has_is_transparent<_Cmp, _SfinaeType>::type;
+
+
+
+
+
+
+
+  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 this->_M_impl; }
+
+      const _Node_allocator&
+      _M_get_Node_allocator() const noexcept
+      { return 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); }
+# 611 "/usr/include/c++/10.2.0/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
+ , public _Rb_tree_key_compare<_Key_compare>
+ , public _Rb_tree_header
+ {
+   typedef _Rb_tree_key_compare<_Key_compare> _Base_key_compare;
+
+   _Rb_tree_impl()
+     noexcept(is_nothrow_default_constructible<_Node_allocator>::value && is_nothrow_default_constructible<_Base_key_compare>::value)
+
+
+   : _Node_allocator()
+   { }
+
+   _Rb_tree_impl(const _Rb_tree_impl& __x)
+   : _Node_allocator(_Alloc_traits::_S_select_on_copy(__x))
+   , _Base_key_compare(__x._M_key_compare)
+   { }
+
+
+
+
+
+
+   _Rb_tree_impl(_Rb_tree_impl&&) = default;
+
+   explicit
+   _Rb_tree_impl(_Node_allocator&& __a)
+   : _Node_allocator(std::move(__a))
+   { }
+
+   _Rb_tree_impl(_Rb_tree_impl&& __x, _Node_allocator&& __a)
+   : _Node_allocator(std::move(__a)),
+     _Base_key_compare(std::move(__x)),
+     _Rb_tree_header(std::move(__x))
+   { }
+
+   _Rb_tree_impl(const _Key_compare& __comp, _Node_allocator&& __a)
+   : _Node_allocator(std::move(__a)), _Base_key_compare(__comp)
+   { }
+
+ };
+
+      _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);
+      }
+
+      _Base_ptr
+      _M_end() noexcept
+      { return &this->_M_impl._M_header; }
+
+      _Const_Base_ptr
+      _M_end() const noexcept
+      { return &this->_M_impl._M_header; }
+
+      static const _Key&
+      _S_key(_Const_Link_type __x)
+      {
+
+
+
+ static_assert(__is_invocable<_Compare&, const _Key&, const _Key&>{},
+        "comparison object must be invocable "
+        "with two arguments of key type");
+# 785 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+ return _KeyOfValue()(*__x->_M_valptr());
+      }
+
+      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 _Key&
+      _S_key(_Const_Base_ptr __x)
+      { return _S_key(static_cast<_Const_Link_type>(__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;
+# 838 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+      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);
+
+    private:
+
+      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);
+# 889 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+      template<typename _NodeGen>
+ _Link_type
+ _M_copy(_Const_Link_type __x, _Base_ptr __p, _NodeGen&);
+
+      template<typename _NodeGen>
+ _Link_type
+ _M_copy(const _Rb_tree& __x, _NodeGen& __gen)
+ {
+   _Link_type __root = _M_copy(__x._M_begin(), _M_end(), __gen);
+   _M_leftmost() = _S_minimum(__root);
+   _M_rightmost() = _S_maximum(__root);
+   _M_impl._M_node_count = __x._M_impl._M_node_count;
+   return __root;
+ }
+
+      _Link_type
+      _M_copy(const _Rb_tree& __x)
+      {
+ _Alloc_node __an(*this);
+ return _M_copy(__x, __an);
+      }
+
+      void
+      _M_erase(_Link_type __x);
+
+      iterator
+      _M_lower_bound(_Link_type __x, _Base_ptr __y,
+       const _Key& __k);
+
+      const_iterator
+      _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
+       const _Key& __k) const;
+
+      iterator
+      _M_upper_bound(_Link_type __x, _Base_ptr __y,
+       const _Key& __k);
+
+      const_iterator
+      _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
+       const _Key& __k) const;
+
+    public:
+
+
+
+
+      _Rb_tree() = default;
+
+
+      _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)
+      {
+ if (__x._M_root() != 0)
+   _M_root() = _M_copy(__x);
+      }
+
+
+      _Rb_tree(const allocator_type& __a)
+      : _M_impl(_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);
+      }
+
+      _Rb_tree(_Rb_tree&&) = default;
+
+      _Rb_tree(_Rb_tree&& __x, const allocator_type& __a)
+      : _Rb_tree(std::move(__x), _Node_allocator(__a))
+      { }
+
+    private:
+      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, true_type)
+      noexcept(is_nothrow_default_constructible<_Compare>::value)
+      : _M_impl(std::move(__x._M_impl), std::move(__a))
+      { }
+
+      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, false_type)
+      : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
+      {
+ if (__x._M_root() != nullptr)
+   _M_move_data(__x, false_type{});
+      }
+
+    public:
+      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
+      noexcept( noexcept(
+ _Rb_tree(std::declval<_Rb_tree&&>(), std::declval<_Node_allocator&&>(),
+   std::declval<typename _Alloc_traits::is_always_equal>())) )
+      : _Rb_tree(std::move(__x), std::move(__a),
+   typename _Alloc_traits::is_always_equal{})
+      { }
+
+
+      ~_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(__is_nothrow_swappable<_Compare>::value);
+
+
+
+      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);
+
+      template<typename _Iter>
+ using __same_value_type
+   = is_same<value_type, typename iterator_traits<_Iter>::value_type>;
+
+      template<typename _InputIterator>
+ __enable_if_t<__same_value_type<_InputIterator>::value>
+ _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
+ {
+   _Alloc_node __an(*this);
+   for (; __first != __last; ++__first)
+     _M_insert_unique_(end(), *__first, __an);
+ }
+
+      template<typename _InputIterator>
+ __enable_if_t<!__same_value_type<_InputIterator>::value>
+ _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
+ {
+   for (; __first != __last; ++__first)
+     _M_emplace_unique(*__first);
+ }
+
+      template<typename _InputIterator>
+ __enable_if_t<__same_value_type<_InputIterator>::value>
+ _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
+ {
+   _Alloc_node __an(*this);
+   for (; __first != __last; ++__first)
+     _M_insert_equal_(end(), *__first, __an);
+ }
+
+      template<typename _InputIterator>
+ __enable_if_t<!__same_value_type<_InputIterator>::value>
+ _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
+ {
+   _Alloc_node __an(*this);
+   for (; __first != __last; ++__first)
+     _M_emplace_equal(*__first);
+ }
+# 1186 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+    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;
+      }
+# 1235 "/usr/include/c++/10.2.0/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();
+      }
+# 1258 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+      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 _Kt,
+        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
+ iterator
+ _M_find_tr(const _Kt& __k)
+ {
+   const _Rb_tree* __const_this = this;
+   return __const_this->_M_find_tr(__k)._M_const_cast();
+ }
+
+      template<typename _Kt,
+        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
+ const_iterator
+ _M_find_tr(const _Kt& __k) const
+ {
+   auto __j = _M_lower_bound_tr(__k);
+   if (__j != end() && _M_impl._M_key_compare(__k, _S_key(__j._M_node)))
+     __j = end();
+   return __j;
+ }
+
+      template<typename _Kt,
+        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
+ 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 = __has_is_transparent_t<_Compare, _Kt>>
+ iterator
+ _M_lower_bound_tr(const _Kt& __k)
+ {
+   const _Rb_tree* __const_this = this;
+   return __const_this->_M_lower_bound_tr(__k)._M_const_cast();
+ }
+
+      template<typename _Kt,
+        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
+ const_iterator
+ _M_lower_bound_tr(const _Kt& __k) const
+ {
+   auto __x = _M_begin();
+   auto __y = _M_end();
+   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 _Kt,
+        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
+ iterator
+ _M_upper_bound_tr(const _Kt& __k)
+ {
+   const _Rb_tree* __const_this = this;
+   return __const_this->_M_upper_bound_tr(__k)._M_const_cast();
+ }
+
+      template<typename _Kt,
+        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
+ const_iterator
+ _M_upper_bound_tr(const _Kt& __k) const
+ {
+   auto __x = _M_begin();
+   auto __y = _M_end();
+   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 _Kt,
+        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
+ pair<iterator, iterator>
+ _M_equal_range_tr(const _Kt& __k)
+ {
+   const _Rb_tree* __const_this = this;
+   auto __ret = __const_this->_M_equal_range_tr(__k);
+   return { __ret.first._M_const_cast(), __ret.second._M_const_cast() };
+ }
+
+      template<typename _Kt,
+        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
+ 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()
+        && is_nothrow_move_assignable<_Compare>::value);
+
+      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& __x, true_type)
+      { _M_impl._M_move_data(__x._M_impl); }
+
+
+
+      void
+      _M_move_data(_Rb_tree&, false_type);
+
+
+      void
+      _M_move_assign(_Rb_tree&, true_type);
+
+
+
+      void
+      _M_move_assign(_Rb_tree&, false_type);
+# 1610 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+      friend bool
+      operator==(const _Rb_tree& __x, const _Rb_tree& __y)
+      {
+ return __x.size() == __y.size()
+   && std::equal(__x.begin(), __x.end(), __y.begin());
+      }
+# 1627 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+      friend bool
+      operator<(const _Rb_tree& __x, const _Rb_tree& __y)
+      {
+ return std::lexicographical_compare(__x.begin(), __x.end(),
+         __y.begin(), __y.end());
+      }
+
+      friend bool __attribute__ ((__deprecated__))
+      operator!=(const _Rb_tree& __x, const _Rb_tree& __y)
+      { return !(__x == __y); }
+
+      friend bool __attribute__ ((__deprecated__))
+      operator>(const _Rb_tree& __x, const _Rb_tree& __y)
+      { return __y < __x; }
+
+      friend bool __attribute__ ((__deprecated__))
+      operator<=(const _Rb_tree& __x, const _Rb_tree& __y)
+      { return !(__y < __x); }
+
+      friend bool __attribute__ ((__deprecated__))
+      operator>=(const _Rb_tree& __x, const _Rb_tree& __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>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_move_data(_Rb_tree& __x, false_type)
+    {
+      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
+ _M_move_data(__x, 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, __lbd);
+ }
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+    typename _Compare, typename _Alloc>
+    inline void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_move_assign(_Rb_tree& __x, true_type)
+    {
+      clear();
+      if (__x._M_root() != nullptr)
+ _M_move_data(__x, true_type());
+      std::__alloc_on_move(_M_get_Node_allocator(),
+      __x._M_get_Node_allocator());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+    typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_move_assign(_Rb_tree& __x, false_type)
+    {
+      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
+ return _M_move_assign(__x, true_type{});
+
+
+
+      _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(__val));
+     };
+   _M_root() = _M_copy(__x, __lbd);
+   __x.clear();
+ }
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+    typename _Compare, typename _Alloc>
+    inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    operator=(_Rb_tree&& __x)
+    noexcept(_Alloc_traits::_S_nothrow_move()
+      && is_nothrow_move_assignable<_Compare>::value)
+    {
+      _M_impl._M_key_compare = std::move(__x._M_impl._M_key_compare);
+      _M_move_assign(__x, __bool_constant<_Alloc_traits::_S_nothrow_move()>());
+      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, __roan);
+ }
+
+      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();
+      _Base_ptr __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, _Base_ptr __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, _Base_ptr __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_Base_ptr __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, _Base_ptr __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_Base_ptr __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();
+      _Base_ptr __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);
+       _Base_ptr __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_Base_ptr __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);
+       _Const_Base_ptr __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& __t)
+    noexcept(__is_nothrow_swappable<_Compare>::value)
+    {
+      if (_M_root() == 0)
+ {
+   if (__t._M_root() != 0)
+     _M_impl._M_move_data(__t._M_impl);
+ }
+      else if (__t._M_root() == 0)
+ __t._M_impl._M_move_data(_M_impl);
+      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();
+      _Base_ptr __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();
+      _Base_ptr __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(__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(__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();
+      _Base_ptr __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(__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(__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 _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)
+   _M_erase_aux(__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();
+      _M_erase_aux(__p.first, __p.second);
+      return __old_size - size();
+    }
+
+  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;
+    }
+# 2641 "/usr/include/c++/10.2.0/bits/stl_tree.h" 3
+
+}
+# 61 "/usr/include/c++/10.2.0/map" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_map.h" 1 3
+# 66 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    class multimap;
+# 98 "/usr/include/c++/10.2.0/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:
+# 128 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+    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;
+# 185 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      map() = default;
+
+
+
+
+
+
+
+      explicit
+      map(const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a)) { }
+# 207 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      map(const map&) = default;
+
+
+
+
+
+
+
+      map(map&&) = default;
+# 228 "/usr/include/c++/10.2.0/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_range_unique(__l.begin(), __l.end()); }
+
+
+      explicit
+      map(const allocator_type& __a)
+      : _M_t(_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(_Pair_alloc_type(__a))
+      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }
+
+
+      template<typename _InputIterator>
+ map(_InputIterator __first, _InputIterator __last,
+     const allocator_type& __a)
+ : _M_t(_Pair_alloc_type(__a))
+ { _M_t._M_insert_range_unique(__first, __last); }
+# 272 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template<typename _InputIterator>
+ map(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+ { _M_t._M_insert_range_unique(__first, __last); }
+# 289 "/usr/include/c++/10.2.0/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_range_unique(__first, __last); }
+
+
+
+
+
+
+
+      ~map() = default;
+# 318 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      map&
+      operator=(const map&) = default;
+
+
+      map&
+      operator=(map&&) = default;
+# 336 "/usr/include/c++/10.2.0/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(); }
+# 491 "/usr/include/c++/10.2.0/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;
+      }
+# 536 "/usr/include/c++/10.2.0/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;
+      }
+# 574 "/usr/include/c++/10.2.0/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)...); }
+# 604 "/usr/include/c++/10.2.0/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)...);
+ }
+# 802 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_t._M_insert_unique(__x); }
+
+
+
+
+      std::pair<iterator, bool>
+      insert(value_type&& __x)
+      { return _M_t._M_insert_unique(std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair>::value,
+        pair<iterator, bool>>
+ insert(_Pair&& __x)
+ { return _M_t._M_emplace_unique(std::forward<_Pair>(__x)); }
+# 829 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      void
+      insert(std::initializer_list<value_type> __list)
+      { insert(__list.begin(), __list.end()); }
+# 858 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      iterator
+
+      insert(const_iterator __position, const value_type& __x)
+
+
+
+      { return _M_t._M_insert_unique_(__position, __x); }
+
+
+
+
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return _M_t._M_insert_unique_(__position, std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair>::value, iterator>
+ insert(const_iterator __position, _Pair&& __x)
+ {
+   return _M_t._M_emplace_hint_unique(__position,
+          std::forward<_Pair>(__x));
+ }
+# 891 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_t._M_insert_range_unique(__first, __last); }
+# 1030 "/usr/include/c++/10.2.0/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); }
+# 1067 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 1087 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+# 1121 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+      void
+      swap(map& __x)
+      noexcept(__is_nothrow_swappable<_Compare>::value)
+      { _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()); }
+# 1168 "/usr/include/c++/10.2.0/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); }
+# 1193 "/usr/include/c++/10.2.0/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); }
+# 1214 "/usr/include/c++/10.2.0/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_count_tr(__x); }
+# 1257 "/usr/include/c++/10.2.0/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(iterator(_M_t._M_lower_bound_tr(__x)))
+ { return iterator(_M_t._M_lower_bound_tr(__x)); }
+# 1282 "/usr/include/c++/10.2.0/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(const_iterator(_M_t._M_lower_bound_tr(__x)))
+ { return const_iterator(_M_t._M_lower_bound_tr(__x)); }
+# 1302 "/usr/include/c++/10.2.0/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(iterator(_M_t._M_upper_bound_tr(__x)))
+ { return iterator(_M_t._M_upper_bound_tr(__x)); }
+# 1322 "/usr/include/c++/10.2.0/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(const_iterator(_M_t._M_upper_bound_tr(__x)))
+ { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
+# 1351 "/usr/include/c++/10.2.0/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(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
+ { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }
+# 1380 "/usr/include/c++/10.2.0/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(pair<const_iterator, const_iterator>(
+       _M_t._M_equal_range_tr(__x)))
+ {
+   return pair<const_iterator, const_iterator>(
+       _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>&);
+
+    };
+# 1461 "/usr/include/c++/10.2.0/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; }
+# 1499 "/usr/include/c++/10.2.0/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)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+# 1565 "/usr/include/c++/10.2.0/bits/stl_map.h" 3
+
+}
+# 62 "/usr/include/c++/10.2.0/map" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 1 3
+# 64 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    class map;
+# 96 "/usr/include/c++/10.2.0/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:
+# 127 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+    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;
+# 182 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap() = default;
+
+
+
+
+
+
+
+      explicit
+      multimap(const _Compare& __comp,
+        const allocator_type& __a = allocator_type())
+      : _M_t(__comp, _Pair_alloc_type(__a)) { }
+# 204 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap(const multimap&) = default;
+# 213 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap(multimap&&) = default;
+# 225 "/usr/include/c++/10.2.0/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_range_equal(__l.begin(), __l.end()); }
+
+
+      explicit
+      multimap(const allocator_type& __a)
+      : _M_t(_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(_Pair_alloc_type(__a))
+      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }
+
+
+      template<typename _InputIterator>
+ multimap(_InputIterator __first, _InputIterator __last,
+   const allocator_type& __a)
+ : _M_t(_Pair_alloc_type(__a))
+ { _M_t._M_insert_range_equal(__first, __last); }
+# 268 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+ multimap(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+ { _M_t._M_insert_range_equal(__first, __last); }
+# 284 "/usr/include/c++/10.2.0/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_range_equal(__first, __last); }
+
+
+
+
+
+
+
+      ~multimap() = default;
+# 313 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      multimap&
+      operator=(const multimap&) = default;
+
+
+      multimap&
+      operator=(multimap&&) = default;
+# 331 "/usr/include/c++/10.2.0/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(); }
+# 489 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(_Args&&... __args)
+ { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
+# 516 "/usr/include/c++/10.2.0/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)...);
+ }
+# 538 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      iterator
+      insert(const value_type& __x)
+      { return _M_t._M_insert_equal(__x); }
+
+
+
+
+      iterator
+      insert(value_type&& __x)
+      { return _M_t._M_insert_equal(std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair>::value, iterator>
+ insert(_Pair&& __x)
+ { return _M_t._M_emplace_equal(std::forward<_Pair>(__x)); }
+# 577 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      iterator
+
+      insert(const_iterator __position, const value_type& __x)
+
+
+
+      { return _M_t._M_insert_equal_(__position, __x); }
+
+
+
+
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return _M_t._M_insert_equal_(__position, std::move(__x)); }
+
+      template<typename _Pair>
+ __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
+ insert(const_iterator __position, _Pair&& __x)
+ {
+   return _M_t._M_emplace_hint_equal(__position,
+         std::forward<_Pair>(__x));
+ }
+# 611 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+ void
+ insert(_InputIterator __first, _InputIterator __last)
+ { _M_t._M_insert_range_equal(__first, __last); }
+# 624 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      void
+      insert(initializer_list<value_type> __l)
+      { this->insert(__l.begin(), __l.end()); }
+# 701 "/usr/include/c++/10.2.0/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); }
+# 738 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 759 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      iterator
+      erase(const_iterator __first, const_iterator __last)
+      { return _M_t.erase(__first, __last); }
+# 796 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+      void
+      swap(multimap& __x)
+      noexcept(__is_nothrow_swappable<_Compare>::value)
+      { _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()); }
+# 842 "/usr/include/c++/10.2.0/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); }
+# 866 "/usr/include/c++/10.2.0/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); }
+# 884 "/usr/include/c++/10.2.0/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); }
+# 927 "/usr/include/c++/10.2.0/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(iterator(_M_t._M_lower_bound_tr(__x)))
+ { return iterator(_M_t._M_lower_bound_tr(__x)); }
+# 952 "/usr/include/c++/10.2.0/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(const_iterator(_M_t._M_lower_bound_tr(__x)))
+ { return const_iterator(_M_t._M_lower_bound_tr(__x)); }
+# 972 "/usr/include/c++/10.2.0/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(iterator(_M_t._M_upper_bound_tr(__x)))
+ { return iterator(_M_t._M_upper_bound_tr(__x)); }
+# 992 "/usr/include/c++/10.2.0/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(const_iterator(_M_t._M_upper_bound_tr(__x)))
+ { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
+# 1019 "/usr/include/c++/10.2.0/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(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
+ { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }
+# 1046 "/usr/include/c++/10.2.0/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(pair<const_iterator, const_iterator>(
+       _M_t._M_equal_range_tr(__x)))
+ {
+   return pair<const_iterator, const_iterator>(
+       _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>&);
+
+  };
+# 1126 "/usr/include/c++/10.2.0/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; }
+# 1164 "/usr/include/c++/10.2.0/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)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+# 1230 "/usr/include/c++/10.2.0/bits/stl_multimap.h" 3
+
+}
+# 63 "/usr/include/c++/10.2.0/map" 2 3
+# 6 "/usr/include/nlohmann/json_fwd.hpp" 2 3 4
+# 15 "/usr/include/nlohmann/json_fwd.hpp" 3 4
+namespace nlohmann
+{
+
+
+
+
+
+
+
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer,
+         class BinaryType = std::vector<std::uint8_t>>
+class basic_json;
+# 51 "/usr/include/nlohmann/json_fwd.hpp" 3 4
+template<typename BasicJsonType>
+class json_pointer;
+# 62 "/usr/include/nlohmann/json_fwd.hpp" 3 4
+using json = basic_json<>;
+
+template<class Key, class T, class IgnoredLess, class Allocator>
+struct ordered_map;
+# 74 "/usr/include/nlohmann/json_fwd.hpp" 3 4
+using ordered_json = basic_json<nlohmann::ordered_map>;
+
+}
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../core/JsonFwd.hpp" 2
+
+
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../core/JsonFwd.hpp"
+using json_t = nlohmann::json;
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/Object.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../util/Util.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../util/Util.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../util/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../util/Util.h" 2
+
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdio" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/../util/Util.h" 2
+# 1 "/usr/include/c++/10.2.0/ctime" 1 3
+# 39 "/usr/include/c++/10.2.0/ctime" 3
+       
+# 40 "/usr/include/c++/10.2.0/ctime" 3
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/../util/Util.h" 2
+
+
+
+
+int32_t squaredmetres_to_squaredfeet(int32_t squaredMetres);
+int32_t metres_to_feet(int32_t metres);
+int32_t mph_to_kmph(int32_t mph);
+int32_t mph_to_dmps(int32_t mph);
+
+bool filename_valid_characters(const utf8* filename);
+
+char* path_get_directory(const utf8* path);
+const char* path_get_filename(const utf8* path);
+const char* path_get_extension(const utf8* path);
+void path_set_extension(utf8* path, const utf8* newExtension, size_t size);
+void path_append_extension(utf8* path, const utf8* newExtension, size_t size);
+void path_remove_extension(utf8* path);
+void path_end_with_separator(utf8* path, size_t size);
+bool writeentirefile(const utf8* path, const void* buffer, size_t length);
+
+bool sse41_available();
+bool avx2_available();
+
+int32_t bitscanforward(int32_t source);
+int32_t bitscanforward(int64_t source);
+void bitcount_init();
+int32_t bitcount(uint32_t source);
+int32_t strcicmp(char const* a, char const* b);
+int32_t strlogicalcmp(char const* a, char const* b);
+utf8* safe_strtrunc(utf8* text, size_t size);
+char* safe_strcpy(char* destination, const char* source, size_t num);
+char* safe_strcat(char* destination, const char* source, size_t size);
+char* safe_strcat_path(char* destination, const char* source, size_t size);
+
+
+
+
+bool utf8_is_bom(const char* str);
+bool str_is_null_or_empty(const char* str);
+
+uint32_t util_rand();
+
+std::optional<std::vector<uint8_t>> util_zlib_deflate(const uint8_t* data, size_t data_in_size);
+uint8_t* util_zlib_inflate(const uint8_t* data, size_t data_in_size, size_t* data_out_size);
+bool util_gzip_compress(FILE* source, FILE* dest);
+
+int8_t add_clamp_int8_t(int8_t value, int8_t value_to_add);
+int16_t add_clamp_int16_t(int16_t value, int16_t value_to_add);
+int32_t add_clamp_int32_t(int32_t value, int32_t value_to_add);
+money32 add_clamp_money32(money32 value, money32 value_to_add);
+
+uint8_t lerp(uint8_t a, uint8_t b, float t);
+float flerp(float a, float b, float t);
+uint8_t soft_light(uint8_t a, uint8_t b);
+
+size_t strcatftime(char* buffer, size_t bufferSize, const char* format, const struct tm* tp);
+
+template<typename T>[[nodiscard]] constexpr uint64_t EnumToFlag(T v)
+{
+    static_assert(std::is_enum_v<T>);
+    return 1ULL << static_cast<std::underlying_type_t<T>>(v);
+}
+
+template<typename... T>[[nodiscard]] constexpr uint64_t EnumsToFlags(T... types)
+{
+    return (EnumToFlag(types) | ...);
+}
+
+template<typename TEnum> constexpr auto EnumValue(TEnum enumerator) noexcept
+{
+    return static_cast<std::underlying_type_t<TEnum>>(enumerator);
+}
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/Object.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/ImageTable.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/ImageTable.h"
+       
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../interface/Colour.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../interface/Colour.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../interface/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../interface/Colour.h" 2
+
+
+
+
+
+
+enum : colour_t
+{
+    COLOUR_BLACK,
+    COLOUR_GREY,
+    COLOUR_WHITE,
+    COLOUR_DARK_PURPLE,
+    COLOUR_LIGHT_PURPLE,
+    COLOUR_BRIGHT_PURPLE,
+    COLOUR_DARK_BLUE,
+    COLOUR_LIGHT_BLUE,
+    COLOUR_ICY_BLUE,
+    COLOUR_TEAL,
+    COLOUR_AQUAMARINE,
+    COLOUR_SATURATED_GREEN,
+    COLOUR_DARK_GREEN,
+    COLOUR_MOSS_GREEN,
+    COLOUR_BRIGHT_GREEN,
+    COLOUR_OLIVE_GREEN,
+    COLOUR_DARK_OLIVE_GREEN,
+    COLOUR_BRIGHT_YELLOW,
+    COLOUR_YELLOW,
+    COLOUR_DARK_YELLOW,
+    COLOUR_LIGHT_ORANGE,
+    COLOUR_DARK_ORANGE,
+    COLOUR_LIGHT_BROWN,
+    COLOUR_SATURATED_BROWN,
+    COLOUR_DARK_BROWN,
+    COLOUR_SALMON_PINK,
+    COLOUR_BORDEAUX_RED,
+    COLOUR_SATURATED_RED,
+    COLOUR_BRIGHT_RED,
+    COLOUR_DARK_PINK,
+    COLOUR_BRIGHT_PINK,
+    COLOUR_LIGHT_PINK,
+
+    COLOUR_COUNT
+};
+
+
+
+
+enum
+{
+    COLOUR_DARK_WATER = 9,
+    COLOUR_LIGHT_WATER = 10
+};
+
+enum : uint8_t
+{
+    PALETTE_INDEX_0 = 0,
+    PALETTE_INDEX_10 = 10,
+    PALETTE_INDEX_11 = 11,
+    PALETTE_INDEX_12 = 12,
+    PALETTE_INDEX_14 = 14,
+    PALETTE_INDEX_13 = 13,
+    PALETTE_INDEX_16 = 16,
+    PALETTE_INDEX_17 = 17,
+    PALETTE_INDEX_20 = 20,
+    PALETTE_INDEX_21 = 21,
+    PALETTE_INDEX_40 = 40,
+    PALETTE_INDEX_42 = 42,
+    PALETTE_INDEX_46 = 46,
+    PALETTE_INDEX_47 = 47,
+    PALETTE_INDEX_48 = 48,
+    PALETTE_INDEX_49 = 49,
+    PALETTE_INDEX_50 = 50,
+    PALETTE_INDEX_51 = 51,
+    PALETTE_INDEX_52 = 52,
+    PALETTE_INDEX_53 = 53,
+    PALETTE_INDEX_54 = 54,
+    PALETTE_INDEX_55 = 55,
+    PALETTE_INDEX_56 = 56,
+    PALETTE_INDEX_57 = 57,
+    PALETTE_INDEX_61 = 61,
+    PALETTE_INDEX_62 = 62,
+    PALETTE_INDEX_68 = 68,
+    PALETTE_INDEX_73 = 73,
+    PALETTE_INDEX_99 = 99,
+    PALETTE_INDEX_102 = 102,
+    PALETTE_INDEX_108 = 108,
+    PALETTE_INDEX_111 = 111,
+    PALETTE_INDEX_129 = 129,
+    PALETTE_INDEX_135 = 135,
+    PALETTE_INDEX_136 = 136,
+    PALETTE_INDEX_138 = 138,
+    PALETTE_INDEX_141 = 141,
+    PALETTE_INDEX_144 = 144,
+    PALETTE_INDEX_161 = 161,
+    PALETTE_INDEX_162 = 162,
+    PALETTE_INDEX_171 = 171,
+    PALETTE_INDEX_172 = 172,
+    PALETTE_INDEX_173 = 173,
+    PALETTE_INDEX_183 = 183,
+    PALETTE_INDEX_186 = 186,
+    PALETTE_INDEX_194 = 194,
+    PALETTE_INDEX_195 = 195,
+    PALETTE_INDEX_202 = 202,
+    PALETTE_INDEX_203 = 203,
+    PALETTE_INDEX_204 = 204,
+    PALETTE_INDEX_205 = 205,
+    PALETTE_INDEX_206 = 206,
+    PALETTE_INDEX_207 = 207,
+    PALETTE_INDEX_208 = 208,
+    PALETTE_INDEX_209 = 209,
+    PALETTE_INDEX_210 = 210,
+    PALETTE_INDEX_211 = 211,
+    PALETTE_INDEX_212 = 212,
+    PALETTE_INDEX_213 = 213,
+    PALETTE_INDEX_222 = 222,
+    PALETTE_INDEX_230 = 230,
+    PALETTE_INDEX_231 = 231,
+    PALETTE_INDEX_232 = 232,
+    PALETTE_INDEX_233 = 233,
+    PALETTE_INDEX_234 = 234,
+    PALETTE_INDEX_235 = 235,
+    PALETTE_INDEX_236 = 236,
+    PALETTE_INDEX_237 = 237,
+    PALETTE_INDEX_238 = 238,
+    PALETTE_INDEX_239 = 239,
+    PALETTE_INDEX_240 = 240,
+    PALETTE_INDEX_241 = 241,
+    PALETTE_INDEX_242 = 242,
+    PALETTE_INDEX_243 = 243,
+    PALETTE_INDEX_244 = 244,
+    PALETTE_INDEX_245 = 245,
+    PALETTE_INDEX_246 = 246,
+    PALETTE_INDEX_247 = 247,
+    PALETTE_INDEX_248 = 248,
+    PALETTE_INDEX_249 = 249,
+    PALETTE_INDEX_250 = 250,
+    PALETTE_INDEX_251 = 251,
+    PALETTE_INDEX_252 = 252,
+    PALETTE_INDEX_253 = 253,
+    PALETTE_INDEX_254 = 254,
+};
+
+constexpr size_t PALETTE_COUNT = 256;
+
+constexpr uint8_t PALETTE_OFFSET_DYNAMIC = PALETTE_INDEX_10;
+constexpr uint8_t PALETTE_LENGTH_DYNAMIC = 236;
+
+constexpr uint8_t PALETTE_OFFSET_WATER_WAVES = PALETTE_INDEX_230;
+constexpr uint8_t PALETTE_OFFSET_WATER_SPARKLES = PALETTE_INDEX_235;
+constexpr uint8_t PALETTE_LENGTH_WATER_WAVES = 5;
+constexpr uint8_t PALETTE_LENGTH_WATER_SPARKLES = 5;
+
+constexpr uint8_t PALETTE_OFFSET_TRACK_RAILS = PALETTE_INDEX_240;
+constexpr uint8_t PALETTE_LENGTH_TRACK_RAILS = 3;
+
+constexpr uint8_t PALETTE_OFFSET_REMAP_PRIMARY = PALETTE_INDEX_243;
+constexpr uint8_t PALETTE_OFFSET_REMAP_SECONDARY = PALETTE_INDEX_202;
+constexpr uint8_t PALETTE_OFFSET_REMAP_TERTIARY = PALETTE_INDEX_46;
+constexpr uint8_t PALETTE_LENGTH_REMAP = 12;
+
+constexpr uint8_t PALETTE_OFFSET_ANIMATED = PALETTE_INDEX_230;
+constexpr uint8_t PALETTE_LENGTH_ANIMATED = 16;
+
+
+
+
+enum
+{
+    COLOUR_FLAG_OUTLINE = (1 << 5),
+    COLOUR_FLAG_INSET = (1 << 6),
+    COLOUR_FLAG_TRANSLUCENT = (1 << 7),
+    COLOUR_FLAG_8 = (1 << 8)
+};
+
+
+
+
+
+struct rct_colour_map
+{
+    uint8_t colour_0;
+    uint8_t colour_1;
+    uint8_t darkest;
+    uint8_t darker;
+    uint8_t dark;
+    uint8_t mid_dark;
+    uint8_t mid_light;
+    uint8_t light;
+    uint8_t lighter;
+    uint8_t lightest;
+    uint8_t colour_10;
+    uint8_t colour_11;
+};
+
+extern rct_colour_map ColourMapA[COLOUR_COUNT];
+
+void colours_init_maps();
+
+namespace Colour
+{
+    colour_t FromString(std::string_view s, colour_t defaultValue = COLOUR_BLACK);
+}
+
+
+uint8_t blendColours(const uint8_t paletteIndex1, const uint8_t paletteIndex2);
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../interface/ZoomLevel.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../interface/ZoomLevel.h"
+       
+
+
+
+struct ZoomLevel
+{
+private:
+    int8_t _level{};
+
+public:
+    constexpr ZoomLevel() = default;
+
+    constexpr ZoomLevel(int8_t level)
+        : _level(level)
+    {
+    }
+
+    constexpr ZoomLevel(const ZoomLevel& rhs)
+        : _level(rhs._level)
+    {
+    }
+
+    explicit operator int8_t() const;
+    ZoomLevel operator++(int);
+    ZoomLevel& operator++();
+    ZoomLevel operator--(int);
+    ZoomLevel& operator--();
+    ZoomLevel& operator=(const ZoomLevel& other);
+    ZoomLevel& operator+=(const ZoomLevel& rhs);
+    ZoomLevel& operator-=(const ZoomLevel& rhs);
+
+    friend ZoomLevel operator+(ZoomLevel lhs, const ZoomLevel& rhs);
+    friend ZoomLevel operator-(ZoomLevel lhs, const ZoomLevel& rhs);
+    friend bool operator==(const ZoomLevel& lhs, const ZoomLevel& rhs);
+    friend bool operator!=(const ZoomLevel& lhs, const ZoomLevel& rhs);
+    friend bool operator>=(const ZoomLevel& lhs, const ZoomLevel& rhs);
+    friend bool operator<=(const ZoomLevel& lhs, const ZoomLevel& rhs);
+    friend bool operator>(const ZoomLevel& lhs, const ZoomLevel& rhs);
+    friend bool operator<(const ZoomLevel& lhs, const ZoomLevel& rhs);
+
+    template<typename T> friend T operator*(const T& lhs, const ZoomLevel& rhs)
+    {
+        if (rhs._level < 0)
+            return lhs >> -rhs._level;
+        else
+            return lhs << rhs._level;
+    }
+
+    template<typename T> friend T operator/(const T& lhs, const ZoomLevel& rhs)
+    {
+        if (rhs._level < 0)
+            return lhs << -rhs._level;
+        else
+            return lhs >> rhs._level;
+    }
+
+    static ZoomLevel min();
+
+    static constexpr ZoomLevel max()
+    {
+        return 3;
+    }
+};
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Font.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Font.h"
+constexpr const uint16_t FONT_SPRITE_GLYPH_COUNT = 224;
+
+enum
+{
+    FONT_SIZE_TINY = 2,
+    FONT_SIZE_SMALL = 0,
+    FONT_SIZE_MEDIUM = 1,
+    FONT_SIZE_COUNT = 3
+};
+
+enum class FontSpriteBase : int16_t
+{
+    MEDIUM_EXTRA_DARK = -2,
+    MEDIUM_DARK = -1,
+
+    TINY = FONT_SIZE_TINY * FONT_SPRITE_GLYPH_COUNT,
+    SMALL = FONT_SIZE_SMALL * FONT_SPRITE_GLYPH_COUNT,
+    MEDIUM = FONT_SIZE_MEDIUM * FONT_SPRITE_GLYPH_COUNT,
+};
+
+
+
+struct _TTF_Font;
+using TTF_Font = _TTF_Font;
+struct TTFFontDescriptor
+{
+    const utf8* filename;
+    const utf8* font_name;
+    int32_t ptSize;
+    int32_t offset_x;
+    int32_t offset_y;
+    int32_t line_height;
+    int32_t hinting_threshold;
+    TTF_Font* font;
+};
+
+struct TTFFontSetDescriptor
+{
+    TTFFontDescriptor size[FONT_SIZE_COUNT];
+};
+
+extern TTFFontSetDescriptor* gCurrentTTFFontSet;
+
+
+
+void font_sprite_initialise_characters();
+int32_t font_sprite_get_codepoint_offset(int32_t codepoint);
+int32_t font_sprite_get_codepoint_width(FontSpriteBase fontSpriteBase, int32_t codepoint);
+int32_t font_sprite_get_codepoint_sprite(FontSpriteBase fontSpriteBase, int32_t codepoint);
+int32_t font_get_font_index_from_sprite_base(FontSpriteBase spriteBase);
+int32_t font_get_size_from_sprite_base(FontSpriteBase spriteBase);
+int32_t font_get_line_height(FontSpriteBase fontSpriteBase);
+int32_t font_get_line_height_small(FontSpriteBase fontSpriteBase);
+bool font_supports_string_sprite(const utf8* text);
+bool font_supports_string_ttf(const utf8* text, int32_t fontSize);
+bool font_supports_string(const utf8* text, int32_t fontSize);
+# 18 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Text.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Text.h"
+       
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../localisation/Formatter.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../localisation/Formatter.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../localisation/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../localisation/Formatter.h" 2
+
+
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3
+# 39 "/usr/include/c++/10.2.0/cstring" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+
+
+# 1 "/usr/include/string.h" 1 3 4
+# 26 "/usr/include/string.h" 3 4
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 27 "/usr/include/string.h" 2 3 4
+
+
+# 28 "/usr/include/string.h" 3 4
+extern "C" {
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 34 "/usr/include/string.h" 2 3 4
+# 43 "/usr/include/string.h" 3 4
+extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
+       size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void *memmove (void *__dest, const void *__src, size_t __n)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
+        int __c, size_t __n)
+    noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__access__ (__write_only__, 1, 4)));
+
+
+
+
+extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern int memcmp (const void *__s1, const void *__s2, size_t __n)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern "C++"
+{
+extern void *memchr (void *__s, int __c, size_t __n)
+      noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const void *memchr (const void *__s, int __c, size_t __n)
+      noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 89 "/usr/include/string.h" 3 4
+}
+# 99 "/usr/include/string.h" 3 4
+extern "C++" void *rawmemchr (void *__s, int __c)
+     noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" const void *rawmemchr (const void *__s, int __c)
+     noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern "C++" void *memrchr (void *__s, int __c, size_t __n)
+      noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)))
+      __attribute__ ((__access__ (__read_only__, 1, 3)));
+extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
+      noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)))
+      __attribute__ ((__access__ (__read_only__, 1, 3)));
+# 125 "/usr/include/string.h" 3 4
+extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncpy (char *__restrict __dest,
+        const char *__restrict __src, size_t __n)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern char *strcat (char *__restrict __dest, const char *__restrict __src)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncat (char *__restrict __dest, const char *__restrict __src,
+        size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcmp (const char *__s1, const char *__s2)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int strncmp (const char *__s1, const char *__s2, size_t __n)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcoll (const char *__s1, const char *__s2)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern size_t strxfrm (char *__restrict __dest,
+         const char *__restrict __src, size_t __n)
+    noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 1, 3)));
+
+
+
+
+
+
+extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
+    locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4)))
+     __attribute__ ((__access__ (__write_only__, 1, 3)));
+
+
+
+
+
+extern char *strdup (const char *__s)
+     noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern char *strndup (const char *__string, size_t __n)
+     noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+# 208 "/usr/include/string.h" 3 4
+extern "C++"
+{
+extern char *strchr (char *__s, int __c)
+     noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const char *strchr (const char *__s, int __c)
+     noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 228 "/usr/include/string.h" 3 4
+}
+
+
+
+
+
+
+extern "C++"
+{
+extern char *strrchr (char *__s, int __c)
+     noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const char *strrchr (const char *__s, int __c)
+     noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 255 "/usr/include/string.h" 3 4
+}
+# 265 "/usr/include/string.h" 3 4
+extern "C++" char *strchrnul (char *__s, int __c)
+     noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" const char *strchrnul (const char *__s, int __c)
+     noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 277 "/usr/include/string.h" 3 4
+extern size_t strcspn (const char *__s, const char *__reject)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern size_t strspn (const char *__s, const char *__accept)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern "C++"
+{
+extern char *strpbrk (char *__s, const char *__accept)
+     noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern const char *strpbrk (const char *__s, const char *__accept)
+     noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 305 "/usr/include/string.h" 3 4
+}
+
+
+
+
+
+
+extern "C++"
+{
+extern char *strstr (char *__haystack, const char *__needle)
+     noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern const char *strstr (const char *__haystack, const char *__needle)
+     noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 332 "/usr/include/string.h" 3 4
+}
+
+
+
+
+
+
+
+extern char *strtok (char *__restrict __s, const char *__restrict __delim)
+     noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern char *__strtok_r (char *__restrict __s,
+    const char *__restrict __delim,
+    char **__restrict __save_ptr)
+     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));
+
+extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
+         char **__restrict __save_ptr)
+     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));
+
+
+
+
+
+extern "C++" char *strcasestr (char *__haystack, const char *__needle)
+     noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern "C++" const char *strcasestr (const char *__haystack,
+         const char *__needle)
+     noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 373 "/usr/include/string.h" 3 4
+extern void *memmem (const void *__haystack, size_t __haystacklen,
+       const void *__needle, size_t __needlelen)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)))
+    __attribute__ ((__access__ (__read_only__, 1, 2)))
+    __attribute__ ((__access__ (__read_only__, 3, 4)));
+
+
+
+extern void *__mempcpy (void *__restrict __dest,
+   const void *__restrict __src, size_t __n)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+extern void *mempcpy (void *__restrict __dest,
+        const void *__restrict __src, size_t __n)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern size_t strlen (const char *__s)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern size_t strnlen (const char *__string, size_t __maxlen)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern char *strerror (int __errnum) noexcept (true);
+# 428 "/usr/include/string.h" 3 4
+extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
+     noexcept (true) __attribute__ ((__nonnull__ (2))) __attribute__ ((__access__ (__write_only__, 2, 3)));
+
+
+
+
+extern const char *strerrordesc_np (int __err) noexcept (true);
+
+extern const char *strerrorname_np (int __err) noexcept (true);
+
+
+
+
+
+extern char *strerror_l (int __errnum, locale_t __l) noexcept (true);
+
+
+
+# 1 "/usr/include/strings.h" 1 3 4
+# 23 "/usr/include/strings.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stddef.h" 1 3 4
+# 24 "/usr/include/strings.h" 2 3 4
+
+
+
+
+
+
+extern "C" {
+
+
+
+extern int bcmp (const void *__s1, const void *__s2, size_t __n)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void bcopy (const void *__src, void *__dest, size_t __n)
+  noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+
+extern "C++"
+{
+extern char *index (char *__s, int __c)
+     noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const char *index (const char *__s, int __c)
+     noexcept (true) __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 66 "/usr/include/strings.h" 3 4
+}
+
+
+
+
+
+
+
+extern "C++"
+{
+extern char *rindex (char *__s, int __c)
+     noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern const char *rindex (const char *__s, int __c)
+     noexcept (true) __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+# 94 "/usr/include/strings.h" 3 4
+}
+# 104 "/usr/include/strings.h" 3 4
+extern int ffs (int __i) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+
+extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__));
+__extension__ extern int ffsll (long long int __ll)
+     noexcept (true) __attribute__ ((__const__));
+
+
+
+extern int strcasecmp (const char *__s1, const char *__s2)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+extern int strncasecmp_l (const char *__s1, const char *__s2,
+     size_t __n, locale_t __loc)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
+
+
+}
+# 447 "/usr/include/string.h" 2 3 4
+
+
+
+extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+extern char *strsep (char **__restrict __stringp,
+       const char *__restrict __delim)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern char *strsignal (int __sig) noexcept (true);
+
+
+
+extern const char *sigabbrev_np (int __sig) noexcept (true);
+
+
+extern const char *sigdescr_np (int __sig) noexcept (true);
+
+
+
+extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern char *__stpncpy (char *__restrict __dest,
+   const char *__restrict __src, size_t __n)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpncpy (char *__restrict __dest,
+        const char *__restrict __src, size_t __n)
+     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int strverscmp (const char *__s1, const char *__s2)
+     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1)));
+
+
+extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)))
+    __attribute__ ((__access__ (__write_only__, 1, 2)));
+
+
+
+
+
+
+
+extern "C++" char *basename (char *__filename)
+     noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1)));
+extern "C++" const char *basename (const char *__filename)
+     noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1)));
+# 523 "/usr/include/string.h" 3 4
+}
+# 43 "/usr/include/c++/10.2.0/cstring" 2 3
+# 71 "/usr/include/c++/10.2.0/cstring" 3
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  using ::memchr;
+  using ::memcmp;
+  using ::memcpy;
+  using ::memmove;
+  using ::memset;
+  using ::strcat;
+  using ::strcmp;
+  using ::strcoll;
+  using ::strcpy;
+  using ::strcspn;
+  using ::strerror;
+  using ::strlen;
+  using ::strncat;
+  using ::strncmp;
+  using ::strncpy;
+  using ::strspn;
+  using ::strtok;
+  using ::strxfrm;
+  using ::strchr;
+  using ::strpbrk;
+  using ::strrchr;
+  using ::strstr;
+# 122 "/usr/include/c++/10.2.0/cstring" 3
+
+}
+}
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../localisation/Formatter.h" 2
+
+
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/../localisation/Formatter.h"
+extern thread_local uint8_t gCommonFormatArgs[80];
+
+class Formatter
+{
+    std::array<uint8_t, 80> Buffer{};
+    uint8_t* StartBuf{};
+    uint8_t* CurrentBuf{};
+
+public:
+    explicit Formatter(uint8_t* buf)
+        : StartBuf(buf)
+        , CurrentBuf(buf)
+    {
+    }
+
+    Formatter()
+        : Buffer{}
+        , StartBuf(Buffer.data())
+        , CurrentBuf(StartBuf)
+    {
+    }
+
+    Formatter(const Formatter& other)
+    {
+        *this = other;
+    }
+
+    Formatter& operator=(const Formatter& other);
+
+    static Formatter Common();
+
+    auto Buf()
+    {
+        return CurrentBuf;
+    }
+
+    auto Data() const
+    {
+        return StartBuf;
+    }
+
+    void Increment(size_t count)
+    {
+        CurrentBuf += count;
+    }
+
+    void Rewind()
+    {
+        CurrentBuf -= NumBytes();
+    }
+
+    std::size_t NumBytes() const
+    {
+        return CurrentBuf - StartBuf;
+    }
+
+    template<typename TSpecified, typename TDeduced> Formatter& Add(TDeduced value)
+    {
+        static_assert(sizeof(TSpecified) <= sizeof(uintptr_t), "Type too large");
+        static_assert(sizeof(TDeduced) <= sizeof(uintptr_t), "Type too large");
+
+
+        static_assert(
+            std::is_same_v<TSpecified, char*> ||
+            std::is_same_v<TSpecified, const char*> ||
+            std::is_same_v<TSpecified, int16_t> ||
+            std::is_same_v<TSpecified, int32_t> ||
+            std::is_same_v<TSpecified, money32> ||
+            std::is_same_v<TSpecified, rct_string_id> ||
+            std::is_same_v<TSpecified, uint16_t> ||
+            std::is_same_v<TSpecified, uint32_t> ||
+            std::is_same_v<TSpecified, utf8*> ||
+            std::is_same_v<TSpecified, const utf8*>
+        );
+
+
+        uintptr_t convertedValue;
+        if constexpr (std::is_integral_v<TSpecified>)
+        {
+            convertedValue = static_cast<uintptr_t>(value);
+        }
+        else
+        {
+            convertedValue = reinterpret_cast<uintptr_t>(value);
+        }
+        std::memcpy(CurrentBuf, &convertedValue, sizeof(TSpecified));
+        Increment(sizeof(TSpecified));
+        return *this;
+    }
+};
+
+struct OpenRCT2String
+{
+    rct_string_id str;
+    Formatter args;
+};
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Text.h" 2
+
+
+struct ScreenCoordsXY;
+struct rct_drawpixelinfo;
+class Formatter;
+
+enum class TextAlignment
+{
+    LEFT,
+    CENTRE,
+    RIGHT
+};
+
+enum class TextUnderline
+{
+    Off,
+    On,
+};
+
+struct TextPaint
+{
+    colour_t Colour = COLOUR_BLACK;
+    FontSpriteBase SpriteBase = FontSpriteBase::MEDIUM;
+    TextUnderline UnderlineText = TextUnderline::Off;
+    TextAlignment Alignment = TextAlignment::LEFT;
+
+    TextPaint()
+    {
+    }
+    TextPaint(colour_t colour)
+        : Colour(colour)
+    {
+    }
+    TextPaint(FontSpriteBase spriteBase)
+        : SpriteBase(spriteBase)
+    {
+    }
+    TextPaint(TextUnderline underlineText)
+        : UnderlineText(underlineText)
+    {
+    }
+    TextPaint(TextAlignment alignment)
+        : Alignment(alignment)
+    {
+    }
+
+    TextPaint(colour_t colour, FontSpriteBase spriteBase)
+        : Colour(colour)
+        , SpriteBase(spriteBase)
+    {
+    }
+    TextPaint(colour_t colour, TextUnderline underlineText)
+        : Colour(colour)
+        , UnderlineText(underlineText)
+    {
+    }
+    TextPaint(colour_t colour, TextAlignment alignment)
+        : Colour(colour)
+        , Alignment(alignment)
+    {
+    }
+
+    TextPaint(FontSpriteBase spriteBase, TextUnderline underlineText)
+        : SpriteBase(spriteBase)
+        , UnderlineText(underlineText)
+    {
+    }
+    TextPaint(FontSpriteBase spriteBase, TextAlignment alignment)
+        : SpriteBase(spriteBase)
+        , Alignment(alignment)
+    {
+    }
+    TextPaint(TextUnderline underlineText, TextAlignment alignment)
+        : UnderlineText(underlineText)
+        , Alignment(alignment)
+    {
+    }
+
+    TextPaint(colour_t colour, FontSpriteBase spriteBase, TextUnderline underlineText)
+        : Colour(colour)
+        , SpriteBase(spriteBase)
+        , UnderlineText(underlineText)
+    {
+    }
+    TextPaint(colour_t colour, FontSpriteBase spriteBase, TextAlignment alignment)
+        : Colour(colour)
+        , SpriteBase(spriteBase)
+        , Alignment(alignment)
+    {
+    }
+    TextPaint(colour_t colour, TextUnderline underlineText, TextAlignment alignment)
+        : Colour(colour)
+        , UnderlineText(underlineText)
+        , Alignment(alignment)
+    {
+    }
+    TextPaint(FontSpriteBase spriteBase, TextUnderline underlineText, TextAlignment alignment)
+        : SpriteBase(spriteBase)
+        , UnderlineText(underlineText)
+        , Alignment(alignment)
+    {
+    }
+
+    TextPaint(colour_t colour, FontSpriteBase spriteBase, TextUnderline underlineText, TextAlignment alignment)
+        : Colour(colour)
+        , SpriteBase(spriteBase)
+        , UnderlineText(underlineText)
+        , Alignment(alignment)
+    {
+    }
+};
+
+class StaticLayout
+{
+private:
+    utf8string Buffer;
+    TextPaint Paint;
+    int32_t LineCount = 0;
+    int32_t LineHeight;
+    int32_t MaxWidth;
+
+    StaticLayout();
+    StaticLayout(const StaticLayout&);
+
+public:
+    StaticLayout(utf8string source, const TextPaint& paint, int32_t width);
+    void Draw(rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords);
+    int32_t GetHeight();
+    int32_t GetWidth();
+    int32_t GetLineCount();
+};
+
+void DrawTextBasic(
+    rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, rct_string_id format, const Formatter& ft = {},
+    TextPaint textPaint = {});
+void DrawTextBasic(
+    rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, rct_string_id format, const void* args, TextPaint textPaint = {});
+void DrawTextEllipsised(
+    rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, int32_t width, rct_string_id format, const Formatter& ft,
+    TextPaint textPaint = {});
+int32_t DrawTextWrapped(
+    rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, int32_t width, rct_string_id format, const Formatter& ft = {},
+    TextPaint textPaint = {});
+int32_t DrawTextWrapped(
+    rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, int32_t width, rct_string_id format, const void* args,
+    TextPaint textPaint = {});
+# 19 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 2
+
+
+
+
+
+struct ScreenCoordsXY;
+struct ScreenLine;
+struct ScreenRect;
+namespace OpenRCT2
+{
+    struct IPlatformEnvironment;
+}
+
+namespace OpenRCT2::Drawing
+{
+    struct IDrawingEngine;
+}
+
+struct PaletteBGRA
+{
+    uint8_t Blue{};
+    uint8_t Green{};
+    uint8_t Red{};
+    uint8_t Alpha{};
+};
+
+constexpr const auto PALETTE_SIZE = 256;
+
+struct GamePalette
+{
+    PaletteBGRA Colour[PALETTE_SIZE]{};
+
+    PaletteBGRA& operator[](uint16_t idx)
+    {
+        
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 3 4
+       (static_cast <bool> (
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h"
+       idx < PALETTE_SIZE
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 3 4
+       ) ? void (0) : __assert_fail (
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h"
+       "idx < PALETTE_SIZE"
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 3 4
+       , "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h", 53, __extension__ __PRETTY_FUNCTION__))
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h"
+                                 ;
+        if (idx >= PALETTE_SIZE)
+        {
+            static PaletteBGRA dummy;
+            return dummy;
+        }
+
+        return Colour[idx];
+    }
+
+    const PaletteBGRA operator[](uint16_t idx) const
+    {
+        
+# 65 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 3 4
+       (static_cast <bool> (
+# 65 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h"
+       idx < PALETTE_SIZE
+# 65 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 3 4
+       ) ? void (0) : __assert_fail (
+# 65 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h"
+       "idx < PALETTE_SIZE"
+# 65 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 3 4
+       , "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h", 65, __extension__ __PRETTY_FUNCTION__))
+# 65 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h"
+                                 ;
+        if (idx >= PALETTE_SIZE)
+            return {};
+
+        return Colour[idx];
+    }
+
+    explicit operator uint8_t*()
+    {
+        return reinterpret_cast<uint8_t*>(Colour);
+    }
+};
+
+struct rct_g1_element
+{
+    uint8_t* offset;
+    int16_t width;
+    int16_t height;
+    int16_t x_offset;
+    int16_t y_offset;
+    uint16_t flags;
+    int32_t zoomed_offset;
+};
+
+#pragma pack(push, 1)
+struct rct_g1_header
+{
+    uint32_t num_entries;
+    uint32_t total_size;
+};
+static_assert(sizeof(rct_g1_header) == (8), "Improper struct size");
+#pragma pack(pop)
+
+struct rct_gx
+{
+    rct_g1_header header;
+    std::vector<rct_g1_element> elements;
+    std::unique_ptr<uint8_t[]> data;
+};
+
+struct rct_drawpixelinfo
+{
+    uint8_t* bits{};
+    int16_t x{};
+    int16_t y{};
+    int16_t width{};
+    int16_t height{};
+    int16_t pitch{};
+    ZoomLevel zoom_level{};
+
+
+
+
+
+
+    uint8_t remX{};
+    uint8_t remY{};
+
+    OpenRCT2::Drawing::IDrawingEngine* DrawingEngine{};
+
+    size_t GetBytesPerRow() const;
+    uint8_t* GetBitsOffset(const ScreenCoordsXY& pos) const;
+    rct_drawpixelinfo Crop(const ScreenCoordsXY& pos, const ScreenSize& size) const;
+};
+
+struct rct_g1_element_32bit
+{
+    uint32_t offset;
+    int16_t width;
+    int16_t height;
+    int16_t x_offset;
+    int16_t y_offset;
+    uint16_t flags;
+    uint16_t zoomed_offset;
+};
+static_assert(sizeof(rct_g1_element_32bit) == (0x10), "Improper struct size");
+
+enum
+{
+    G1_FLAG_BMP = (1 << 0),
+    G1_FLAG_1 = (1 << 1),
+    G1_FLAG_RLE_COMPRESSION = (1 << 2),
+    G1_FLAG_PALETTE = (1 << 3),
+    G1_FLAG_HAS_ZOOM_SPRITE = (1 << 4),
+    G1_FLAG_NO_ZOOM_DRAW = (1 << 5),
+};
+
+enum : uint32_t
+{
+    IMAGE_TYPE_DEFAULT = 0,
+    IMAGE_TYPE_REMAP = (1 << 29),
+    IMAGE_TYPE_TRANSPARENT = (1 << 30),
+    IMAGE_TYPE_REMAP_2_PLUS = (1u << 31)
+
+
+};
+
+using DrawBlendOp = uint8_t;
+
+constexpr DrawBlendOp BLEND_NONE = 0;
+
+
+
+
+
+constexpr DrawBlendOp BLEND_TRANSPARENT = 1 << 0;
+
+
+
+
+
+constexpr DrawBlendOp BLEND_SRC = 1 << 1;
+
+
+
+
+
+constexpr DrawBlendOp BLEND_DST = 2 << 2;
+
+enum
+{
+    INSET_RECT_FLAG_FILL_GREY = (1 << 2),
+    INSET_RECT_FLAG_BORDER_NONE = (1 << 3),
+    INSET_RECT_FLAG_FILL_NONE = (1 << 4),
+    INSET_RECT_FLAG_BORDER_INSET = (1 << 5),
+    INSET_RECT_FLAG_FILL_DONT_LIGHTEN = (1 << 6),
+    INSET_RECT_FLAG_FILL_MID_LIGHT = (1 << 7),
+};
+
+enum class FilterPaletteID : int32_t
+{
+    PaletteNull = 0,
+
+    PaletteWater = 32,
+
+    Palette34 = 34,
+
+    Palette45 = 45,
+    Palette46 = 46,
+
+    PaletteDarken3 = 47,
+
+    PaletteDarken1 = 49,
+    PaletteDarken2 = 50,
+    Palette51 = 51,
+    PaletteTranslucentGrey = 52,
+    PaletteTranslucentGreyHighlight = 53,
+    PaletteTranslucentGreyShadow = 54,
+    PaletteTranslucentLightBlue = 55,
+    PaletteTranslucentLightBlueHighlight = 56,
+    PaletteTranslucentLightBlueShadow = 57,
+    PaletteTranslucentBordeauxRed = 58,
+    PaletteTranslucentBordeauxRedHighlight = 59,
+    PaletteTranslucentBordeauxRedShadow = 60,
+    PaletteTranslucentDarkGreen = 61,
+    PaletteTranslucentDarkGreenHighlight = 62,
+    PaletteTranslucentDarkGreenShadow = 63,
+    PaletteTranslucentLightPurple = 64,
+    PaletteTranslucentLightPurpleHighlight = 65,
+    PaletteTranslucentLightPurpleShadow = 66,
+    PaletteTranslucentDarkOliveGreen = 67,
+    PaletteTranslucentDarkOliveGreenHighlight = 68,
+    PaletteTranslucentDarkOliveGreenShadow = 69,
+    PaletteTranslucentLightBrown = 70,
+    PaletteTranslucentLightBrownHighlight = 71,
+    PaletteTranslucentLightBrownShadow = 72,
+    PaletteTranslucentYellow = 73,
+    PaletteTranslucentYellowHighlight = 74,
+    PaletteTranslucentYellowShadow = 75,
+    PaletteTranslucentMossGreen = 76,
+    PaletteTranslucentMossGreenHighlight = 77,
+    PaletteTranslucentMossGreenShadow = 78,
+    PaletteTranslucentOliveGreen = 79,
+    PaletteTranslucentOliveGreenHighlight = 80,
+    PaletteTranslucentOliveGreenShadow = 81,
+    PaletteTranslucentBrightGreen = 82,
+    PaletteTranslucentBrightGreenHighlight = 83,
+    PaletteTranslucentBrightGreenShadow = 84,
+    PaletteTranslucentSalmonPink = 85,
+    PaletteTranslucentSalmonPinkHighlight = 86,
+    PaletteTranslucentSalmonPinkShadow = 87,
+    PaletteTranslucentBrightPurple = 88,
+    PaletteTranslucentBrightPurpleHighlight = 89,
+    PaletteTranslucentBrightPurpleShadow = 90,
+    PaletteTranslucentBrightRed = 91,
+    PaletteTranslucentBrightRedHighlight = 92,
+    PaletteTranslucentBrightRedShadow = 93,
+    PaletteTranslucentLightOrange = 94,
+    PaletteTranslucentLightOrangeHighlight = 95,
+    PaletteTranslucentLightOrangeShadow = 96,
+    PaletteTranslucentTeal = 97,
+    PaletteTranslucentTealHighlight = 98,
+    PaletteTranslucentTealShadow = 99,
+    PaletteTranslucentBrightPink = 100,
+    PaletteTranslucentBrightPinkHighlight = 101,
+    PaletteTranslucentBrightPinkShadow = 102,
+    PaletteTranslucentDarkBrown = 103,
+    PaletteTranslucentDarkBrownHighlight = 104,
+    PaletteTranslucentDarkBrownShadow = 105,
+    PaletteTranslucentLightPink = 106,
+    PaletteTranslucentLightPinkHighlight = 107,
+    PaletteTranslucentLightPinkShadow = 108,
+    PaletteTranslucentWhite = 109,
+    PaletteTranslucentWhiteHighlight = 110,
+    PaletteTranslucentWhiteShadow = 111,
+    PaletteGlass = 112,
+    PaletteGlassBlack = PaletteGlass + COLOUR_BLACK,
+    PaletteGlassGrey = PaletteGlass + COLOUR_GREY,
+    PaletteGlassWhite = PaletteGlass + COLOUR_WHITE,
+    PaletteGlassDarkPurple = PaletteGlass + COLOUR_DARK_PURPLE,
+    PaletteGlassLightPurple = PaletteGlass + COLOUR_LIGHT_PURPLE,
+    PaletteGlassBrightPurple = PaletteGlass + COLOUR_BRIGHT_PURPLE,
+    PaletteGlassDarkBlue = PaletteGlass + COLOUR_DARK_BLUE,
+    PaletteGlassLightBlue = PaletteGlass + COLOUR_LIGHT_BLUE,
+    PaletteGlassIcyBlue = PaletteGlass + COLOUR_ICY_BLUE,
+    PaletteGlassTeal = PaletteGlass + COLOUR_TEAL,
+    PaletteGlassAquamarine = PaletteGlass + COLOUR_AQUAMARINE,
+    PaletteGlassSaturatedGreen = PaletteGlass + COLOUR_SATURATED_GREEN,
+    PaletteGlassDarkGreen = PaletteGlass + COLOUR_DARK_GREEN,
+    PaletteGlassMossGreen = PaletteGlass + COLOUR_MOSS_GREEN,
+    PaletteGlassBrightGreen = PaletteGlass + COLOUR_BRIGHT_GREEN,
+    PaletteGlassOliveGreen = PaletteGlass + COLOUR_OLIVE_GREEN,
+    PaletteGlassDarkOliveGreen = PaletteGlass + COLOUR_DARK_OLIVE_GREEN,
+    PaletteGlassBrightYellow = PaletteGlass + COLOUR_BRIGHT_YELLOW,
+    PaletteGlassYellow = PaletteGlass + COLOUR_YELLOW,
+    PaletteGlassDarkYellow = PaletteGlass + COLOUR_DARK_YELLOW,
+    PaletteGlassLightOrange = PaletteGlass + COLOUR_LIGHT_ORANGE,
+    PaletteGlassDarkOrange = PaletteGlass + COLOUR_DARK_ORANGE,
+    PaletteGlassLightBrown = PaletteGlass + COLOUR_LIGHT_BROWN,
+    PaletteGlassSaturatedBrown = PaletteGlass + COLOUR_SATURATED_BROWN,
+    PaletteGlassDarkBrown = PaletteGlass + COLOUR_DARK_BROWN,
+    PaletteGlassSalmonPink = PaletteGlass + COLOUR_SALMON_PINK,
+    PaletteGlassBordeauxRed = PaletteGlass + COLOUR_BORDEAUX_RED,
+    PaletteGlassSaturatedRed = PaletteGlass + COLOUR_SATURATED_RED,
+    PaletteGlassBrightRed = PaletteGlass + COLOUR_BRIGHT_RED,
+    PaletteGlassDarkPink = PaletteGlass + COLOUR_DARK_PINK,
+    PaletteGlassBrightPink = PaletteGlass + COLOUR_BRIGHT_PINK,
+    PaletteGlassLightPink = PaletteGlass + COLOUR_LIGHT_PINK,
+};
+
+struct translucent_window_palette
+{
+    FilterPaletteID base;
+    FilterPaletteID highlight;
+    FilterPaletteID shadow;
+};
+
+struct rct_size16
+{
+    int16_t width;
+    int16_t height;
+};
+
+enum class ImageCatalogue
+{
+    UNKNOWN,
+    G1,
+    G2,
+    CSG,
+    OBJECT,
+    TEMPORARY,
+};
+# 335 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h"
+struct ImageId
+{
+private:
+
+    static constexpr uint32_t MASK_INDEX = 0b00000000000001111111111111111111;
+    static constexpr uint32_t MASK_REMAP = 0b00000111111110000000000000000000;
+    static constexpr uint32_t MASK_PRIMARY = 0b00000000111110000000000000000000;
+    static constexpr uint32_t MASK_SECONDARY = 0b00011111000000000000000000000000;
+    static constexpr uint32_t FLAG_PRIMARY = 0b00100000000000000000000000000000;
+    static constexpr uint32_t FLAG_BLEND = 0b01000000000000000000000000000000;
+    static constexpr uint32_t FLAG_SECONDARY = 0b10000000000000000000000000000000;
+    static constexpr uint32_t SHIFT_REMAP = 19;
+    static constexpr uint32_t SHIFT_PRIMARY = 19;
+    static constexpr uint32_t SHIFT_SECONDARY = 24;
+    static constexpr uint32_t INDEX_UNDEFINED = 0b00000000000001111111111111111111;
+    static constexpr uint32_t VALUE_UNDEFINED = INDEX_UNDEFINED;
+
+
+    uint32_t _value = VALUE_UNDEFINED;
+    uint8_t _tertiary = 0;
+
+public:
+    static ImageId FromUInt32(uint32_t value)
+    {
+        ImageId result;
+        result._value = value;
+        return result;
+    }
+
+    static ImageId FromUInt32(uint32_t value, uint32_t tertiary)
+    {
+        ImageId result;
+        result._value = value;
+        result._tertiary = tertiary & 0xFF;
+        return result;
+    }
+
+    ImageId() = default;
+
+    explicit constexpr ImageId(uint32_t index)
+        : _value(index & MASK_INDEX)
+    {
+    }
+
+    constexpr ImageId(uint32_t index, uint8_t primaryColourOrPalette)
+        : ImageId(ImageId(index).WithPrimary(primaryColourOrPalette))
+    {
+    }
+
+    constexpr ImageId(uint32_t index, colour_t primaryColour, colour_t secondaryColour)
+        : ImageId(ImageId(index).WithPrimary(primaryColour).WithSecondary(secondaryColour))
+    {
+    }
+
+    constexpr ImageId(uint32_t index, colour_t primaryColour, colour_t secondaryColour, colour_t tertiaryColour)
+        : ImageId(ImageId(index).WithPrimary(primaryColour).WithSecondary(secondaryColour).WithTertiary(tertiaryColour))
+    {
+    }
+
+    uint32_t ToUInt32() const
+    {
+        return _value;
+    }
+
+    bool HasValue() const
+    {
+        return GetIndex() != INDEX_UNDEFINED;
+    }
+
+    bool HasPrimary() const
+    {
+        return (_value & FLAG_PRIMARY) || (_value & FLAG_SECONDARY);
+    }
+
+    bool HasSecondary() const
+    {
+        return _value & FLAG_SECONDARY;
+    }
+
+    bool HasTertiary() const
+    {
+        return !(_value & FLAG_PRIMARY) && (_value & FLAG_SECONDARY);
+    }
+
+    bool IsRemap() const
+    {
+        return (_value & FLAG_PRIMARY) && !(_value & FLAG_SECONDARY);
+    }
+
+    bool IsBlended() const
+    {
+        return _value & FLAG_BLEND;
+    }
+
+    uint32_t GetIndex() const
+    {
+        return _value & MASK_INDEX;
+    }
+
+    uint8_t GetRemap() const
+    {
+        return (_value & MASK_REMAP) >> SHIFT_REMAP;
+    }
+
+    colour_t GetPrimary() const
+    {
+        return (_value & MASK_PRIMARY) >> SHIFT_PRIMARY;
+    }
+
+    colour_t GetSecondary() const
+    {
+        return (_value & MASK_SECONDARY) >> SHIFT_SECONDARY;
+    }
+
+    colour_t GetTertiary() const
+    {
+        return _tertiary;
+    }
+
+    ImageCatalogue GetCatalogue() const;
+
+    constexpr ImageId WithIndex(uint32_t index)
+    {
+        ImageId result = *this;
+        result._value = (_value & ~MASK_INDEX) | (index & MASK_INDEX);
+        return result;
+    }
+
+    constexpr ImageId WithRemap(uint8_t paletteId)
+    {
+        ImageId result = *this;
+        result._value = (_value & ~MASK_REMAP) | ((paletteId << SHIFT_REMAP) & MASK_REMAP) | FLAG_PRIMARY;
+        return result;
+    }
+
+    constexpr ImageId WithPrimary(colour_t colour)
+    {
+        ImageId result = *this;
+        result._value = (_value & ~MASK_PRIMARY) | ((colour << SHIFT_PRIMARY) & MASK_PRIMARY) | FLAG_PRIMARY;
+        return result;
+    }
+
+    constexpr ImageId WithSecondary(colour_t colour)
+    {
+        ImageId result = *this;
+        result._value = (_value & ~MASK_SECONDARY) | ((colour << SHIFT_SECONDARY) & MASK_SECONDARY) | FLAG_SECONDARY;
+        return result;
+    }
+
+    constexpr ImageId WithTertiary(colour_t tertiary)
+    {
+        ImageId result = *this;
+        result._value &= ~FLAG_PRIMARY;
+        if (!(_value & FLAG_SECONDARY))
+        {
+
+
+            result._value &= ~MASK_SECONDARY;
+            result._value |= FLAG_SECONDARY;
+        }
+        result._tertiary = tertiary;
+        return result;
+    }
+};
+
+
+
+
+struct PaletteMap
+{
+private:
+    uint8_t* _data{};
+    uint32_t _dataLength{};
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint16_t _numMaps;
+#pragma clang diagnostic pop
+    uint16_t _mapLength;
+
+public:
+    static const PaletteMap& GetDefault();
+
+    PaletteMap() = default;
+
+    PaletteMap(uint8_t* data, uint16_t numMaps, uint16_t mapLength)
+        : _data(data)
+        , _dataLength(numMaps * mapLength)
+        , _numMaps(numMaps)
+        , _mapLength(mapLength)
+    {
+    }
+
+    template<std::size_t TSize>
+    PaletteMap(uint8_t (&map)[TSize])
+        : _data(map)
+        , _dataLength(static_cast<uint32_t>(std::size(map)))
+        , _numMaps(1)
+        , _mapLength(static_cast<uint16_t>(std::size(map)))
+    {
+    }
+
+    uint8_t& operator[](size_t index);
+    uint8_t operator[](size_t index) const;
+    uint8_t Blend(uint8_t src, uint8_t dst) const;
+    void Copy(size_t dstIndex, const PaletteMap& src, size_t srcIndex, size_t length);
+};
+
+struct DrawSpriteArgs
+{
+    rct_drawpixelinfo* DPI;
+    ImageId Image;
+    const PaletteMap& PalMap;
+    const rct_g1_element& SourceImage;
+    int32_t SrcX;
+    int32_t SrcY;
+    int32_t Width;
+    int32_t Height;
+    uint8_t* DestinationBits;
+
+    DrawSpriteArgs(
+        rct_drawpixelinfo* dpi, ImageId image, const PaletteMap& palMap, const rct_g1_element& sourceImage, int32_t srcX,
+        int32_t srcY, int32_t width, int32_t height, uint8_t* destinationBits)
+        : DPI(dpi)
+        , Image(image)
+        , PalMap(palMap)
+        , SourceImage(sourceImage)
+        , SrcX(srcX)
+        , SrcY(srcY)
+        , Width(width)
+        , Height(height)
+        , DestinationBits(destinationBits)
+    {
+    }
+};
+
+template<DrawBlendOp TBlendOp> bool BlitPixel(const uint8_t* src, uint8_t* dst, const PaletteMap& paletteMap)
+{
+    if constexpr (TBlendOp & BLEND_TRANSPARENT)
+    {
+
+        if (*src == 0)
+        {
+            return false;
+        }
+    }
+
+    if constexpr (((TBlendOp & BLEND_SRC) != 0) && ((TBlendOp & BLEND_DST) != 0))
+    {
+        auto pixel = paletteMap.Blend(*src, *dst);
+        if constexpr (TBlendOp & BLEND_TRANSPARENT)
+        {
+            if (pixel == 0)
+            {
+                return false;
+            }
+        }
+        *dst = pixel;
+        return true;
+    }
+    else if constexpr ((TBlendOp & BLEND_SRC) != 0)
+    {
+        auto pixel = paletteMap[*src];
+        if constexpr (TBlendOp & BLEND_TRANSPARENT)
+        {
+            if (pixel == 0)
+            {
+                return false;
+            }
+        }
+        *dst = pixel;
+        return true;
+    }
+    else if constexpr ((TBlendOp & BLEND_DST) != 0)
+    {
+        auto pixel = paletteMap[*dst];
+        if constexpr (TBlendOp & BLEND_TRANSPARENT)
+        {
+            if (pixel == 0)
+            {
+                return false;
+            }
+        }
+        *dst = pixel;
+        return true;
+    }
+    else
+    {
+        *dst = *src;
+        return true;
+    }
+}
+
+template<DrawBlendOp TBlendOp>
+void BlitPixels(const uint8_t* src, uint8_t* dst, const PaletteMap& paletteMap, uint8_t zoom, size_t dstPitch)
+{
+    auto yDstSkip = dstPitch - zoom;
+    for (uint8_t yy = 0; yy < zoom; yy++)
+    {
+        for (uint8_t xx = 0; xx < zoom; xx++)
+        {
+            BlitPixel<TBlendOp>(src, dst, paletteMap);
+            dst++;
+        }
+        dst += yDstSkip;
+    }
+}
+# 656 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h"
+extern GamePalette gPalette;
+extern uint8_t gGamePalette[256 * 4];
+extern uint32_t gPaletteEffectFrame;
+extern const FilterPaletteID GlassPaletteIds[COLOUR_COUNT];
+extern uint8_t gPeepPalette[256];
+extern uint8_t gOtherPalette[256];
+extern uint8_t text_palette[];
+extern const translucent_window_palette TranslucentWindowPalettes[COLOUR_COUNT];
+
+extern thread_local int32_t gLastDrawStringX;
+extern thread_local int32_t gLastDrawStringY;
+
+extern uint32_t gPickupPeepImage;
+extern int32_t gPickupPeepX;
+extern int32_t gPickupPeepY;
+
+extern bool gTinyFontAntiAliased;
+
+bool clip_drawpixelinfo(
+    rct_drawpixelinfo* dst, rct_drawpixelinfo* src, const ScreenCoordsXY& coords, int32_t width, int32_t height);
+void gfx_set_dirty_blocks(const ScreenRect& rect);
+void gfx_invalidate_screen();
+
+
+void gfx_transpose_palette(int32_t pal, uint8_t product);
+void load_palette();
+
+
+void gfx_clear(rct_drawpixelinfo* dpi, uint8_t paletteIndex);
+void gfx_filter_pixel(rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, FilterPaletteID palette);
+void gfx_invalidate_pickedup_peep();
+void gfx_draw_pickedup_peep(rct_drawpixelinfo* dpi);
+
+
+void gfx_draw_line(rct_drawpixelinfo* dpi, const ScreenLine& line, int32_t colour);
+void gfx_draw_line_software(rct_drawpixelinfo* dpi, const ScreenLine& line, int32_t colour);
+void gfx_draw_dashed_line(
+    rct_drawpixelinfo* dpi, const ScreenLine& screenLine, const int32_t dashedLineSegmentLength, const int32_t color);
+
+
+void gfx_fill_rect(rct_drawpixelinfo* dpi, const ScreenRect& rect, int32_t colour);
+void gfx_fill_rect_inset(rct_drawpixelinfo* dpi, const ScreenRect& rect, int32_t colour, uint8_t flags);
+void gfx_filter_rect(rct_drawpixelinfo* dpi, int32_t left, int32_t top, int32_t right, int32_t bottom, FilterPaletteID palette);
+void gfx_filter_rect(rct_drawpixelinfo* dpi, const ScreenRect& rect, FilterPaletteID palette);
+
+
+bool gfx_load_g1(const OpenRCT2::IPlatformEnvironment& env);
+bool gfx_load_g2();
+bool gfx_load_csg();
+void gfx_unload_g1();
+void gfx_unload_g2();
+void gfx_unload_csg();
+const rct_g1_element* gfx_get_g1_element(ImageId imageId);
+const rct_g1_element* gfx_get_g1_element(int32_t image_id);
+void gfx_set_g1_element(int32_t imageId, const rct_g1_element* g1);
+bool is_csg_loaded();
+uint32_t gfx_object_allocate_images(const rct_g1_element* images, uint32_t count);
+void gfx_object_free_images(uint32_t baseImageId, uint32_t count);
+void gfx_object_check_all_images_freed();
+size_t ImageListGetUsedCount();
+size_t ImageListGetMaximum();
+void gfx_sprite_to_buffer(DrawSpriteArgs& args);
+void gfx_bmp_sprite_to_buffer(DrawSpriteArgs& args);
+void gfx_rle_sprite_to_buffer(DrawSpriteArgs& args);
+void gfx_draw_sprite(rct_drawpixelinfo* dpi, ImageId image_id, const ScreenCoordsXY& coords);
+void gfx_draw_sprite(rct_drawpixelinfo* dpi, int32_t image_id, const ScreenCoordsXY& coords, uint32_t tertiary_colour);
+void
+    gfx_draw_glyph(rct_drawpixelinfo* dpi, int32_t image_id, const ScreenCoordsXY& coords, const PaletteMap& paletteMap);
+void
+    gfx_draw_sprite_raw_masked(rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, int32_t maskImage, int32_t colourImage);
+void gfx_draw_sprite_solid(rct_drawpixelinfo* dpi, int32_t image, const ScreenCoordsXY& coords, uint8_t colour);
+
+void gfx_draw_sprite_software(rct_drawpixelinfo* dpi, ImageId imageId, const ScreenCoordsXY& spriteCoords);
+void gfx_draw_sprite_palette_set_software(
+    rct_drawpixelinfo* dpi, ImageId imageId, const ScreenCoordsXY& coords, const PaletteMap& paletteMap);
+void gfx_draw_sprite_raw_masked_software(
+    rct_drawpixelinfo* dpi, const ScreenCoordsXY& scrCoords, int32_t maskImage, int32_t colourImage);
+
+
+void gfx_draw_string(rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, const_utf8string buffer, TextPaint textPaint = {});
+void gfx_draw_string_no_formatting(
+    rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, const_utf8string buffer, TextPaint textPaint);
+
+void gfx_draw_string_left_centred(
+    rct_drawpixelinfo* dpi, rct_string_id format, void* args, colour_t colour, const ScreenCoordsXY& coords);
+void draw_string_centred_raw(
+    rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, int32_t numLines, char* text, FontSpriteBase fontSpriteBase);
+void DrawNewsTicker(
+    rct_drawpixelinfo* dpi, const ScreenCoordsXY& coords, int32_t width, colour_t colour, rct_string_id format, void* args,
+    int32_t ticks);
+void gfx_draw_string_with_y_offsets(
+    rct_drawpixelinfo* dpi, const utf8* text, int32_t colour, const ScreenCoordsXY& coords, const int8_t* yOffsets,
+    bool forceSpriteFont, FontSpriteBase fontSpriteBase);
+
+int32_t gfx_wrap_string(char* buffer, int32_t width, FontSpriteBase fontSpriteBase, int32_t* num_lines);
+int32_t gfx_get_string_width(std::string_view text, FontSpriteBase fontSpriteBase);
+int32_t gfx_get_string_width_new_lined(std::string_view text, FontSpriteBase fontSpriteBase);
+int32_t gfx_get_string_width_no_formatting(std::string_view text, FontSpriteBase fontSpriteBase);
+int32_t string_get_height_raw(std::string_view text, FontSpriteBase fontBase);
+int32_t gfx_clip_string(char* buffer, int32_t width, FontSpriteBase fontSpriteBase);
+void shorten_path(utf8* buffer, size_t bufferSize, const utf8* path, int32_t availableWidth, FontSpriteBase fontSpriteBase);
+void ttf_draw_string(
+    rct_drawpixelinfo* dpi, const_utf8string text, int32_t colour, const ScreenCoordsXY& coords, bool noFormatting,
+    FontSpriteBase fontSpriteBase);
+
+
+void scrolling_text_initialise_bitmaps();
+void scrolling_text_invalidate();
+
+class Formatter;
+
+int32_t scrolling_text_setup(
+    struct paint_session* session, rct_string_id stringId, Formatter& ft, uint16_t scroll, uint16_t scrollingMode,
+    colour_t colour);
+
+rct_size16 gfx_get_sprite_size(uint32_t image_id);
+size_t g1_calculate_data_size(const rct_g1_element* g1);
+
+void mask_scalar(
+    int32_t width, int32_t height, const uint8_t* __restrict__ maskSrc, const uint8_t* __restrict__ colourSrc, uint8_t* __restrict__ dst,
+    int32_t maskWrap, int32_t colourWrap, int32_t dstWrap);
+void mask_sse4_1(
+    int32_t width, int32_t height, const uint8_t* __restrict__ maskSrc, const uint8_t* __restrict__ colourSrc, uint8_t* __restrict__ dst,
+    int32_t maskWrap, int32_t colourWrap, int32_t dstWrap);
+void mask_avx2(
+    int32_t width, int32_t height, const uint8_t* __restrict__ maskSrc, const uint8_t* __restrict__ colourSrc, uint8_t* __restrict__ dst,
+    int32_t maskWrap, int32_t colourWrap, int32_t dstWrap);
+void mask_init();
+
+extern void (*mask_fn)(
+    int32_t width, int32_t height, const uint8_t* __restrict__ maskSrc, const uint8_t* __restrict__ colourSrc, uint8_t* __restrict__ dst,
+    int32_t maskWrap, int32_t colourWrap, int32_t dstWrap);
+
+std::optional<uint32_t> GetPaletteG1Index(colour_t paletteId);
+std::optional<PaletteMap> GetPaletteMapForColour(colour_t paletteId);
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/NewDrawing.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/NewDrawing.h"
+       
+
+
+
+struct rct_drawpixelinfo;
+struct GamePalette;
+enum class DrawingEngine : int32_t;
+
+extern rct_string_id DrawingEngineStringIds[3];
+
+DrawingEngine drawing_engine_get_type();
+bool drawing_engine_requires_new_window(DrawingEngine srcEngine, DrawingEngine dstEngine);
+void drawing_engine_init();
+void drawing_engine_resize();
+void drawing_engine_set_palette(const GamePalette& colours);
+void drawing_engine_copy_rect(int32_t x, int32_t y, int32_t width, int32_t height, int32_t dx, int32_t dy);
+void drawing_engine_dispose();
+
+rct_drawpixelinfo* drawing_engine_get_dpi();
+bool drawing_engine_has_dirty_optimisations();
+void drawing_engine_invalidate_image(uint32_t image);
+void drawing_engine_set_vsync(bool vsync);
+# 793 "/home/ted/dev/openrct2/src/openrct2/object/../drawing/Drawing.h" 2
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/ImageTable.h" 2
+
+
+
+
+struct IReadObjectContext;
+namespace OpenRCT2
+{
+    struct IStream;
+}
+
+class ImageTable
+{
+private:
+    std::unique_ptr<uint8_t[]> _data;
+    std::vector<rct_g1_element> _entries;
+
+
+
+
+    struct RequiredImage;
+    static std::vector<std::unique_ptr<ImageTable::RequiredImage>> ParseImages(IReadObjectContext* context, std::string s);
+
+
+
+    static std::vector<std::unique_ptr<ImageTable::RequiredImage>> ParseImages(IReadObjectContext* context, json_t& el);
+    static std::vector<std::unique_ptr<ImageTable::RequiredImage>> LoadObjectImages(
+        IReadObjectContext* context, const std::string& name, const std::vector<int32_t>& range);
+    static std::vector<int32_t> ParseRange(std::string s);
+    static std::string FindLegacyObject(const std::string& name);
+
+public:
+    ImageTable() = default;
+    ImageTable(const ImageTable&) = delete;
+    ImageTable& operator=(const ImageTable&) = delete;
+    ~ImageTable();
+
+    void Read(IReadObjectContext* context, OpenRCT2::IStream* stream);
+
+
+
+    void ReadJson(IReadObjectContext* context, json_t& root);
+    const rct_g1_element* GetImages() const
+    {
+        return _entries.data();
+    }
+    uint32_t GetCount() const
+    {
+        return static_cast<uint32_t>(_entries.size());
+    }
+    void AddImage(const rct_g1_element* g1);
+};
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/Object.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/StringTable.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/StringTable.h"
+       
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../localisation/Language.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../localisation/Language.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../localisation/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../localisation/Language.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../localisation/../drawing/Font.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../localisation/Language.h" 2
+
+
+
+
+enum
+{
+    LANGUAGE_UNDEFINED,
+    LANGUAGE_ARABIC,
+    LANGUAGE_CATALAN,
+    LANGUAGE_CHINESE_SIMPLIFIED,
+    LANGUAGE_CHINESE_TRADITIONAL,
+    LANGUAGE_CZECH,
+    LANGUAGE_DANISH,
+    LANGUAGE_GERMAN,
+    LANGUAGE_ENGLISH_UK,
+    LANGUAGE_ENGLISH_US,
+    LANGUAGE_ESPERANTO,
+    LANGUAGE_SPANISH,
+    LANGUAGE_FRENCH,
+    LANGUAGE_ITALIAN,
+    LANGUAGE_JAPANESE,
+    LANGUAGE_KOREAN,
+    LANGUAGE_HUNGARIAN,
+    LANGUAGE_DUTCH,
+    LANGUAGE_NORWEGIAN,
+    LANGUAGE_POLISH,
+    LANGUAGE_PORTUGUESE_BR,
+    LANGUAGE_RUSSIAN,
+    LANGUAGE_FINNISH,
+    LANGUAGE_SWEDISH,
+    LANGUAGE_TURKISH,
+    LANGUAGE_VIETNAMESE,
+    LANGUAGE_COUNT
+};
+
+enum class RCT2LanguageId
+{
+    EnglishUK,
+    EnglishUS,
+    French,
+    German,
+    Spanish,
+    Italian,
+    Dutch,
+    Swedish,
+    Japanese,
+    Korean,
+    ChineseSimplified,
+    ChineseTraditional,
+    Undefined,
+    Portuguese,
+    Blank = 254,
+    End = 255
+};
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../localisation/../interface/FontFamilies.h" 1
+# 19 "/home/ted/dev/openrct2/src/openrct2/object/../localisation/../interface/FontFamilies.h"
+struct TTFFontSetDescriptor;
+
+using TTFontFamily = std::vector<TTFFontSetDescriptor*>;
+
+extern TTFontFamily const TTFFamilyChineseSimplified;
+extern TTFontFamily const TTFFamilyChineseTraditional;
+extern TTFontFamily const TTFFamilyJapanese;
+extern TTFontFamily const TTFFamilyKorean;
+extern TTFontFamily const TTFFamilySansSerif;
+# 73 "/home/ted/dev/openrct2/src/openrct2/object/../localisation/Language.h" 2
+
+struct language_descriptor
+{
+    const char* locale;
+    const utf8* english_name;
+    const utf8* native_name;
+
+    TTFontFamily const* font_family;
+
+
+
+    bool isRtl;
+};
+
+extern const language_descriptor LanguagesDescriptors[LANGUAGE_COUNT];
+
+constexpr const char* BlackUpArrowString = u8"{BLACK}▲";
+constexpr const char* BlackDownArrowString = u8"{BLACK}▼";
+constexpr const char* BlackLeftArrowString = u8"{BLACK}◀";
+constexpr const char* BlackRightArrowString = u8"{BLACK}▶";
+constexpr const char* CheckBoxMarkString = u8"✓";
+
+uint8_t language_get_id_from_locale(const char* locale);
+const char* language_get_string(rct_string_id id);
+bool language_open(int32_t id);
+
+uint32_t utf8_get_next(const utf8* char_ptr, const utf8** nextchar_ptr);
+int32_t utf8_insert_codepoint(utf8* dst, uint32_t codepoint);
+bool utf8_is_codepoint_start(const utf8* text);
+int32_t utf8_get_codepoint_length(char32_t codepoint);
+int32_t utf8_length(const utf8* text);
+
+std::string rct2_to_utf8(std::string_view src, RCT2LanguageId languageId);
+std::string utf8_to_rct2(std::string_view src);
+bool language_get_localised_scenario_strings(const utf8* scenarioFilename, rct_string_id* outStringIds);
+void language_free_object_string(rct_string_id stringId);
+rct_string_id language_allocate_object_string(const std::string& target);
+
+constexpr utf8* utf8_write_codepoint(utf8* dst, uint32_t codepoint)
+{
+    if (codepoint <= 0x7F)
+    {
+        dst[0] = static_cast<utf8>(codepoint);
+        return dst + 1;
+    }
+    else if (codepoint <= 0x7FF)
+    {
+        dst[0] = 0xC0 | ((codepoint >> 6) & 0x1F);
+        dst[1] = 0x80 | (codepoint & 0x3F);
+        return dst + 2;
+    }
+    else if (codepoint <= 0xFFFF)
+    {
+        dst[0] = 0xE0 | ((codepoint >> 12) & 0x0F);
+        dst[1] = 0x80 | ((codepoint >> 6) & 0x3F);
+        dst[2] = 0x80 | (codepoint & 0x3F);
+        return dst + 3;
+    }
+    else
+    {
+        dst[0] = 0xF0 | ((codepoint >> 18) & 0x07);
+        dst[1] = 0x80 | ((codepoint >> 12) & 0x3F);
+        dst[2] = 0x80 | ((codepoint >> 6) & 0x3F);
+        dst[3] = 0x80 | (codepoint & 0x3F);
+        return dst + 4;
+    }
+}
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/StringTable.h" 2
+
+
+
+
+struct IReadObjectContext;
+namespace OpenRCT2
+{
+    struct IStream;
+}
+
+enum class ObjectStringID : uint8_t
+{
+    UNKNOWN = 255,
+    NAME = 0,
+    DESCRIPTION,
+    SCENARIO_NAME = 0,
+    PARK_NAME = 1,
+    SCENARIO_DETAILS = 2,
+    CAPACITY = 2,
+    VEHICLE_NAME = 3,
+};
+
+struct StringTableEntry
+{
+    ObjectStringID Id = ObjectStringID::UNKNOWN;
+    uint8_t LanguageId = LANGUAGE_UNDEFINED;
+    std::string Text;
+};
+
+class StringTable
+{
+private:
+    std::vector<StringTableEntry> _strings;
+    static ObjectStringID ParseStringId(const std::string& s);
+
+public:
+    StringTable() = default;
+    StringTable(const StringTable&) = delete;
+    StringTable& operator=(const StringTable&) = delete;
+
+    void Read(IReadObjectContext* context, OpenRCT2::IStream* stream, ObjectStringID id);
+
+
+
+    void ReadJson(json_t& root);
+    void Sort();
+    std::string GetString(ObjectStringID id) const;
+    std::string GetString(uint8_t language, ObjectStringID id) const;
+    void SetString(ObjectStringID id, uint8_t language, const std::string& text);
+};
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/Object.h" 2
+
+
+
+
+
+
+using ObjectEntryIndex = uint16_t;
+constexpr const ObjectEntryIndex OBJECT_ENTRY_INDEX_NULL = std::numeric_limits<ObjectEntryIndex>::max();
+struct ObjectRepositoryItem;
+
+
+enum class ObjectType : uint8_t
+{
+    Ride,
+    SmallScenery,
+    LargeScenery,
+    Walls,
+    Banners,
+    Paths,
+    PathBits,
+    SceneryGroup,
+    ParkEntrance,
+    Water,
+    ScenarioText,
+    TerrainSurface,
+    TerrainEdge,
+    Station,
+    Music,
+
+    Count,
+    None = 255
+};
+
+ObjectType& operator++(ObjectType& d, int);
+
+enum OBJECT_SELECTION_FLAGS
+{
+    OBJECT_SELECTION_FLAG_SELECTED = (1 << 0),
+    OBJECT_SELECTION_FLAG_2 = (1 << 1),
+    OBJECT_SELECTION_FLAG_IN_USE = (1 << 2),
+
+    OBJECT_SELECTION_FLAG_ALWAYS_REQUIRED = (1 << 4),
+    OBJECT_SELECTION_FLAG_6 = (1 << 5),
+    OBJECT_SELECTION_FLAG_7 = (1 << 6),
+    OBJECT_SELECTION_FLAG_8 = (1 << 7),
+    OBJECT_SELECTION_FLAG_ALL = 0xFF,
+};
+
+
+
+enum class ObjectSourceGame : uint8_t
+{
+    Custom,
+    WackyWorlds,
+    TimeTwister,
+    OpenRCT2Official,
+    RCT1,
+    AddedAttractions,
+    LoopyLandscapes,
+    RCT2 = 8
+};
+
+#pragma pack(push, 1)
+
+
+
+
+struct rct_object_entry
+{
+    union
+    {
+        uint8_t end_flag;
+        uint32_t flags;
+    };
+    union
+    {
+        char nameWOC[12];
+        struct
+        {
+            char name[8];
+            uint32_t checksum;
+        };
+    };
+
+    std::string_view GetName() const
+    {
+        return std::string_view(name, std::size(name));
+    }
+
+    void SetName(std::string_view value);
+
+    ObjectType GetType() const
+    {
+        return static_cast<ObjectType>(flags & 0x0F);
+    }
+
+    void SetType(ObjectType newType)
+    {
+        flags &= ~0x0F;
+        flags |= (static_cast<uint8_t>(newType) & 0x0F);
+    }
+
+    std::optional<uint8_t> GetSceneryType() const;
+
+    ObjectSourceGame GetSourceGame() const
+    {
+        return static_cast<ObjectSourceGame>((flags & 0xF0) >> 4);
+    }
+};
+static_assert(sizeof(rct_object_entry) == (0x10), "Improper struct size");
+
+struct rct_object_entry_group
+{
+    void** chunks;
+    rct_object_entry* entries;
+};
+
+
+
+
+struct rct_ride_filters
+{
+    uint8_t category[2];
+    uint8_t ride_type;
+};
+static_assert(sizeof(rct_ride_filters) == (3), "Improper struct size");
+
+struct rct_object_filters
+{
+    union
+    {
+        rct_ride_filters ride;
+    };
+};
+static_assert(sizeof(rct_object_filters) == (3), "Improper struct size");
+#pragma pack(pop)
+
+enum class ObjectGeneration : uint8_t
+{
+    DAT,
+    JSON,
+};
+
+struct ObjectEntryDescriptor
+{
+    ObjectGeneration Generation = ObjectGeneration::JSON;
+
+
+    rct_object_entry Entry;
+
+
+    ObjectType Type{};
+    std::string Identifier;
+    std::string Version;
+
+    ObjectEntryDescriptor() = default;
+    explicit ObjectEntryDescriptor(const rct_object_entry& newEntry);
+    explicit ObjectEntryDescriptor(std::string_view newIdentifier);
+    explicit ObjectEntryDescriptor(const ObjectRepositoryItem& ori);
+    bool HasValue() const;
+    ObjectType GetType() const;
+    std::string_view GetName() const;
+};
+
+struct IObjectRepository;
+namespace OpenRCT2
+{
+    struct IStream;
+}
+struct ObjectRepositoryItem;
+struct rct_drawpixelinfo;
+
+enum class ObjectError : uint32_t
+{
+    Ok,
+    Unknown,
+    BadEncoding,
+    InvalidProperty,
+    BadStringTable,
+    BadImageTable,
+    UnexpectedEOF,
+};
+
+class ObjectAsset
+{
+private:
+    std::string _zipPath;
+    std::string _path;
+
+public:
+    ObjectAsset() = default;
+    ObjectAsset(std::string_view path)
+        : _path(path)
+    {
+    }
+    ObjectAsset(std::string_view zipPath, std::string_view path)
+        : _zipPath(zipPath)
+        , _path(path)
+    {
+    }
+
+    bool IsAvailable() const;
+    size_t GetSize() const;
+    std::unique_ptr<OpenRCT2::IStream> GetStream() const;
+};
+
+struct IReadObjectContext
+{
+    virtual ~IReadObjectContext() = default;
+
+    virtual std::string_view GetObjectIdentifier() = 0;
+    virtual IObjectRepository& GetObjectRepository() = 0;
+    virtual bool ShouldLoadImages() = 0;
+    virtual std::vector<uint8_t> GetData(std::string_view path) = 0;
+    virtual ObjectAsset GetAsset(std::string_view path) = 0;
+
+    virtual void LogWarning(ObjectError code, const utf8* text) = 0;
+    virtual void LogError(ObjectError code, const utf8* text) = 0;
+};
+
+
+
+
+
+
+class Object
+{
+private:
+    std::string _identifier;
+    rct_object_entry _objectEntry{};
+    StringTable _stringTable;
+    ImageTable _imageTable;
+    std::vector<ObjectSourceGame> _sourceGames;
+    std::vector<std::string> _authors;
+    bool _isJsonObject{};
+
+protected:
+    StringTable& GetStringTable()
+    {
+        return _stringTable;
+    }
+    const StringTable& GetStringTable() const
+    {
+        return _stringTable;
+    }
+    ImageTable& GetImageTable()
+    {
+        return _imageTable;
+    }
+
+
+
+
+
+
+
+    void PopulateTablesFromJson(IReadObjectContext* context, json_t& root);
+
+    static rct_object_entry ParseObjectEntry(const std::string& s);
+
+    std::string GetOverrideString(uint8_t index) const;
+    std::string GetString(ObjectStringID index) const;
+    std::string GetString(int32_t language, ObjectStringID index) const;
+
+public:
+    explicit Object(const rct_object_entry& entry);
+    virtual ~Object() = default;
+
+    std::string_view GetIdentifier() const
+    {
+        return _identifier;
+    }
+    void SetIdentifier(std::string_view identifier)
+    {
+        _identifier = identifier;
+    }
+
+    void MarkAsJsonObject()
+    {
+        _isJsonObject = true;
+    }
+
+    bool IsJsonObject() const
+    {
+        return _isJsonObject;
+    };
+
+
+    std::string_view GetLegacyIdentifier() const
+    {
+        return _objectEntry.GetName();
+    }
+    const rct_object_entry* GetObjectEntry() const
+    {
+        return &_objectEntry;
+    }
+    virtual void* GetLegacyData();
+
+
+
+
+    virtual void ReadJson(IReadObjectContext* , json_t& )
+    {
+    }
+    virtual void ReadLegacy(IReadObjectContext* context, OpenRCT2::IStream* stream);
+    virtual void Load() = 0;
+    virtual void Unload() = 0;
+
+    virtual void DrawPreview(rct_drawpixelinfo* , int32_t , int32_t ) const
+    {
+    }
+
+    virtual ObjectType GetObjectType() const final
+    {
+        return _objectEntry.GetType();
+    }
+    virtual std::string GetName() const;
+    virtual std::string GetName(int32_t language) const;
+
+    virtual void SetRepositoryItem(ObjectRepositoryItem* ) const
+    {
+    }
+    std::vector<ObjectSourceGame> GetSourceGames();
+    void SetSourceGames(const std::vector<ObjectSourceGame>& sourceGames);
+
+    const std::vector<std::string>& GetAuthors() const;
+    void SetAuthors(std::vector<std::string>&& authors);
+
+    const ImageTable& GetImageTable() const
+    {
+        return _imageTable;
+    }
+
+    ObjectEntryDescriptor GetScgWallsHeader() const;
+    ObjectEntryDescriptor GetScgPathXHeader() const;
+    rct_object_entry CreateHeader(const char name[9], uint32_t flags, uint32_t checksum);
+
+    uint32_t GetNumImages() const
+    {
+        return GetImageTable().GetCount();
+    }
+};
+
+
+
+
+extern int32_t object_entry_group_counts[];
+extern int32_t object_entry_group_encoding[];
+
+bool object_entry_is_empty(const rct_object_entry* entry);
+bool object_entry_compare(const rct_object_entry* a, const rct_object_entry* b);
+int32_t object_calculate_checksum(const rct_object_entry* entry, const void* data, size_t dataLength);
+bool find_object_in_entry_group(const rct_object_entry* entry, ObjectType* entry_type, ObjectEntryIndex* entryIndex);
+void object_create_identifier_name(char* string_buffer, size_t size, const rct_object_entry* object);
+
+const rct_object_entry* object_list_find(rct_object_entry* entry);
+
+void object_entry_get_name_fixed(utf8* buffer, size_t bufferSize, const rct_object_entry* entry);
+
+void* object_entry_get_chunk(ObjectType objectType, ObjectEntryIndex index);
+const Object* object_entry_get_object(ObjectType objectType, ObjectEntryIndex index);
+# 15 "/home/ted/dev/openrct2/src/openrct2/ParkImporter.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/ObjectList.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/ObjectList.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct12/RCT12.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct12/RCT12.h"
+       
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct12/../common.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct12/RCT12.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct12/../ride/RideTypes.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct12/../ride/RideTypes.h"
+       
+
+
+
+
+
+
+using ride_id_t = uint16_t;
+struct Ride;
+
+constexpr const ride_id_t RIDE_ID_NULL = std::numeric_limits<ride_id_t>::max();
+
+
+
+
+struct RideSelection
+{
+    uint8_t Type;
+    ObjectEntryIndex EntryIndex;
+
+    bool operator==(const RideSelection& other) const
+    {
+        return Type == other.Type && EntryIndex == other.EntryIndex;
+    }
+
+    bool operator!=(const RideSelection& other) const
+    {
+        return !(*this == other);
+    }
+};
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct12/RCT12.h" 2
+
+
+
+
+class ObjectList;
+
+using track_type_t = uint16_t;
+using RCT12TrackType = uint8_t;
+
+constexpr uint8_t RCT2_STRING_FORMAT_ARG_START = 123;
+constexpr uint8_t RCT2_STRING_FORMAT_ARG_END = 141;
+constexpr uint8_t RCT2_STRING_FORMAT_COLOUR_START = 142;
+constexpr uint8_t RCT2_STRING_FORMAT_COLOUR_END = 156;
+
+constexpr const uint8_t RCT12_MAX_RIDES_IN_PARK = 255;
+constexpr const uint8_t RCT12_MAX_AWARDS = 4;
+constexpr const uint8_t RCT12_MAX_NEWS_ITEMS = 61;
+constexpr const uint8_t RCT12_MAX_STATIONS_PER_RIDE = 4;
+constexpr const uint8_t RCT12_MAX_PEEP_SPAWNS = 2;
+constexpr const uint8_t RCT12_MAX_PARK_ENTRANCES = 4;
+
+
+
+constexpr const uint8_t RCT12_PATROL_AREA_SIZE = 128;
+constexpr const uint8_t RCT12_STAFF_TYPE_COUNT = 4;
+constexpr const uint8_t RCT12_NUM_COLOUR_SCHEMES = 4;
+constexpr const uint8_t RCT12_MAX_VEHICLE_COLOURS = 32;
+constexpr const uint8_t RCT12_SOUND_ID_NULL = 0xFF;
+
+constexpr const uint8_t RCT12_EXPENDITURE_TABLE_MONTH_COUNT = 16;
+constexpr const uint8_t RCT12_EXPENDITURE_TYPE_COUNT = 14;
+constexpr const uint8_t RCT12_FINANCE_GRAPH_SIZE = 128;
+
+constexpr const uint16_t RCT12_MAX_USER_STRINGS = 1024;
+constexpr const uint8_t RCT12_USER_STRING_MAX_LENGTH = 32;
+
+constexpr const uint8_t RCT12_PEEP_MAX_THOUGHTS = 5;
+
+using RCT12RideId = uint8_t;
+constexpr const RCT12RideId RCT12_RIDE_ID_NULL = 255;
+constexpr const uint16_t RCT12_RIDE_MEASUREMENT_MAX_ITEMS = 4800;
+
+constexpr uint16_t const RCT12_MAX_INVERSIONS = 31;
+constexpr uint16_t const RCT12_MAX_GOLF_HOLES = 31;
+constexpr uint16_t const RCT12_MAX_HELICES = 31;
+
+constexpr uint8_t RCT12_BANNER_INDEX_NULL = std::numeric_limits<uint8_t>::max();
+
+constexpr const uint8_t RCT12_TILE_ELEMENT_SURFACE_EDGE_STYLE_MASK = 0xE0;
+constexpr const uint8_t RCT12_TILE_ELEMENT_SURFACE_WATER_HEIGHT_MASK = 0x1F;
+constexpr const uint8_t RCT12_TILE_ELEMENT_SURFACE_TERRAIN_MASK = 0xE0;
+
+constexpr const uint16_t RCT12_TILE_ELEMENT_LARGE_TYPE_MASK = 0x3FF;
+
+constexpr uint16_t const RCT12_XY8_UNDEFINED = 0xFFFF;
+
+using RCT12ObjectEntryIndex = uint8_t;
+constexpr const RCT12ObjectEntryIndex RCT12_OBJECT_ENTRY_INDEX_NULL = 255;
+
+
+constexpr const uint32_t RCT12_RESEARCHED_ITEMS_SEPARATOR = 0xFFFFFFFF;
+
+constexpr const uint32_t RCT12_RESEARCHED_ITEMS_END = 0xFFFFFFFE;
+
+constexpr const uint32_t RCT12_RESEARCHED_ITEMS_END_2 = 0xFFFFFFFD;
+
+constexpr const uint8_t RCT12_MAX_ELEMENT_HEIGHT = 255;
+
+constexpr const uint16_t RCT12_PEEP_SPAWN_UNDEFINED = 0xFFFF;
+
+constexpr const uint16_t RCT12VehicleTrackDirectionMask = 0b0000000000000011;
+constexpr const uint16_t RCT12VehicleTrackTypeMask = 0b1111111111111100;
+
+enum class RCT12TrackDesignVersion : uint8_t
+{
+    TD4,
+    TD4_AA,
+    TD6,
+    unknown
+};
+
+enum
+{
+    RCT12_SURFACE_ELEMENT_TYPE_SURFACE_MASK = 0b00000011,
+    RCT12_SURFACE_ELEMENT_TYPE_EDGE_MASK = 0b01000000,
+};
+
+enum
+{
+    RCT12_TILE_ELEMENT_FLAG_GHOST = (1 << 4),
+    RCT12_TILE_ELEMENT_FLAG_BROKEN = (1 << 5),
+    RCT12_TILE_ELEMENT_FLAG_BLOCK_BRAKE_CLOSED = (1 << 5),
+    RCT12_TILE_ELEMENT_FLAG_INDESTRUCTIBLE_TRACK_PIECE = (1 << 6),
+    RCT12_TILE_ELEMENT_FLAG_BLOCKED_BY_VEHICLE = (1 << 6),
+    RCT12_TILE_ELEMENT_FLAG_LARGE_SCENERY_ACCOUNTED = (1 << 6),
+    RCT12_TILE_ELEMENT_FLAG_LAST_TILE = (1 << 7)
+};
+
+enum
+{
+    RCT12_TRACK_ELEMENT_TYPE_FLAG_CHAIN_LIFT = 1 << 7,
+};
+
+enum
+{
+    RCT12_TRACK_ELEMENT_SEQUENCE_STATION_INDEX_MASK = 0b01110000,
+    RCT12_TRACK_ELEMENT_SEQUENCE_SEQUENCE_MASK = 0b00001111,
+    RCT12_TRACK_ELEMENT_SEQUENCE_TAKING_PHOTO_MASK = 0b11110000,
+};
+
+enum
+{
+
+
+
+
+    RCT12_TRACK_ELEMENT_COLOUR_FLAG_INVERTED = (1 << 2),
+
+
+    RCT12_TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT = (1 << 3),
+
+    RCT12_TRACK_ELEMENT_DOOR_A_MASK = 0b00011100,
+    RCT12_TRACK_ELEMENT_DOOR_B_MASK = 0b11100000,
+};
+
+
+enum
+{
+    RCT12_FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK = (1 << 0) | (1 << 1),
+    RCT12_FOOTPATH_PROPERTIES_FLAG_IS_SLOPED = (1 << 2),
+    RCT12_FOOTPATH_PROPERTIES_FLAG_HAS_QUEUE_BANNER = (1 << 3),
+    RCT12_FOOTPATH_PROPERTIES_TYPE_MASK = (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7),
+};
+
+
+enum
+{
+    RCT12_FOOTPATH_PROPERTIES_ADDITIONS_TYPE_MASK = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3),
+
+    RCT12_FOOTPATH_PROPERTIES_ADDITIONS_STATION_INDEX_MASK = (1 << 4) | (1 << 5) | (1 << 6),
+    RCT12_FOOTPATH_PROPERTIES_ADDITIONS_FLAG_GHOST = (1 << 7),
+};
+
+enum
+{
+    RCT12_STATION_STYLE_PLAIN,
+    RCT12_STATION_STYLE_WOODEN,
+    RCT12_STATION_STYLE_CANVAS_TENT,
+    RCT12_STATION_STYLE_CASTLE_GREY,
+    RCT12_STATION_STYLE_CASTLE_BROWN,
+    RCT12_STATION_STYLE_JUNGLE,
+    RCT12_STATION_STYLE_LOG_CABIN,
+    RCT12_STATION_STYLE_CLASSICAL,
+    RCT12_STATION_STYLE_ABSTRACT,
+    RCT12_STATION_STYLE_SNOW,
+    RCT12_STATION_STYLE_PAGODA,
+    RCT12_STATION_STYLE_SPACE,
+
+    RCT12_STATION_STYLE_INVISIBLE,
+};
+
+#pragma pack(push, 1)
+
+struct RCT12xy8
+{
+    union
+    {
+        struct
+        {
+            uint8_t x, y;
+        };
+        uint16_t xy;
+    };
+
+    bool isNull() const
+    {
+        return xy == RCT12_XY8_UNDEFINED;
+    }
+
+    void setNull()
+    {
+        xy = RCT12_XY8_UNDEFINED;
+    }
+};
+static_assert(sizeof(RCT12xy8) == (2), "Improper struct size");
+
+
+struct rct_td46_maze_element
+{
+    union
+    {
+        uint32_t all;
+        struct
+        {
+            int8_t x;
+            int8_t y;
+            union
+            {
+                uint16_t maze_entry;
+                struct
+                {
+                    uint8_t direction;
+                    uint8_t type;
+                };
+            };
+        };
+    };
+};
+static_assert(sizeof(rct_td46_maze_element) == (0x04), "Improper struct size");
+
+
+struct rct_td46_track_element
+{
+    uint8_t type;
+    uint8_t flags;
+};
+static_assert(sizeof(rct_td46_track_element) == (0x02), "Improper struct size");
+
+struct rct12_award
+{
+    uint16_t time;
+    uint16_t type;
+};
+static_assert(sizeof(rct12_award) == (4), "Improper struct size");
+
+
+
+
+
+struct rct12_news_item
+{
+    uint8_t Type;
+    uint8_t Flags;
+    uint32_t Assoc;
+    uint16_t Ticks;
+    uint16_t MonthYear;
+    uint8_t Day;
+    uint8_t pad_0B;
+    char Text[256];
+};
+static_assert(sizeof(rct12_news_item) == (0x10C), "Improper struct size");
+
+struct rct12_xyzd8
+{
+    uint8_t x, y, z, direction;
+};
+static_assert(sizeof(rct12_xyzd8) == (4), "Improper struct size");
+
+struct rct12_peep_spawn
+{
+    uint16_t x;
+    uint16_t y;
+    uint8_t z;
+    uint8_t direction;
+};
+static_assert(sizeof(rct12_peep_spawn) == (6), "Improper struct size");
+
+enum class RCT12TileElementType : uint8_t
+{
+    Surface = (0 << 2),
+    Path = (1 << 2),
+    Track = (2 << 2),
+    SmallScenery = (3 << 2),
+    Entrance = (4 << 2),
+    Wall = (5 << 2),
+    LargeScenery = (6 << 2),
+    Banner = (7 << 2),
+    Corrupt = (8 << 2),
+    EightCarsCorrupt14 = (14 << 2),
+    EightCarsCorrupt15 = (15 << 2),
+};
+struct RCT12SurfaceElement;
+struct RCT12PathElement;
+struct RCT12TrackElement;
+struct RCT12SmallSceneryElement;
+struct RCT12LargeSceneryElement;
+struct RCT12WallElement;
+struct RCT12EntranceElement;
+struct RCT12BannerElement;
+struct RCT12CorruptElement;
+struct RCT12EightCarsCorruptElement14;
+struct RCT12EightCarsCorruptElement15;
+
+struct RCT12TileElementBase
+{
+    uint8_t type;
+    uint8_t flags;
+    uint8_t base_height;
+    uint8_t clearance_height;
+    uint8_t GetType() const;
+    uint8_t GetDirection() const;
+    void SetDirection(uint8_t direction);
+
+    uint8_t GetOccupiedQuadrants() const;
+    void SetOccupiedQuadrants(uint8_t quadrants);
+
+    bool IsLastForTile() const;
+    void SetLastForTile(bool on);
+    bool IsGhost() const;
+    void SetGhost(bool isGhost);
+};
+
+
+
+
+struct RCT12TileElement : public RCT12TileElementBase
+{
+    uint8_t pad_04[4];
+    template<typename TType, RCT12TileElementType TClass> const TType* as() const
+    {
+        return static_cast<RCT12TileElementType>(GetType()) == TClass ? reinterpret_cast<const TType*>(this) : nullptr;
+    }
+    template<typename TType, RCT12TileElementType TClass> TType* as()
+    {
+        return static_cast<RCT12TileElementType>(GetType()) == TClass ? reinterpret_cast<TType*>(this) : nullptr;
+    }
+
+    const RCT12SurfaceElement* AsSurface() const
+    {
+        return as<RCT12SurfaceElement, RCT12TileElementType::Surface>();
+    }
+    RCT12SurfaceElement* AsSurface()
+    {
+        return as<RCT12SurfaceElement, RCT12TileElementType::Surface>();
+    }
+    const RCT12PathElement* AsPath() const
+    {
+        return as<RCT12PathElement, RCT12TileElementType::Path>();
+    }
+    RCT12PathElement* AsPath()
+    {
+        return as<RCT12PathElement, RCT12TileElementType::Path>();
+    }
+    const RCT12TrackElement* AsTrack() const
+    {
+        return as<RCT12TrackElement, RCT12TileElementType::Track>();
+    }
+    RCT12TrackElement* AsTrack()
+    {
+        return as<RCT12TrackElement, RCT12TileElementType::Track>();
+    }
+    const RCT12SmallSceneryElement* AsSmallScenery() const
+    {
+        return as<RCT12SmallSceneryElement, RCT12TileElementType::SmallScenery>();
+    }
+    RCT12SmallSceneryElement* AsSmallScenery()
+    {
+        return as<RCT12SmallSceneryElement, RCT12TileElementType::SmallScenery>();
+    }
+    const RCT12LargeSceneryElement* AsLargeScenery() const
+    {
+        return as<RCT12LargeSceneryElement, RCT12TileElementType::LargeScenery>();
+    }
+    RCT12LargeSceneryElement* AsLargeScenery()
+    {
+        return as<RCT12LargeSceneryElement, RCT12TileElementType::LargeScenery>();
+    }
+    const RCT12WallElement* AsWall() const
+    {
+        return as<RCT12WallElement, RCT12TileElementType::Wall>();
+    }
+    RCT12WallElement* AsWall()
+    {
+        return as<RCT12WallElement, RCT12TileElementType::Wall>();
+    }
+    const RCT12EntranceElement* AsEntrance() const
+    {
+        return as<RCT12EntranceElement, RCT12TileElementType::Entrance>();
+    }
+    RCT12EntranceElement* AsEntrance()
+    {
+        return as<RCT12EntranceElement, RCT12TileElementType::Entrance>();
+    }
+    const RCT12BannerElement* AsBanner() const
+    {
+        return as<RCT12BannerElement, RCT12TileElementType::Banner>();
+    }
+    RCT12BannerElement* AsBanner()
+    {
+        return as<RCT12BannerElement, RCT12TileElementType::Banner>();
+    }
+    void ClearAs(uint8_t newType);
+    uint8_t GetBannerIndex();
+};
+static_assert(sizeof(RCT12TileElement) == (8), "Improper struct size");
+struct RCT12SurfaceElement : RCT12TileElementBase
+{
+private:
+    uint8_t slope;
+    uint8_t terrain;
+    uint8_t grass_length;
+    uint8_t ownership;
+public:
+    uint8_t GetSlope() const;
+    uint32_t GetSurfaceStyle() const;
+    uint32_t GetEdgeStyle() const;
+    uint8_t GetGrassLength() const;
+    uint8_t GetOwnership() const;
+    uint32_t GetWaterHeight() const;
+    uint8_t GetParkFences() const;
+    bool HasTrackThatNeedsWater() const;
+
+    void SetSlope(uint8_t newSlope);
+    void SetSurfaceStyle(uint32_t newStyle);
+    void SetEdgeStyle(uint32_t newStyle);
+    void SetGrassLength(uint8_t newLength);
+    void SetOwnership(uint8_t newOwnership);
+    void SetWaterHeight(uint32_t newWaterHeight);
+    void SetParkFences(uint8_t newParkFences);
+    void SetHasTrackThatNeedsWater(bool on);
+};
+static_assert(sizeof(RCT12SurfaceElement) == (8), "Improper struct size");
+struct RCT12PathElement : RCT12TileElementBase
+{
+private:
+    uint8_t entryIndex;
+    uint8_t additions;
+    uint8_t edges;
+    union
+    {
+        uint8_t additionStatus;
+        uint8_t rideIndex;
+    };
+
+public:
+    RCT12ObjectEntryIndex GetEntryIndex() const;
+    uint8_t GetQueueBannerDirection() const;
+    bool IsSloped() const;
+    uint8_t GetSlopeDirection() const;
+    uint8_t GetRideIndex() const;
+    uint8_t GetStationIndex() const;
+    bool IsWide() const;
+    bool IsQueue() const;
+    bool HasQueueBanner() const;
+    uint8_t GetEdges() const;
+    uint8_t GetCorners() const;
+    uint8_t GetAddition() const;
+    bool AdditionIsGhost() const;
+    uint8_t GetAdditionStatus() const;
+    uint8_t GetRCT1PathType() const;
+    uint8_t GetRCT1SupportType() const;
+
+    void SetPathEntryIndex(RCT12ObjectEntryIndex newIndex);
+    void SetQueueBannerDirection(uint8_t direction);
+    void SetSloped(bool isSloped);
+    void SetSlopeDirection(uint8_t newSlope);
+    void SetRideIndex(uint8_t newRideIndex);
+    void SetStationIndex(uint8_t newStationIndex);
+    void SetWide(bool isWide);
+    void SetIsQueue(bool isQueue);
+    void SetHasQueueBanner(bool hasQueueBanner);
+    void SetEdges(uint8_t newEdges);
+    void SetCorners(uint8_t newCorners);
+    void SetAddition(uint8_t newAddition);
+    void SetAdditionIsGhost(bool isGhost);
+    void SetAdditionStatus(uint8_t newStatus);
+
+    bool IsBroken() const;
+    void SetIsBroken(bool isBroken);
+
+    bool IsBlockedByVehicle() const;
+    void SetIsBlockedByVehicle(bool isBlocked);
+};
+static_assert(sizeof(RCT12PathElement) == (8), "Improper struct size");
+struct RCT12TrackElement : RCT12TileElementBase
+{
+private:
+    uint8_t trackType;
+    union
+    {
+        struct
+        {
+# 500 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct12/RCT12.h"
+            uint8_t sequence;
+            uint8_t colour;
+        };
+        uint16_t mazeEntry;
+    };
+    uint8_t rideIndex;
+public:
+    uint8_t GetTrackType() const;
+    uint8_t GetSequenceIndex() const;
+    uint8_t GetRideIndex() const;
+    uint8_t GetColourScheme() const;
+    uint8_t GetStationIndex() const;
+    bool HasChain() const;
+    bool HasCableLift() const;
+    bool IsInverted() const;
+    uint8_t GetBrakeBoosterSpeed() const;
+    bool HasGreenLight() const;
+    uint8_t GetSeatRotation() const;
+    uint16_t GetMazeEntry() const;
+    uint8_t GetPhotoTimeout() const;
+
+    uint8_t GetDoorAState() const;
+    uint8_t GetDoorBState() const;
+    void SetDoorAState(uint8_t newState);
+    void SetDoorBState(uint8_t newState);
+
+    void SetTrackType(uint8_t newEntryIndex);
+    void SetSequenceIndex(uint8_t newSequenceIndex);
+    void SetRideIndex(uint8_t newRideIndex);
+    void SetColourScheme(uint8_t newColourScheme);
+    void SetStationIndex(uint8_t newStationIndex);
+    void SetHasChain(bool on);
+    void SetHasCableLift(bool on);
+    void SetInverted(bool inverted);
+    bool BlockBrakeClosed() const;
+    void SetBlockBrakeClosed(bool isClosed);
+    void SetBrakeBoosterSpeed(uint8_t speed);
+    void SetHasGreenLight(uint8_t greenLight);
+    void SetSeatRotation(uint8_t newSeatRotation);
+    void SetMazeEntry(uint16_t newMazeEntry);
+    void SetPhotoTimeout(uint8_t newValue);
+
+    bool IsIndestructible() const;
+    void SetIsIndestructible(bool isIndestructible);
+};
+static_assert(sizeof(RCT12TrackElement) == (8), "Improper struct size");
+struct RCT12SmallSceneryElement : RCT12TileElementBase
+{
+private:
+    uint8_t entryIndex;
+    uint8_t age;
+    uint8_t colour_1;
+    uint8_t colour_2;
+public:
+    RCT12ObjectEntryIndex GetEntryIndex() const;
+    uint8_t GetAge() const;
+    uint8_t GetSceneryQuadrant() const;
+    colour_t GetPrimaryColour() const;
+    colour_t GetSecondaryColour() const;
+    bool NeedsSupports() const;
+
+    void SetEntryIndex(RCT12ObjectEntryIndex newIndex);
+    void SetAge(uint8_t newAge);
+    void SetSceneryQuadrant(uint8_t newQuadrant);
+    void SetPrimaryColour(colour_t colour);
+    void SetSecondaryColour(colour_t colour);
+    void SetNeedsSupports();
+};
+static_assert(sizeof(RCT12SmallSceneryElement) == (8), "Improper struct size");
+struct RCT12LargeSceneryElement : RCT12TileElementBase
+{
+private:
+    uint16_t entryIndex;
+    uint8_t colour[2];
+public:
+    uint32_t GetEntryIndex() const;
+    uint16_t GetSequenceIndex() const;
+    colour_t GetPrimaryColour() const;
+    colour_t GetSecondaryColour() const;
+    uint8_t GetBannerIndex() const;
+
+    void SetEntryIndex(uint32_t newIndex);
+    void SetSequenceIndex(uint16_t sequence);
+    void SetPrimaryColour(colour_t colour);
+    void SetSecondaryColour(colour_t colour);
+    void SetBannerIndex(uint8_t newIndex);
+};
+static_assert(sizeof(RCT12LargeSceneryElement) == (8), "Improper struct size");
+struct RCT12WallElement : RCT12TileElementBase
+{
+private:
+    uint8_t entryIndex;
+    union
+    {
+        uint8_t colour_3;
+        uint8_t banner_index;
+    };
+    uint8_t colour_1;
+    uint8_t animation;
+public:
+    RCT12ObjectEntryIndex GetEntryIndex() const;
+    uint8_t GetSlope() const;
+    colour_t GetPrimaryColour() const;
+    colour_t GetSecondaryColour() const;
+    colour_t GetTertiaryColour() const;
+    uint8_t GetAnimationFrame() const;
+    uint8_t GetBannerIndex() const;
+    bool IsAcrossTrack() const;
+    bool AnimationIsBackwards() const;
+    int32_t GetRCT1WallType(int32_t edge) const;
+    colour_t GetRCT1WallColour() const;
+    uint8_t GetRCT1Slope() const;
+
+    void SetEntryIndex(RCT12ObjectEntryIndex newIndex);
+    void SetSlope(uint8_t newslope);
+    void SetPrimaryColour(colour_t newColour);
+    void SetSecondaryColour(colour_t newColour);
+    void SetTertiaryColour(colour_t newColour);
+    void SetAnimationFrame(uint8_t frameNum);
+    void SetBannerIndex(uint8_t newIndex);
+    void SetAcrossTrack(bool acrossTrack);
+    void SetAnimationIsBackwards(bool isBackwards);
+};
+static_assert(sizeof(RCT12WallElement) == (8), "Improper struct size");
+struct RCT12EntranceElement : RCT12TileElementBase
+{
+private:
+    uint8_t entranceType;
+    uint8_t index;
+    uint8_t pathType;
+    uint8_t rideIndex;
+public:
+    uint8_t GetEntranceType() const;
+    uint8_t GetRideIndex() const;
+    uint8_t GetStationIndex() const;
+    uint8_t GetSequenceIndex() const;
+    uint8_t GetPathType() const;
+
+    void SetEntranceType(uint8_t newType);
+    void SetRideIndex(uint8_t newRideIndex);
+    void SetStationIndex(uint8_t stationIndex);
+    void SetSequenceIndex(uint8_t newSequenceIndex);
+    void SetPathType(uint8_t newPathType);
+};
+static_assert(sizeof(RCT12EntranceElement) == (8), "Improper struct size");
+struct RCT12BannerElement : RCT12TileElementBase
+{
+private:
+    uint8_t index;
+    uint8_t position;
+    uint8_t AllowedEdges;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint8_t unused;
+#pragma clang diagnostic pop
+public:
+    uint8_t GetIndex() const;
+    uint8_t GetPosition() const;
+    uint8_t GetAllowedEdges() const;
+
+    void SetIndex(uint8_t newIndex);
+    void SetPosition(uint8_t newPosition);
+    void SetAllowedEdges(uint8_t newEdges);
+};
+static_assert(sizeof(RCT12BannerElement) == (8), "Improper struct size");
+
+struct RCT12CorruptElement : RCT12TileElementBase
+{
+    uint8_t pad[4];
+};
+static_assert(sizeof(RCT12CorruptElement) == (8), "Improper struct size");
+
+struct RCT12EightCarsCorruptElement14 : RCT12TileElementBase
+{
+    uint8_t pad[4];
+};
+static_assert(sizeof(RCT12EightCarsCorruptElement14) == (8), "Improper struct size");
+
+struct RCT12EightCarsCorruptElement15 : RCT12TileElementBase
+{
+    uint8_t pad[4];
+};
+static_assert(sizeof(RCT12EightCarsCorruptElement15) == (8), "Improper struct size");
+
+
+enum class RCT12EntityLinkListOffset : uint8_t
+{
+    Free = 0,
+    TrainHead = 1 * sizeof(uint16_t),
+    Peep = 2 * sizeof(uint16_t),
+    Misc = 3 * sizeof(uint16_t),
+    Litter = 4 * sizeof(uint16_t),
+    Vehicle = 5 * sizeof(uint16_t),
+};
+
+enum class RCT12SpriteIdentifier : uint8_t
+{
+    Vehicle = 0,
+    Peep = 1,
+    Misc = 2,
+    Litter = 3,
+    Null = 255
+};
+
+enum class RCT12MiscEntityType : uint8_t
+{
+    SteamParticle,
+    MoneyEffect,
+    CrashedVehicleParticle,
+    ExplosionCloud,
+    CrashSplash,
+    ExplosionFlare,
+    JumpingFountainWater,
+    Balloon,
+    Duck,
+    JumpingFountainSnow
+};
+
+enum class RCT12PeepType : uint8_t
+{
+    Guest,
+    Staff,
+
+    Invalid = 0xFF
+};
+
+struct RCT12SpriteBase
+{
+    RCT12SpriteIdentifier sprite_identifier;
+    uint8_t type;
+    uint16_t next_in_quadrant;
+    uint16_t next;
+    uint16_t previous;
+    RCT12EntityLinkListOffset linked_list_type_offset;
+    uint8_t sprite_height_negative;
+    uint16_t sprite_index;
+    uint16_t flags;
+    int16_t x;
+    int16_t y;
+    int16_t z;
+    uint8_t sprite_width;
+    uint8_t sprite_height_positive;
+    int16_t sprite_left;
+    int16_t sprite_top;
+    int16_t sprite_right;
+    int16_t sprite_bottom;
+    uint8_t sprite_direction;
+};
+static_assert(sizeof(RCT12SpriteBase) == (0x1F), "Improper struct size");
+
+struct RCT12SpriteBalloon : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x24 - 0x1F];
+    uint16_t popped;
+    uint8_t time_to_move;
+    uint8_t frame;
+    uint8_t pad_28[4];
+    uint8_t colour;
+};
+static_assert(sizeof(RCT12SpriteBalloon) == (0x2D), "Improper struct size");
+
+struct RCT12SpriteDuck : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x26 - 0x1F];
+    uint16_t frame;
+    uint8_t pad_28[0x30 - 0x28];
+    int16_t target_x;
+    int16_t target_y;
+    uint8_t pad_34[0x14];
+    uint8_t state;
+};
+static_assert(sizeof(RCT12SpriteDuck) == (0x49), "Improper struct size");
+
+struct RCT12SpriteLitter : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x24 - 0x1F];
+    uint32_t creationTick;
+};
+static_assert(sizeof(RCT12SpriteLitter) == (0x28), "Improper struct size");
+
+struct RCT12SpriteParticle : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x26 - 0x1F];
+    uint16_t frame;
+};
+static_assert(sizeof(RCT12SpriteParticle) == (0x28), "Improper struct size");
+
+struct RCT12SpriteJumpingFountain : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x26 - 0x1F];
+    uint8_t num_ticks_alive;
+    uint8_t frame;
+    uint8_t pad_28[0x2F - 0x28];
+    uint8_t fountain_flags;
+    int16_t target_x;
+    int16_t target_y;
+    uint8_t pad_34[0x46 - 0x34];
+    uint16_t iteration;
+};
+static_assert(sizeof(RCT12SpriteJumpingFountain) == (0x48), "Improper struct size");
+
+struct RCT12SpriteMoneyEffect : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x24 - 0x1F];
+    uint16_t move_delay;
+    uint8_t num_movements;
+    uint8_t vertical;
+    money32 value;
+    uint8_t pad_2C[0x44 - 0x2C];
+    int16_t offset_x;
+    uint16_t wiggle;
+};
+static_assert(sizeof(RCT12SpriteMoneyEffect) == (0x48), "Improper struct size");
+
+struct RCT12SpriteCrashedVehicleParticle : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x24 - 0x1F];
+    uint16_t time_to_live;
+    uint16_t frame;
+    uint8_t pad_28[0x2C - 0x28];
+    uint8_t colour[2];
+    uint16_t crashed_sprite_base;
+    int16_t velocity_x;
+    int16_t velocity_y;
+    int16_t velocity_z;
+    uint8_t pad_36[0x38 - 0x36];
+    int32_t acceleration_x;
+    int32_t acceleration_y;
+    int32_t acceleration_z;
+};
+static_assert(sizeof(RCT12SpriteCrashedVehicleParticle) == (0x44), "Improper struct size");
+
+struct RCT12SpriteCrashSplash : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x26 - 0x1F];
+    uint16_t frame;
+};
+static_assert(sizeof(RCT12SpriteCrashSplash) == (0x28), "Improper struct size");
+
+struct RCT12SpriteSteamParticle : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x24 - 0x1F];
+    uint16_t time_to_move;
+    uint16_t frame;
+};
+static_assert(sizeof(RCT12SpriteSteamParticle) == (0x28), "Improper struct size");
+
+struct RCT12PeepThought
+{
+    uint8_t type;
+    uint8_t item;
+    uint8_t freshness;
+    uint8_t fresh_timeout;
+};
+static_assert(sizeof(RCT12PeepThought) == (4), "Improper struct size");
+
+struct RCT12RideMeasurement
+{
+    uint8_t ride_index;
+    uint8_t flags;
+    uint32_t last_use_tick;
+    uint16_t num_items;
+    uint16_t current_item;
+    uint8_t vehicle_index;
+    uint8_t current_station;
+    int8_t vertical[RCT12_RIDE_MEASUREMENT_MAX_ITEMS];
+    int8_t lateral[RCT12_RIDE_MEASUREMENT_MAX_ITEMS];
+    uint8_t velocity[RCT12_RIDE_MEASUREMENT_MAX_ITEMS];
+    uint8_t altitude[RCT12_RIDE_MEASUREMENT_MAX_ITEMS];
+};
+static_assert(sizeof(RCT12RideMeasurement) == (0x4B0C), "Improper struct size");
+
+struct RCT12Banner
+{
+    RCT12ObjectEntryIndex type;
+    uint8_t flags;
+    rct_string_id string_idx;
+    union
+    {
+        uint8_t colour;
+        uint8_t ride_index;
+    };
+    uint8_t text_colour;
+    uint8_t x;
+    uint8_t y;
+};
+static_assert(sizeof(RCT12Banner) == (8), "Improper struct size");
+
+struct RCT12MapAnimation
+{
+    uint8_t baseZ;
+    uint8_t type;
+    uint16_t x;
+    uint16_t y;
+};
+static_assert(sizeof(RCT12MapAnimation) == (6), "Improper struct size");
+
+struct RCT12ResearchItem
+{
+
+    union
+    {
+        uint32_t rawValue;
+        struct
+        {
+            RCT12ObjectEntryIndex entryIndex;
+            uint8_t baseRideType;
+            uint8_t type;
+            uint8_t flags;
+        };
+    };
+    uint8_t category;
+
+    bool IsInventedEndMarker() const;
+    bool IsRandomEndMarker() const;
+    bool IsUninventedEndMarker() const;
+};
+static_assert(sizeof(RCT12ResearchItem) == (5), "Improper struct size");
+
+#pragma pack(pop)
+
+ObjectEntryIndex RCTEntryIndexToOpenRCT2EntryIndex(const RCT12ObjectEntryIndex index);
+RCT12ObjectEntryIndex OpenRCT2EntryIndexToRCTEntryIndex(const ObjectEntryIndex index);
+ride_id_t RCT12RideIdToOpenRCT2RideId(const RCT12RideId rideId);
+RCT12RideId OpenRCT2RideIdToRCT12RideId(const ride_id_t rideId);
+bool IsLikelyUTF8(std::string_view s);
+std::string RCT12RemoveFormattingUTF8(std::string_view s);
+std::string ConvertFormattedStringToOpenRCT2(std::string_view buffer);
+std::string ConvertFormattedStringToRCT2(std::string_view buffer, size_t maxLength);
+std::string GetTruncatedRCT2String(std::string_view src, size_t maxLength);
+track_type_t RCT12FlatTrackTypeToOpenRCT2(RCT12TrackType origTrackType);
+RCT12TrackType OpenRCT2FlatTrackTypeToRCT12(track_type_t origTrackType);
+void RCT12AddDefaultObjects(ObjectList& objectList);
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/RCT2.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/RCT2.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/RCT2.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../core/FileSystem.hpp" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../core/FileSystem.hpp"
+       
+# 35 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../core/FileSystem.hpp"
+# 1 "/usr/include/c++/10.2.0/filesystem" 1 3
+# 33 "/usr/include/c++/10.2.0/filesystem" 3
+       
+# 34 "/usr/include/c++/10.2.0/filesystem" 3
+# 36 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../core/FileSystem.hpp" 2
+namespace fs = std::filesystem;
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/RCT2.h" 2
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../ride/RideRatings.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../ride/RideRatings.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../ride/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../ride/RideRatings.h" 2
+
+
+
+using ride_rating = fixed16_2dp;
+using track_type_t = uint16_t;
+
+
+
+
+
+
+#pragma pack(push, 1)
+
+
+struct RatingTuple
+{
+    ride_rating Excitement;
+    ride_rating Intensity;
+    ride_rating Nausea;
+};
+static_assert(sizeof(RatingTuple) == (6), "Improper struct size");
+
+#pragma pack(pop)
+
+enum
+{
+    RIDE_RATING_STATION_FLAG_NO_ENTRANCE = 1 << 0
+};
+
+struct RideRatingCalculationData
+{
+    CoordsXYZ Proximity;
+    CoordsXYZ ProximityStart;
+    ride_id_t CurrentRide;
+    uint8_t State;
+    track_type_t ProximityTrackType;
+    uint8_t ProximityBaseHeight;
+    uint16_t ProximityTotal;
+    uint16_t ProximityScores[26];
+    uint16_t AmountOfBrakes;
+    uint16_t AmountOfReversers;
+    uint16_t StationFlags;
+};
+
+extern RideRatingCalculationData gRideRatingsCalcData;
+
+void ride_ratings_update_ride(const Ride& ride);
+void ride_ratings_update_all();
+
+using ride_ratings_calculation = void (*)(Ride* ride);
+ride_ratings_calculation ride_ratings_get_calculate_func(uint8_t rideType);
+
+void ride_ratings_calculate_spiral_roller_coaster(Ride* ride);
+void ride_ratings_calculate_stand_up_roller_coaster(Ride* ride);
+void ride_ratings_calculate_suspended_swinging_coaster(Ride* ride);
+void ride_ratings_calculate_inverted_roller_coaster(Ride* ride);
+void ride_ratings_calculate_junior_roller_coaster(Ride* ride);
+void ride_ratings_calculate_miniature_railway(Ride* ride);
+void ride_ratings_calculate_monorail(Ride* ride);
+void ride_ratings_calculate_mini_suspended_coaster(Ride* ride);
+void ride_ratings_calculate_boat_hire(Ride* ride);
+void ride_ratings_calculate_wooden_wild_mouse(Ride* ride);
+void ride_ratings_calculate_steeplechase(Ride* ride);
+void ride_ratings_calculate_car_ride(Ride* ride);
+void ride_ratings_calculate_launched_freefall(Ride* ride);
+void ride_ratings_calculate_bobsleigh_coaster(Ride* ride);
+void ride_ratings_calculate_observation_tower(Ride* ride);
+void ride_ratings_calculate_looping_roller_coaster(Ride* ride);
+void ride_ratings_calculate_dinghy_slide(Ride* ride);
+void ride_ratings_calculate_mine_train_coaster(Ride* ride);
+void ride_ratings_calculate_chairlift(Ride* ride);
+void ride_ratings_calculate_corkscrew_roller_coaster(Ride* ride);
+void ride_ratings_calculate_maze(Ride* ride);
+void ride_ratings_calculate_spiral_slide(Ride* ride);
+void ride_ratings_calculate_go_karts(Ride* ride);
+void ride_ratings_calculate_log_flume(Ride* ride);
+void ride_ratings_calculate_river_rapids(Ride* ride);
+void ride_ratings_calculate_dodgems(Ride* ride);
+void ride_ratings_calculate_swinging_ship(Ride* ride);
+void ride_ratings_calculate_inverter_ship(Ride* ride);
+void ride_ratings_calculate_food_stall(Ride* ride);
+void ride_ratings_calculate_shop(Ride* ride);
+void ride_ratings_calculate_merry_go_round(Ride* ride);
+void ride_ratings_calculate_information_kiosk(Ride* ride);
+void ride_ratings_calculate_toilets(Ride* ride);
+void ride_ratings_calculate_ferris_wheel(Ride* ride);
+void ride_ratings_calculate_motion_simulator(Ride* ride);
+void ride_ratings_calculate_3d_cinema(Ride* ride);
+void ride_ratings_calculate_top_spin(Ride* ride);
+void ride_ratings_calculate_space_rings(Ride* ride);
+void ride_ratings_calculate_reverse_freefall_coaster(Ride* ride);
+void ride_ratings_calculate_lift(Ride* ride);
+void ride_ratings_calculate_vertical_drop_roller_coaster(Ride* ride);
+void ride_ratings_calculate_cash_machine(Ride* ride);
+void ride_ratings_calculate_twist(Ride* ride);
+void ride_ratings_calculate_haunted_house(Ride* ride);
+void ride_ratings_calculate_first_aid(Ride* ride);
+void ride_ratings_calculate_circus(Ride* ride);
+void ride_ratings_calculate_ghost_train(Ride* ride);
+void ride_ratings_calculate_twister_roller_coaster(Ride* ride);
+void ride_ratings_calculate_wooden_roller_coaster(Ride* ride);
+void ride_ratings_calculate_side_friction_roller_coaster(Ride* ride);
+void ride_ratings_calculate_wild_mouse(Ride* ride);
+void ride_ratings_calculate_multi_dimension_roller_coaster(Ride* ride);
+void ride_ratings_calculate_flying_roller_coaster(Ride* ride);
+void ride_ratings_calculate_virginia_reel(Ride* ride);
+void ride_ratings_calculate_splash_boats(Ride* ride);
+void ride_ratings_calculate_mini_helicopters(Ride* ride);
+void ride_ratings_calculate_lay_down_roller_coaster(Ride* ride);
+void ride_ratings_calculate_suspended_monorail(Ride* ride);
+void ride_ratings_calculate_reverser_roller_coaster(Ride* ride);
+void ride_ratings_calculate_heartline_twister_coaster(Ride* ride);
+void ride_ratings_calculate_mini_golf(Ride* ride);
+void ride_ratings_calculate_giga_coaster(Ride* ride);
+void ride_ratings_calculate_roto_drop(Ride* ride);
+void ride_ratings_calculate_flying_saucers(Ride* ride);
+void ride_ratings_calculate_crooked_house(Ride* ride);
+void ride_ratings_calculate_monorail_cycles(Ride* ride);
+void ride_ratings_calculate_compact_inverted_coaster(Ride* ride);
+void ride_ratings_calculate_water_coaster(Ride* ride);
+void ride_ratings_calculate_air_powered_vertical_coaster(Ride* ride);
+void ride_ratings_calculate_inverted_hairpin_coaster(Ride* ride);
+void ride_ratings_calculate_magic_carpet(Ride* ride);
+void ride_ratings_calculate_submarine_ride(Ride* ride);
+void ride_ratings_calculate_river_rafts(Ride* ride);
+void ride_ratings_calculate_enterprise(Ride* ride);
+void ride_ratings_calculate_inverted_impulse_coaster(Ride* ride);
+void ride_ratings_calculate_mini_roller_coaster(Ride* ride);
+void ride_ratings_calculate_mine_ride(Ride* ride);
+void ride_ratings_calculate_lim_launched_roller_coaster(Ride* ride);
+void ride_ratings_calculate_hybrid_coaster(Ride* ride);
+void ride_ratings_calculate_single_rail_roller_coaster(Ride* ride);
+void ride_ratings_calculate_drink_stall(Ride* ride);
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/RCT2.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../ride/VehicleColour.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/../ride/VehicleColour.h"
+       
+
+
+
+struct rct_vehicle_colour
+{
+    uint8_t body_colour;
+    uint8_t trim_colour;
+};
+
+struct VehicleColour
+{
+    uint8_t Body;
+    uint8_t Trim;
+    uint8_t Ternary;
+};
+# 18 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../rct2/RCT2.h" 2
+
+
+
+constexpr const uint8_t RCT2_MAX_STAFF = 200;
+constexpr const uint8_t RCT2_MAX_BANNERS_IN_PARK = 250;
+constexpr const uint8_t RCT2_MAX_VEHICLES_PER_RIDE = 31;
+constexpr const uint8_t RCT2_MAX_CARS_PER_TRAIN = 32;
+constexpr const uint8_t RCT2_MAX_CATEGORIES_PER_RIDE = 2;
+constexpr const uint8_t RCT2_MAX_RIDE_TYPES_PER_RIDE_ENTRY = 3;
+constexpr const uint8_t RCT2_MAX_VEHICLES_PER_RIDE_ENTRY = 4;
+constexpr const uint8_t RCT2_DOWNTIME_HISTORY_SIZE = 8;
+constexpr const uint8_t RCT2_CUSTOMER_HISTORY_SIZE = 10;
+constexpr const uint16_t RCT2_MAX_SPRITES = 10000;
+constexpr const uint32_t RCT2_MAX_TILE_ELEMENTS = 0x30000;
+constexpr const uint16_t RCT2_MAX_ANIMATED_OBJECTS = 2000;
+constexpr const uint8_t RCT2_MAX_RESEARCHED_RIDE_TYPE_QUADS = 8;
+
+constexpr const uint8_t RCT2_MAX_RESEARCHED_RIDE_ENTRY_QUADS = 8;
+
+constexpr const uint8_t RCT2_MAX_RESEARCHED_SCENERY_ITEM_QUADS = 56;
+constexpr const uint16_t RCT2_MAX_RESEARCHED_SCENERY_ITEMS = (RCT2_MAX_RESEARCHED_SCENERY_ITEM_QUADS * 32);
+
+constexpr uint16_t TD6MaxTrackElements = 8192;
+
+constexpr const uint8_t RCT2_MAX_RIDE_OBJECTS = 128;
+constexpr const uint8_t RCT2_MAX_SMALL_SCENERY_OBJECTS = 252;
+constexpr const uint8_t RCT2_MAX_LARGE_SCENERY_OBJECTS = 128;
+constexpr const uint8_t RCT2_MAX_WALL_SCENERY_OBJECTS = 128;
+constexpr const uint8_t RCT2_MAX_BANNER_OBJECTS = 32;
+constexpr const uint8_t RCT2_MAX_PATH_OBJECTS = 16;
+constexpr const uint8_t RCT2_MAX_PATH_ADDITION_OBJECTS = 15;
+constexpr const uint8_t RCT2_MAX_SCENERY_GROUP_OBJECTS = 19;
+constexpr const uint8_t RCT2_MAX_PARK_ENTRANCE_OBJECTS = 1;
+constexpr const uint8_t RCT2_MAX_WATER_OBJECTS = 1;
+constexpr const uint8_t RCT2_MAX_SCENARIO_TEXT_OBJECTS = 1;
+constexpr const uint8_t RCT2_RIDE_TYPE_COUNT = 91;
+
+constexpr const rct_string_id RCT2_RIDE_STRING_START = 2;
+
+constexpr const uint16_t RCT2_MAXIMUM_MAP_SIZE_TECHNICAL = 256;
+
+
+constexpr const uint16_t RCT2_OBJECT_ENTRY_COUNT =
+    RCT2_MAX_RIDE_OBJECTS +
+    RCT2_MAX_SMALL_SCENERY_OBJECTS +
+    RCT2_MAX_LARGE_SCENERY_OBJECTS +
+    RCT2_MAX_WALL_SCENERY_OBJECTS +
+    RCT2_MAX_BANNER_OBJECTS +
+    RCT2_MAX_PATH_OBJECTS +
+    RCT2_MAX_PATH_ADDITION_OBJECTS +
+    RCT2_MAX_SCENERY_GROUP_OBJECTS +
+    RCT2_MAX_PARK_ENTRANCE_OBJECTS +
+    RCT2_MAX_WATER_OBJECTS +
+    RCT2_MAX_SCENARIO_TEXT_OBJECTS;
+
+static_assert(RCT2_OBJECT_ENTRY_COUNT == 721);
+
+
+constexpr const int32_t rct2_object_entry_group_counts[] = {
+    RCT2_MAX_RIDE_OBJECTS,
+    RCT2_MAX_SMALL_SCENERY_OBJECTS,
+    RCT2_MAX_LARGE_SCENERY_OBJECTS,
+    RCT2_MAX_WALL_SCENERY_OBJECTS,
+    RCT2_MAX_BANNER_OBJECTS,
+    RCT2_MAX_PATH_OBJECTS,
+    RCT2_MAX_PATH_ADDITION_OBJECTS,
+    RCT2_MAX_SCENERY_GROUP_OBJECTS,
+    RCT2_MAX_PARK_ENTRANCE_OBJECTS,
+    RCT2_MAX_WATER_OBJECTS,
+    RCT2_MAX_SCENARIO_TEXT_OBJECTS,
+};
+
+
+#pragma pack(push, 1)
+
+struct rct_ride_entry;
+
+
+
+
+
+struct rct2_ride
+{
+    uint8_t type;
+
+
+    RCT12ObjectEntryIndex subtype;
+    uint16_t pad_002;
+    uint8_t mode;
+    uint8_t colour_scheme_type;
+    rct_vehicle_colour vehicle_colours[RCT2_MAX_CARS_PER_TRAIN];
+    uint8_t pad_046[0x03];
+
+    uint8_t status;
+    rct_string_id name;
+    union
+    {
+        uint32_t name_arguments;
+        struct
+        {
+            rct_string_id name_arguments_type_name;
+            uint16_t name_arguments_number;
+        };
+    };
+    RCT12xy8 overall_view;
+    RCT12xy8 station_starts[RCT12_MAX_STATIONS_PER_RIDE];
+    uint8_t station_heights[RCT12_MAX_STATIONS_PER_RIDE];
+    uint8_t station_length[RCT12_MAX_STATIONS_PER_RIDE];
+    uint8_t station_depart[RCT12_MAX_STATIONS_PER_RIDE];
+
+
+    uint8_t train_at_station[RCT12_MAX_STATIONS_PER_RIDE];
+    RCT12xy8 entrances[RCT12_MAX_STATIONS_PER_RIDE];
+    RCT12xy8 exits[RCT12_MAX_STATIONS_PER_RIDE];
+    uint16_t last_peep_in_queue[RCT12_MAX_STATIONS_PER_RIDE];
+    uint8_t pad_082[RCT12_MAX_STATIONS_PER_RIDE];
+    uint16_t vehicles[RCT2_MAX_VEHICLES_PER_RIDE + 1];
+    uint8_t depart_flags;
+
+
+    uint8_t num_stations;
+    uint8_t num_vehicles;
+    uint8_t num_cars_per_train;
+    uint8_t proposed_num_vehicles;
+    uint8_t proposed_num_cars_per_train;
+    uint8_t max_trains;
+    uint8_t min_max_cars_per_train;
+    uint8_t min_waiting_time;
+    uint8_t max_waiting_time;
+    union
+    {
+        uint8_t operation_option;
+        uint8_t time_limit;
+        uint8_t num_laps;
+        uint8_t launch_speed;
+        uint8_t speed;
+        uint8_t rotations;
+    };
+
+    uint8_t boat_hire_return_direction;
+    RCT12xy8 boat_hire_return_position;
+    uint8_t measurement_index;
+
+
+
+
+    uint8_t special_track_elements;
+    uint8_t pad_0D6[2];
+
+
+    int32_t max_speed;
+    int32_t average_speed;
+    uint8_t current_test_segment;
+    uint8_t average_speed_test_timeout;
+    uint8_t pad_0E2[0x2];
+    int32_t length[RCT12_MAX_STATIONS_PER_RIDE];
+    uint16_t time[RCT12_MAX_STATIONS_PER_RIDE];
+    fixed16_2dp max_positive_vertical_g;
+    fixed16_2dp max_negative_vertical_g;
+    fixed16_2dp max_lateral_g;
+    fixed16_2dp previous_vertical_g;
+    fixed16_2dp previous_lateral_g;
+    uint8_t pad_106[0x2];
+    uint32_t testing_flags;
+
+
+    RCT12xy8 cur_test_track_location;
+
+    uint16_t turn_count_default;
+    uint16_t turn_count_banked;
+    uint16_t turn_count_sloped;
+    union
+    {
+        uint8_t inversions;
+        uint8_t holes;
+
+
+        uint8_t sheltered_eighths;
+    };
+
+    uint8_t drops;
+    uint8_t start_drop_height;
+    uint8_t highest_drop_height;
+    int32_t sheltered_length;
+
+    uint16_t var_11C;
+    uint8_t num_sheltered_sections;
+
+    uint8_t cur_test_track_z;
+
+    uint16_t cur_num_customers;
+
+    uint16_t num_customers_timeout;
+
+    uint16_t num_customers[RCT2_CUSTOMER_HISTORY_SIZE];
+    money16 price;
+    RCT12xy8 chairlift_bullwheel_location[2];
+    uint8_t chairlift_bullwheel_z[2];
+    union
+    {
+        RatingTuple ratings;
+        struct
+        {
+            ride_rating excitement;
+            ride_rating intensity;
+            ride_rating nausea;
+        };
+    };
+    uint16_t value;
+    uint16_t chairlift_bullwheel_rotation;
+    uint8_t satisfaction;
+    uint8_t satisfaction_time_out;
+    uint8_t satisfaction_next;
+
+    uint8_t window_invalidate_flags;
+    uint8_t pad_14E[0x02];
+    uint32_t total_customers;
+    money32 total_profit;
+    uint8_t popularity;
+    uint8_t popularity_time_out;
+    uint8_t popularity_next;
+    uint8_t num_riders;
+    uint8_t music_tune_id;
+    uint8_t slide_in_use;
+    union
+    {
+        uint16_t slide_peep;
+        uint16_t maze_tiles;
+    };
+    uint8_t pad_160[0xE];
+    uint8_t slide_peep_t_shirt_colour;
+    uint8_t pad_16F[0x7];
+    uint8_t spiral_slide_progress;
+    uint8_t pad_177[0x9];
+    int16_t build_date;
+    money16 upkeep_cost;
+    uint16_t race_winner;
+    uint8_t pad_186[0x02];
+    uint32_t music_position;
+    uint8_t breakdown_reason_pending;
+    uint8_t mechanic_status;
+    uint16_t mechanic;
+    uint8_t inspection_station;
+    uint8_t broken_vehicle;
+    uint8_t broken_car;
+    uint8_t breakdown_reason;
+    money16 price_secondary;
+    union
+    {
+        struct
+        {
+            uint8_t reliability_subvalue;
+            uint8_t reliability_percentage;
+        };
+        uint16_t reliability;
+    };
+
+
+    uint8_t unreliability_factor;
+
+    uint8_t downtime;
+    uint8_t inspection_interval;
+    uint8_t last_inspection;
+    uint8_t downtime_history[RCT2_DOWNTIME_HISTORY_SIZE];
+    uint32_t no_primary_items_sold;
+    uint32_t no_secondary_items_sold;
+    uint8_t breakdown_sound_modifier;
+
+
+    uint8_t not_fixed_timeout;
+    uint8_t last_crash_type;
+    uint8_t connected_message_throttle;
+    money32 income_per_hour;
+    money32 profit;
+    uint8_t queue_time[RCT12_MAX_STATIONS_PER_RIDE];
+    uint8_t track_colour_main[RCT12_NUM_COLOUR_SCHEMES];
+    uint8_t track_colour_additional[RCT12_NUM_COLOUR_SCHEMES];
+    uint8_t track_colour_supports[RCT12_NUM_COLOUR_SCHEMES];
+    uint8_t music;
+    uint8_t entrance_style;
+    uint16_t vehicle_change_timeout;
+    uint8_t num_block_brakes;
+    uint8_t lift_hill_speed;
+    uint16_t guests_favourite;
+    uint32_t lifecycle_flags;
+    uint8_t vehicle_colours_extended[RCT2_MAX_CARS_PER_TRAIN];
+    uint16_t total_air_time;
+    uint8_t current_test_station;
+    uint8_t num_circuits;
+    int16_t cable_lift_x;
+    int16_t cable_lift_y;
+    uint8_t cable_lift_z;
+    uint8_t pad_1FD;
+    uint16_t cable_lift;
+    uint16_t queue_length[RCT12_MAX_STATIONS_PER_RIDE];
+    uint8_t pad_208[0x58];
+
+    uint8_t GetMinCarsPerTrain() const;
+    uint8_t GetMaxCarsPerTrain() const;
+    void SetMinCarsPerTrain(uint8_t newValue);
+    void SetMaxCarsPerTrain(uint8_t newValue);
+};
+static_assert(sizeof(rct2_ride) == (0x260), "Improper struct size");
+
+
+struct rct_td6_entrance_element
+{
+    int8_t z;
+    uint8_t direction;
+    int16_t x;
+    int16_t y;
+};
+static_assert(sizeof(rct_td6_entrance_element) == (0x06), "Improper struct size");
+
+
+struct rct_td6_scenery_element
+{
+    rct_object_entry scenery_object;
+    int8_t x;
+    int8_t y;
+    int8_t z;
+    uint8_t flags;
+    uint8_t primary_colour;
+    uint8_t secondary_colour;
+};
+static_assert(sizeof(rct_td6_scenery_element) == (0x16), "Improper struct size");
+
+
+
+
+
+struct rct_track_td6
+{
+    uint8_t type;
+    RCT12ObjectEntryIndex vehicle_type;
+    union
+    {
+
+
+        money32 cost;
+        uint32_t flags;
+    };
+    union
+    {
+
+
+        uint8_t ride_mode;
+        uint8_t track_flags;
+    };
+    uint8_t version_and_colour_scheme;
+    rct_vehicle_colour vehicle_colours[RCT2_MAX_CARS_PER_TRAIN];
+    union
+    {
+        uint8_t pad_48;
+        uint8_t track_spine_colour_rct1;
+    };
+    union
+    {
+        uint8_t entrance_style;
+        uint8_t track_rail_colour_rct1;
+    };
+    union
+    {
+        uint8_t total_air_time;
+        uint8_t track_support_colour_rct1;
+    };
+    uint8_t depart_flags;
+    uint8_t number_of_trains;
+    uint8_t number_of_cars_per_train;
+    uint8_t min_waiting_time;
+    uint8_t max_waiting_time;
+    uint8_t operation_setting;
+    int8_t max_speed;
+    int8_t average_speed;
+    uint16_t ride_length;
+    uint8_t max_positive_vertical_g;
+    int8_t max_negative_vertical_g;
+    uint8_t max_lateral_g;
+    union
+    {
+        uint8_t inversions;
+        uint8_t holes;
+    };
+    uint8_t drops;
+    uint8_t highest_drop_height;
+    uint8_t excitement;
+    uint8_t intensity;
+    uint8_t nausea;
+    money16 upkeep_cost;
+    uint8_t track_spine_colour[RCT12_NUM_COLOUR_SCHEMES];
+    uint8_t track_rail_colour[RCT12_NUM_COLOUR_SCHEMES];
+    uint8_t track_support_colour[RCT12_NUM_COLOUR_SCHEMES];
+    uint32_t flags2;
+    rct_object_entry vehicle_object;
+    uint8_t space_required_x;
+    uint8_t space_required_y;
+    uint8_t vehicle_additional_colour[RCT2_MAX_CARS_PER_TRAIN];
+    uint8_t lift_hill_speed_num_circuits;
+
+};
+static_assert(sizeof(rct_track_td6) == (0xA3), "Improper struct size");
+
+
+
+
+
+struct rct_scores_header
+{
+    uint32_t var_0;
+    uint32_t var_4;
+    uint32_t var_8;
+    uint32_t ScenarioCount;
+};
+static_assert(sizeof(rct_scores_header) == (0x10), "Improper struct size");
+
+
+
+
+
+struct rct_scores_entry
+{
+    char Path[256];
+    uint8_t Category;
+    uint8_t pad_0101[0x1F];
+    int8_t ObjectiveType;
+    int8_t ObjectiveArg1;
+    int32_t objectiveArg2;
+    int16_t objectiveArg3;
+    char Name[64];
+    char Details[256];
+    int32_t Flags;
+    money32 CompanyValue;
+    char CompletedBy[64];
+};
+static_assert(sizeof(rct_scores_entry) == (0x02B0), "Improper struct size");
+
+struct RCT2SpriteVehicle : RCT12SpriteBase
+{
+    uint8_t vehicle_sprite_type;
+    uint8_t bank_rotation;
+    uint8_t pad_21[3];
+    int32_t remaining_distance;
+    int32_t velocity;
+    int32_t acceleration;
+    uint8_t ride;
+    uint8_t vehicle_type;
+    rct_vehicle_colour colours;
+    union
+    {
+        uint16_t track_progress;
+        struct
+        {
+            int8_t var_34;
+            uint8_t var_35;
+        };
+    };
+    union
+    {
+        int16_t TrackTypeAndDirection;
+        RCT12xy8 boat_location;
+    };
+    uint16_t track_x;
+    uint16_t track_y;
+    uint16_t track_z;
+    uint16_t next_vehicle_on_train;
+    uint16_t prev_vehicle_on_ride;
+    uint16_t next_vehicle_on_ride;
+    uint16_t var_44;
+    uint16_t mass;
+    uint16_t update_flags;
+    uint8_t SwingSprite;
+    uint8_t current_station;
+    union
+    {
+        int16_t SwingPosition;
+        int16_t current_time;
+        struct
+        {
+            int8_t ferris_wheel_var_0;
+            int8_t ferris_wheel_var_1;
+        };
+    };
+    union
+    {
+        int16_t SwingSpeed;
+        int16_t crash_z;
+    };
+    uint8_t status;
+    uint8_t sub_state;
+    uint16_t peep[32];
+    uint8_t peep_tshirt_colours[32];
+    uint8_t num_seats;
+    uint8_t num_peeps;
+    uint8_t next_free_seat;
+    uint8_t restraints_position;
+    union
+    {
+        int16_t spin_speed;
+        int16_t crash_x;
+    };
+    uint16_t sound2_flags;
+    uint8_t spin_sprite;
+    uint8_t sound1_id;
+    uint8_t sound1_volume;
+    uint8_t sound2_id;
+    uint8_t sound2_volume;
+    int8_t sound_vector_factor;
+    union
+    {
+        uint16_t var_C0;
+        int16_t crash_y;
+        uint16_t time_waiting;
+        uint16_t cable_lift_target;
+    };
+    uint8_t speed;
+    uint8_t powered_acceleration;
+    union
+    {
+        uint8_t dodgems_collision_direction;
+        uint8_t var_C4;
+    };
+    uint8_t animation_frame;
+    uint8_t pad_C6[0x2];
+    uint16_t var_C8;
+    uint16_t var_CA;
+    uint8_t scream_sound_id;
+    uint8_t TrackSubposition;
+    union
+    {
+        uint8_t var_CE;
+        uint8_t num_laps;
+    };
+    union
+    {
+        uint8_t var_CF;
+        uint8_t brake_speed;
+    };
+    uint16_t lost_time_out;
+    int8_t vertical_drop_countdown;
+    uint8_t var_D3;
+    uint8_t mini_golf_current_animation;
+    uint8_t mini_golf_flags;
+    uint8_t ride_subtype;
+    uint8_t colours_extended;
+    uint8_t seat_rotation;
+    uint8_t target_seat_rotation;
+
+    uint16_t GetTrackType() const
+    {
+        return TrackTypeAndDirection >> 2;
+    }
+    uint8_t GetTrackDirection() const
+    {
+        return TrackTypeAndDirection & RCT12VehicleTrackDirectionMask;
+    }
+    void SetTrackType(uint16_t trackType)
+    {
+
+        TrackTypeAndDirection &= ~RCT12VehicleTrackTypeMask;
+        TrackTypeAndDirection |= trackType << 2;
+    }
+    void SetTrackDirection(uint8_t trackDirection)
+    {
+
+        TrackTypeAndDirection &= ~RCT12VehicleTrackDirectionMask;
+        TrackTypeAndDirection |= trackDirection & RCT12VehicleTrackDirectionMask;
+    }
+};
+static_assert(sizeof(RCT2SpriteVehicle) == (0xDA), "Improper struct size");
+
+struct RCT2SpritePeep : RCT12SpriteBase
+{
+    uint8_t pad_1F[0x22 - 0x1F];
+    rct_string_id name_string_idx;
+    uint16_t next_x;
+    uint16_t next_y;
+    uint8_t next_z;
+    uint8_t next_flags;
+    uint8_t outside_of_park;
+    uint8_t state;
+    uint8_t sub_state;
+    uint8_t sprite_type;
+    uint8_t peep_type;
+    union
+    {
+        uint8_t staff_type;
+        uint8_t no_of_rides;
+    };
+    uint8_t tshirt_colour;
+    uint8_t trousers_colour;
+    uint16_t destination_x;
+    uint16_t destination_y;
+    uint8_t destination_tolerance;
+    uint8_t var_37;
+    uint8_t energy;
+    uint8_t energy_target;
+    uint8_t happiness;
+    uint8_t happiness_target;
+    uint8_t nausea;
+    uint8_t nausea_target;
+    uint8_t hunger;
+    uint8_t thirst;
+    uint8_t toilet;
+    uint8_t mass;
+    uint8_t time_to_consume;
+    uint8_t intensity;
+    uint8_t nausea_tolerance;
+    uint8_t window_invalidate_flags;
+    money16 paid_on_drink;
+    uint8_t ride_types_been_on[16];
+    uint32_t item_extra_flags;
+    RCT12RideId photo2_ride_ref;
+    RCT12RideId photo3_ride_ref;
+    RCT12RideId photo4_ride_ref;
+    uint8_t pad_5F[0x09];
+    RCT12RideId current_ride;
+    uint8_t current_ride_station;
+    uint8_t current_train;
+    union
+    {
+        struct
+        {
+            uint8_t current_car;
+            uint8_t current_seat;
+        };
+        uint16_t time_to_sitdown;
+        struct
+        {
+            uint8_t time_to_stand;
+            uint8_t standing_flags;
+        };
+    };
+    uint8_t special_sprite;
+    uint8_t action_sprite_type;
+    uint8_t next_action_sprite_type;
+    uint8_t action_sprite_image_offset;
+    uint8_t action;
+    uint8_t action_frame;
+    uint8_t step_progress;
+    union
+    {
+        uint16_t mechanic_time_since_call;
+        uint16_t next_in_queue;
+    };
+    uint8_t pad_76;
+    uint8_t pad_77;
+    union
+    {
+        uint8_t maze_last_edge;
+        uint8_t direction;
+    };
+    RCT12RideId interaction_ride_index;
+    uint16_t time_in_queue;
+    uint8_t rides_been_on[32];
+    uint32_t id;
+    money32 cash_in_pocket;
+    money32 cash_spent;
+    int32_t park_entry_time;
+    int8_t rejoin_queue_timeout;
+    RCT12RideId previous_ride;
+    uint16_t previous_ride_time_out;
+    RCT12PeepThought thoughts[RCT12_PEEP_MAX_THOUGHTS];
+    uint8_t path_check_optimisation;
+    union
+    {
+        uint8_t staff_id;
+        RCT12RideId guest_heading_to_ride_id;
+    };
+    union
+    {
+        uint8_t staff_orders;
+        uint8_t peep_is_lost_countdown;
+    };
+    RCT12RideId photo1_ride_ref;
+    uint32_t peep_flags;
+    rct12_xyzd8 pathfind_goal;
+    rct12_xyzd8 pathfind_history[4];
+    uint8_t no_action_frame_num;
+    uint8_t litter_count;
+    union
+    {
+        uint8_t time_on_ride;
+        uint8_t staff_mowing_timeout;
+    };
+    uint8_t disgusting_count;
+    union
+    {
+        money16 paid_to_enter;
+        uint16_t staff_lawns_mown;
+        uint16_t staff_rides_fixed;
+    };
+    union
+    {
+        money16 paid_on_rides;
+        uint16_t staff_gardens_watered;
+        uint16_t staff_rides_inspected;
+    };
+    union
+    {
+        money16 paid_on_food;
+        uint16_t staff_litter_swept;
+    };
+    union
+    {
+        money16 paid_on_souvenirs;
+        uint16_t staff_bins_emptied;
+    };
+    uint8_t no_of_food;
+    uint8_t no_of_drinks;
+    uint8_t no_of_souvenirs;
+    uint8_t vandalism_seen;
+    uint8_t voucher_type;
+    RCT12RideId voucher_arguments;
+    uint8_t surroundings_thought_timeout;
+    uint8_t angriness;
+    uint8_t time_lost;
+    uint8_t days_in_queue;
+    uint8_t balloon_colour;
+    uint8_t umbrella_colour;
+    uint8_t hat_colour;
+    RCT12RideId favourite_ride;
+    uint8_t favourite_ride_rating;
+    uint8_t pad_FB;
+    uint32_t item_standard_flags;
+    uint64_t GetItemFlags() const
+    {
+        return item_standard_flags | (static_cast<uint64_t>(item_extra_flags) << 32);
+    }
+};
+static_assert(sizeof(RCT2SpritePeep) == (0x100), "Improper struct size");
+
+union RCT2Sprite
+{
+private:
+    uint8_t pad_00[0x100];
+
+public:
+    RCT12SpriteBase unknown;
+    RCT2SpriteVehicle vehicle;
+    RCT2SpritePeep peep;
+    RCT12SpriteLitter litter;
+    RCT12SpriteBalloon balloon;
+    RCT12SpriteDuck duck;
+    RCT12SpriteJumpingFountain jumping_fountain;
+    RCT12SpriteMoneyEffect money_effect;
+    RCT12SpriteCrashedVehicleParticle crashed_vehicle_particle;
+    RCT12SpriteCrashSplash crash_splash;
+    RCT12SpriteSteamParticle steam_particle;
+    RCT12SpriteParticle misc_particle;
+};
+static_assert(sizeof(RCT2Sprite) == (0x100), "Improper struct size");
+
+struct RCT2RideRatingCalculationData
+{
+    uint16_t proximity_x;
+    uint16_t proximity_y;
+    uint16_t proximity_z;
+    uint16_t proximity_start_x;
+    uint16_t proximity_start_y;
+    uint16_t proximity_start_z;
+    uint8_t current_ride;
+    uint8_t state;
+    uint8_t proximity_track_type;
+    uint8_t proximity_base_height;
+    uint16_t proximity_total;
+    uint16_t proximity_scores[26];
+    uint16_t num_brakes;
+    uint16_t num_reversers;
+    uint16_t station_flags;
+};
+static_assert(sizeof(RCT2RideRatingCalculationData) == (76), "Improper struct size");
+
+#pragma pack(pop)
+
+std::vector<uint8_t> DecryptSea(const fs::path& path);
+ObjectEntryIndex RCT2RideTypeToOpenRCT2RideType(uint8_t rct2RideType, const rct_ride_entry* rideEntry);
+bool RCT2TrackTypeIsBooster(uint8_t rideType, uint16_t trackType);
+bool RCT2RideTypeNeedsConversion(uint8_t rct2RideType);
+uint8_t OpenRCT2RideTypeToRCT2RideType(ObjectEntryIndex openrct2Type);
+track_type_t RCT2TrackTypeToOpenRCT2(RCT12TrackType origTrackType, uint8_t rideType);
+RCT12TrackType OpenRCT2TrackTypeToRCT2(track_type_t origTrackType);
+
+
+
+
+
+size_t GetRCT2StringBufferLen(const char* buffer, size_t maxBufferLen);
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Map.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Map.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Map.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/TileElement.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/TileElement.h"
+       
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../ride/Station.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../ride/Station.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../ride/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../ride/Station.h" 2
+
+struct Ride;
+struct TileCoordsXYZD;
+
+using StationIndex = uint8_t;
+
+constexpr const StationIndex STATION_INDEX_NULL = 0xFF;
+
+void ride_update_station(Ride* ride, StationIndex stationIndex);
+StationIndex ride_get_first_valid_station_exit(Ride* ride);
+StationIndex ride_get_first_valid_station_start(const Ride* ride);
+StationIndex ride_get_first_empty_station_start(const Ride* ride);
+
+TileCoordsXYZD ride_get_entrance_location(const Ride* ride, const StationIndex stationIndex);
+TileCoordsXYZD ride_get_exit_location(const Ride* ride, const StationIndex stationIndex);
+
+void ride_clear_entrance_location(Ride* ride, const StationIndex stationIndex);
+void ride_clear_exit_location(Ride* ride, const StationIndex stationIndex);
+
+void ride_set_entrance_location(Ride* ride, const StationIndex stationIndex, const TileCoordsXYZD& location);
+void ride_set_exit_location(Ride* ride, const StationIndex stationIndex, const TileCoordsXYZD& location);
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/TileElement.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Banner.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Banner.h"
+       
+
+
+
+
+
+
+
+class Formatter;
+struct TileElement;
+struct WallElement;
+
+using BannerIndex = uint16_t;
+
+constexpr ObjectEntryIndex BANNER_NULL = OBJECT_ENTRY_INDEX_NULL;
+constexpr size_t MAX_BANNERS = 250;
+constexpr BannerIndex BANNER_INDEX_NULL = static_cast<BannerIndex>(-1);
+
+constexpr uint8_t SCROLLING_MODE_NONE = 255;
+
+struct Banner
+{
+    ObjectEntryIndex type = BANNER_NULL;
+    uint8_t flags{};
+    std::string text;
+    uint8_t colour{};
+    ride_id_t ride_index{};
+    uint8_t text_colour{};
+    TileCoordsXY position;
+
+    bool IsNull() const
+    {
+        return type == BANNER_NULL;
+    }
+
+    std::string GetText() const;
+    void FormatTextTo(Formatter&, bool addColour) const;
+    void FormatTextTo(Formatter&) const;
+};
+
+enum BANNER_FLAGS
+{
+    BANNER_FLAG_NO_ENTRY = (1 << 0),
+    BANNER_FLAG_IS_LARGE_SCENERY = (1 << 1),
+    BANNER_FLAG_LINKED_TO_RIDE = (1 << 2),
+    BANNER_FLAG_IS_WALL = (1 << 3)
+};
+
+void banner_init();
+BannerIndex create_new_banner(uint8_t flags);
+TileElement* banner_get_tile_element(BannerIndex bannerIndex);
+WallElement* banner_get_scrolling_wall_tile_element(BannerIndex bannerIndex);
+ride_id_t banner_get_closest_ride_index(const CoordsXYZ& mapPos);
+void banner_reset_broken_index();
+void fix_duplicated_banners();
+Banner* GetBanner(BannerIndex id);
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/TileElement.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Footpath.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Footpath.h"
+       
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Viewport.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Viewport.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h" 2
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/../world/ScenerySelection.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/../world/ScenerySelection.h"
+       
+
+
+
+
+
+
+constexpr auto WINDOW_SCENERY_TAB_SELECTION_UNDEFINED = std::numeric_limits<uint16_t>::max();
+
+struct ScenerySelection
+{
+    uint8_t SceneryType;
+    ObjectEntryIndex EntryIndex;
+
+    inline bool operator==(const ScenerySelection& rhs)
+    {
+        return SceneryType == rhs.SceneryType && EntryIndex == rhs.EntryIndex;
+    }
+
+    bool IsUndefined() const
+    {
+        return EntryIndex == WINDOW_SCENERY_TAB_SELECTION_UNDEFINED;
+    }
+
+    void SetUndefined()
+    {
+        EntryIndex = WINDOW_SCENERY_TAB_SELECTION_UNDEFINED;
+    }
+
+    static ScenerySelection CreateUndefined()
+    {
+        return ScenerySelection{ 0, WINDOW_SCENERY_TAB_SELECTION_UNDEFINED };
+    }
+};
+# 18 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h" 2
+
+
+# 1 "/usr/include/c++/10.2.0/functional" 1 3
+# 46 "/usr/include/c++/10.2.0/functional" 3
+       
+# 47 "/usr/include/c++/10.2.0/functional" 3
+# 59 "/usr/include/c++/10.2.0/functional" 3
+# 1 "/usr/include/c++/10.2.0/bits/std_function.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+# 47 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+
+# 47 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  class bad_function_call : public std::exception
+  {
+  public:
+    virtual ~bad_function_call() noexcept;
+
+    const char* what() const noexcept;
+  };
+
+
+
+
+
+
+
+  template<typename _Tp>
+    struct __is_location_invariant
+    : is_trivially_copyable<_Tp>::type
+    { };
+
+  class _Undefined_class;
+
+  union _Nocopy_types
+  {
+    void* _M_object;
+    const void* _M_const_object;
+    void (*_M_function_pointer)();
+    void (_Undefined_class::*_M_member_pointer)();
+  };
+
+  union [[gnu::may_alias]] _Any_data
+  {
+    void* _M_access() { return &_M_pod_data[0]; }
+    const void* _M_access() const { return &_M_pod_data[0]; }
+
+    template<typename _Tp>
+      _Tp&
+      _M_access()
+      { return *static_cast<_Tp*>(_M_access()); }
+
+    template<typename _Tp>
+      const _Tp&
+      _M_access() const
+      { return *static_cast<const _Tp*>(_M_access()); }
+
+    _Nocopy_types _M_unused;
+    char _M_pod_data[sizeof(_Nocopy_types)];
+  };
+
+  enum _Manager_operation
+  {
+    __get_type_info,
+    __get_functor_ptr,
+    __clone_functor,
+    __destroy_functor
+  };
+
+  template<typename _Signature>
+    class function;
+
+
+  class _Function_base
+  {
+  public:
+    static const size_t _M_max_size = sizeof(_Nocopy_types);
+    static const size_t _M_max_align = __alignof__(_Nocopy_types);
+
+    template<typename _Functor>
+      class _Base_manager
+      {
+      protected:
+ static const bool __stored_locally =
+ (__is_location_invariant<_Functor>::value
+  && sizeof(_Functor) <= _M_max_size
+  && __alignof__(_Functor) <= _M_max_align
+  && (_M_max_align % __alignof__(_Functor) == 0));
+
+ typedef integral_constant<bool, __stored_locally> _Local_storage;
+
+
+ static _Functor*
+ _M_get_pointer(const _Any_data& __source)
+ {
+   if (__stored_locally)
+     {
+       const _Functor& __f = __source._M_access<_Functor>();
+       return const_cast<_Functor*>(std::__addressof(__f));
+     }
+   else
+     return __source._M_access<_Functor*>();
+ }
+
+
+
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+ {
+   ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+ }
+
+
+
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+ {
+   __dest._M_access<_Functor*>() =
+     new _Functor(*__source._M_access<const _Functor*>());
+ }
+
+
+
+ static void
+ _M_destroy(_Any_data& __victim, true_type)
+ {
+   __victim._M_access<_Functor>().~_Functor();
+ }
+
+
+ static void
+ _M_destroy(_Any_data& __victim, false_type)
+ {
+   delete __victim._M_access<_Functor*>();
+ }
+
+      public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+     _Manager_operation __op)
+ {
+   switch (__op)
+     {
+
+     case __get_type_info:
+       __dest._M_access<const type_info*>() = &typeid(_Functor);
+       break;
+
+     case __get_functor_ptr:
+       __dest._M_access<_Functor*>() = _M_get_pointer(__source);
+       break;
+
+     case __clone_functor:
+       _M_clone(__dest, __source, _Local_storage());
+       break;
+
+     case __destroy_functor:
+       _M_destroy(__dest, _Local_storage());
+       break;
+     }
+   return false;
+ }
+
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f)
+ { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
+
+ template<typename _Signature>
+   static bool
+   _M_not_empty_function(const function<_Signature>& __f)
+   { return static_cast<bool>(__f); }
+
+ template<typename _Tp>
+   static bool
+   _M_not_empty_function(_Tp* __fp)
+   { return __fp != nullptr; }
+
+ template<typename _Class, typename _Tp>
+   static bool
+   _M_not_empty_function(_Tp _Class::* __mp)
+   { return __mp != nullptr; }
+
+ template<typename _Tp>
+   static bool
+   _M_not_empty_function(const _Tp&)
+   { return true; }
+
+      private:
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
+ { ::new (__functor._M_access()) _Functor(std::move(__f)); }
+
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
+ { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
+      };
+
+    _Function_base() : _M_manager(nullptr) { }
+
+    ~_Function_base()
+    {
+      if (_M_manager)
+ _M_manager(_M_functor, _M_functor, __destroy_functor);
+    }
+
+    bool _M_empty() const { return !_M_manager; }
+
+    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
+      _Manager_operation);
+
+    _Any_data _M_functor;
+    _Manager_type _M_manager;
+  };
+
+  template<typename _Signature, typename _Functor>
+    class _Function_handler;
+
+  template<typename _Res, typename _Functor, typename... _ArgTypes>
+    class _Function_handler<_Res(_ArgTypes...), _Functor>
+    : public _Function_base::_Base_manager<_Functor>
+    {
+      typedef _Function_base::_Base_manager<_Functor> _Base;
+
+    public:
+      static bool
+      _M_manager(_Any_data& __dest, const _Any_data& __source,
+   _Manager_operation __op)
+      {
+ switch (__op)
+   {
+
+   case __get_type_info:
+     __dest._M_access<const type_info*>() = &typeid(_Functor);
+     break;
+
+   case __get_functor_ptr:
+     __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
+     break;
+
+   default:
+     _Base::_M_manager(__dest, __source, __op);
+   }
+ return false;
+      }
+
+      static _Res
+      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+      {
+ return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor),
+         std::forward<_ArgTypes>(__args)...);
+      }
+    };
+
+
+
+
+
+
+
+  template<typename _Res, typename... _ArgTypes>
+    class function<_Res(_ArgTypes...)>
+    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
+      private _Function_base
+    {
+      template<typename _Func,
+        typename _Res2 = __invoke_result<_Func&, _ArgTypes...>>
+ struct _Callable
+ : __is_invocable_impl<_Res2, _Res>::type
+ { };
+
+
+
+      template<typename _Tp>
+ struct _Callable<function, _Tp> : false_type { };
+
+      template<typename _Cond, typename _Tp>
+ using _Requires = typename enable_if<_Cond::value, _Tp>::type;
+
+    public:
+      typedef _Res result_type;
+
+
+
+
+
+
+
+      function() noexcept
+      : _Function_base() { }
+
+
+
+
+
+      function(nullptr_t) noexcept
+      : _Function_base() { }
+# 348 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function(const function& __x);
+# 357 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function(function&& __x) noexcept : _Function_base()
+      {
+ __x.swap(*this);
+      }
+# 378 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      template<typename _Functor,
+        typename = _Requires<__not_<is_same<_Functor, function>>, void>,
+        typename = _Requires<_Callable<_Functor>, void>>
+ function(_Functor);
+# 395 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function&
+      operator=(const function& __x)
+      {
+ function(__x).swap(*this);
+ return *this;
+      }
+# 413 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function&
+      operator=(function&& __x) noexcept
+      {
+ function(std::move(__x)).swap(*this);
+ return *this;
+      }
+# 427 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      function&
+      operator=(nullptr_t) noexcept
+      {
+ if (_M_manager)
+   {
+     _M_manager(_M_functor, _M_functor, __destroy_functor);
+     _M_manager = nullptr;
+     _M_invoker = nullptr;
+   }
+ return *this;
+      }
+# 455 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      template<typename _Functor>
+ _Requires<_Callable<typename decay<_Functor>::type>, function&>
+ operator=(_Functor&& __f)
+ {
+   function(std::forward<_Functor>(__f)).swap(*this);
+   return *this;
+ }
+
+
+      template<typename _Functor>
+ function&
+ operator=(reference_wrapper<_Functor> __f) noexcept
+ {
+   function(__f).swap(*this);
+   return *this;
+ }
+# 481 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      void swap(function& __x) noexcept
+      {
+ std::swap(_M_functor, __x._M_functor);
+ std::swap(_M_manager, __x._M_manager);
+ std::swap(_M_invoker, __x._M_invoker);
+      }
+# 498 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      explicit operator bool() const noexcept
+      { return !_M_empty(); }
+# 511 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      _Res operator()(_ArgTypes... __args) const;
+# 524 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      const type_info& target_type() const noexcept;
+# 537 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+      template<typename _Functor> _Functor* target() noexcept;
+
+      template<typename _Functor> const _Functor* target() const noexcept;
+
+
+
+    private:
+      using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
+      _Invoker_type _M_invoker;
+  };
+# 586 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+  template<typename _Res, typename... _ArgTypes>
+    function<_Res(_ArgTypes...)>::
+    function(const function& __x)
+    : _Function_base()
+    {
+      if (static_cast<bool>(__x))
+ {
+   __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+   _M_invoker = __x._M_invoker;
+   _M_manager = __x._M_manager;
+ }
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor, typename, typename>
+      function<_Res(_ArgTypes...)>::
+      function(_Functor __f)
+      : _Function_base()
+      {
+ typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;
+
+ if (_My_handler::_M_not_empty_function(__f))
+   {
+     _My_handler::_M_init_functor(_M_functor, std::move(__f));
+     _M_invoker = &_My_handler::_M_invoke;
+     _M_manager = &_My_handler::_M_manager;
+   }
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    _Res
+    function<_Res(_ArgTypes...)>::
+    operator()(_ArgTypes... __args) const
+    {
+      if (_M_empty())
+ __throw_bad_function_call();
+      return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
+    }
+
+
+  template<typename _Res, typename... _ArgTypes>
+    const type_info&
+    function<_Res(_ArgTypes...)>::
+    target_type() const noexcept
+    {
+      if (_M_manager)
+ {
+   _Any_data __typeinfo_result;
+   _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+   return *__typeinfo_result._M_access<const type_info*>();
+ }
+      else
+ return typeid(void);
+    }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() noexcept
+      {
+ const function* __const_this = this;
+ const _Functor* __func = __const_this->template target<_Functor>();
+ return const_cast<_Functor*>(__func);
+      }
+
+  template<typename _Res, typename... _ArgTypes>
+    template<typename _Functor>
+      const _Functor*
+      function<_Res(_ArgTypes...)>::
+      target() const noexcept
+      {
+ if (typeid(_Functor) == target_type() && _M_manager)
+   {
+     _Any_data __ptr;
+     _M_manager(__ptr, _M_functor, __get_functor_ptr);
+     return __ptr._M_access<const _Functor*>();
+   }
+ else
+   return nullptr;
+      }
+# 678 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return !static_cast<bool>(__f); }
+
+
+
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return !static_cast<bool>(__f); }
+# 697 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+    { return static_cast<bool>(__f); }
+
+
+  template<typename _Res, typename... _Args>
+    inline bool
+    operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+    { return static_cast<bool>(__f); }
+# 718 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+  template<typename _Res, typename... _Args>
+    inline void
+    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
+    { __x.swap(__y); }
+# 737 "/usr/include/c++/10.2.0/bits/std_function.h" 3
+
+}
+# 60 "/usr/include/c++/10.2.0/functional" 2 3
+# 72 "/usr/include/c++/10.2.0/functional" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 93 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _MemFunPtr,
+    bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
+    class _Mem_fn_base
+    : public _Mem_fn_traits<_MemFunPtr>::__maybe_type
+    {
+      using _Traits = _Mem_fn_traits<_MemFunPtr>;
+
+      using _Arity = typename _Traits::__arity;
+      using _Varargs = typename _Traits::__vararg;
+
+      template<typename _Func, typename... _BoundArgs>
+ friend struct _Bind_check_arity;
+
+      _MemFunPtr _M_pmf;
+
+    public:
+
+      using result_type = typename _Traits::__result_type;
+
+      explicit constexpr
+      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }
+
+      template<typename... _Args>
+
+ auto
+ operator()(_Args&&... __args) const
+ noexcept(noexcept(
+       std::__invoke(_M_pmf, std::forward<_Args>(__args)...)))
+ -> decltype(std::__invoke(_M_pmf, std::forward<_Args>(__args)...))
+ { return std::__invoke(_M_pmf, std::forward<_Args>(__args)...); }
+    };
+
+
+  template<typename _MemObjPtr>
+    class _Mem_fn_base<_MemObjPtr, false>
+    {
+      using _Arity = integral_constant<size_t, 0>;
+      using _Varargs = false_type;
+
+      template<typename _Func, typename... _BoundArgs>
+ friend struct _Bind_check_arity;
+
+      _MemObjPtr _M_pm;
+
+    public:
+      explicit constexpr
+      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }
+
+      template<typename _Tp>
+
+ auto
+ operator()(_Tp&& __obj) const
+ noexcept(noexcept(std::__invoke(_M_pm, std::forward<_Tp>(__obj))))
+ -> decltype(std::__invoke(_M_pm, std::forward<_Tp>(__obj)))
+ { return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
+    };
+
+  template<typename _MemberPointer>
+    struct _Mem_fn;
+
+  template<typename _Res, typename _Class>
+    struct _Mem_fn<_Res _Class::*>
+    : _Mem_fn_base<_Res _Class::*>
+    {
+      using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
+    };
+# 167 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Tp, typename _Class>
+   
+    inline _Mem_fn<_Tp _Class::*>
+    mem_fn(_Tp _Class::* __pm) noexcept
+    {
+      return _Mem_fn<_Tp _Class::*>(__pm);
+    }
+# 183 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Tp>
+    struct is_bind_expression
+    : public false_type { };
+# 194 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Tp>
+    struct is_placeholder
+    : public integral_constant<int, 0>
+    { };
+# 209 "/usr/include/c++/10.2.0/functional" 3
+  template<int _Num> struct _Placeholder { };
+
+
+
+
+
+  namespace placeholders
+  {
+
+
+
+
+    extern const _Placeholder<1> _1;
+    extern const _Placeholder<2> _2;
+    extern const _Placeholder<3> _3;
+    extern const _Placeholder<4> _4;
+    extern const _Placeholder<5> _5;
+    extern const _Placeholder<6> _6;
+    extern const _Placeholder<7> _7;
+    extern const _Placeholder<8> _8;
+    extern const _Placeholder<9> _9;
+    extern const _Placeholder<10> _10;
+    extern const _Placeholder<11> _11;
+    extern const _Placeholder<12> _12;
+    extern const _Placeholder<13> _13;
+    extern const _Placeholder<14> _14;
+    extern const _Placeholder<15> _15;
+    extern const _Placeholder<16> _16;
+    extern const _Placeholder<17> _17;
+    extern const _Placeholder<18> _18;
+    extern const _Placeholder<19> _19;
+    extern const _Placeholder<20> _20;
+    extern const _Placeholder<21> _21;
+    extern const _Placeholder<22> _22;
+    extern const _Placeholder<23> _23;
+    extern const _Placeholder<24> _24;
+    extern const _Placeholder<25> _25;
+    extern const _Placeholder<26> _26;
+    extern const _Placeholder<27> _27;
+    extern const _Placeholder<28> _28;
+    extern const _Placeholder<29> _29;
+  }
+
+
+
+
+
+
+  template<int _Num>
+    struct is_placeholder<_Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+
+  template<int _Num>
+    struct is_placeholder<const _Placeholder<_Num> >
+    : public integral_constant<int, _Num>
+    { };
+
+
+
+  template<std::size_t __i, typename _Tuple>
+    using _Safe_tuple_element_t
+      = typename enable_if<(__i < tuple_size<_Tuple>::value),
+      tuple_element<__i, _Tuple>>::type::type;
+# 285 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Arg,
+    bool _IsBindExp = is_bind_expression<_Arg>::value,
+    bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
+    class _Mu;
+
+
+
+
+
+
+  template<typename _Tp>
+    class _Mu<reference_wrapper<_Tp>, false, false>
+    {
+    public:
+
+
+
+
+      template<typename _CVRef, typename _Tuple>
+
+ _Tp&
+ operator()(_CVRef& __arg, _Tuple&) const volatile
+ { return __arg.get(); }
+    };
+
+
+
+
+
+
+
+  template<typename _Arg>
+    class _Mu<_Arg, true, false>
+    {
+    public:
+      template<typename _CVArg, typename... _Args>
+
+ auto
+ operator()(_CVArg& __arg,
+     tuple<_Args...>& __tuple) const volatile
+ -> decltype(__arg(declval<_Args>()...))
+ {
+
+   typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
+     _Indexes;
+   return this->__call(__arg, __tuple, _Indexes());
+ }
+
+    private:
+
+
+      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
+
+ auto
+ __call(_CVArg& __arg, tuple<_Args...>& __tuple,
+        const _Index_tuple<_Indexes...>&) const volatile
+ -> decltype(__arg(declval<_Args>()...))
+ {
+   return __arg(std::get<_Indexes>(std::move(__tuple))...);
+ }
+    };
+
+
+
+
+
+
+  template<typename _Arg>
+    class _Mu<_Arg, false, true>
+    {
+    public:
+      template<typename _Tuple>
+
+ _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
+ operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
+ {
+   return
+     ::std::get<(is_placeholder<_Arg>::value - 1)>(std::move(__tuple));
+ }
+    };
+
+
+
+
+
+
+  template<typename _Arg>
+    class _Mu<_Arg, false, false>
+    {
+    public:
+      template<typename _CVArg, typename _Tuple>
+
+ _CVArg&&
+ operator()(_CVArg&& __arg, _Tuple&) const volatile
+ { return std::forward<_CVArg>(__arg); }
+    };
+
+
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(volatile tuple<_Tp...>& __tuple)
+    -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
+    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }
+
+
+  template<std::size_t _Ind, typename... _Tp>
+    inline auto
+    __volget(const volatile tuple<_Tp...>& __tuple)
+    -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
+    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
+
+
+  template<typename _Signature>
+    struct _Bind;
+
+   template<typename _Functor, typename... _Bound_args>
+    class _Bind<_Functor(_Bound_args...)>
+    : public _Weak_result_type<_Functor>
+    {
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+
+ _Result
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+
+ _Result
+ __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(std::get<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_v(tuple<_Args...>&& __args,
+   _Index_tuple<_Indexes...>) volatile
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+
+
+      template<typename _Result, typename... _Args, std::size_t... _Indexes>
+ _Result
+ __call_c_v(tuple<_Args...>&& __args,
+     _Index_tuple<_Indexes...>) const volatile
+ {
+   return std::__invoke(_M_f,
+       _Mu<_Bound_args>()(__volget<_Indexes>(_M_bound_args), __args)...
+       );
+ }
+
+      template<typename _BoundArg, typename _CallArgs>
+ using _Mu_type = decltype(
+     _Mu<typename remove_cv<_BoundArg>::type>()(
+       std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) );
+
+      template<typename _Fn, typename _CallArgs, typename... _BArgs>
+ using _Res_type_impl
+   = typename result_of< _Fn&(_Mu_type<_BArgs, _CallArgs>&&...) >::type;
+
+      template<typename _CallArgs>
+ using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>;
+
+      template<typename _CallArgs>
+ using __dependent = typename
+   enable_if<bool(tuple_size<_CallArgs>::value+1), _Functor>::type;
+
+      template<typename _CallArgs, template<class> class __cv_quals>
+ using _Res_type_cv = _Res_type_impl<
+   typename __cv_quals<__dependent<_CallArgs>>::type,
+   _CallArgs,
+   typename __cv_quals<_Bound_args>::type...>;
+
+     public:
+      template<typename... _Args>
+ explicit
+ _Bind(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      template<typename... _Args>
+ explicit
+ _Bind(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      _Bind(const _Bind&) = default;
+      _Bind(_Bind&&) = default;
+
+
+      template<typename... _Args,
+        typename _Result = _Res_type<tuple<_Args...>>>
+
+ _Result
+ operator()(_Args&&... __args)
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args,
+        typename _Result = _Res_type_cv<tuple<_Args...>, add_const>>
+
+ _Result
+ operator()(_Args&&... __args) const
+ {
+   return this->__call_c<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+# 523 "/usr/include/c++/10.2.0/functional" 3
+      template<typename... _Args,
+        typename _Result = _Res_type_cv<tuple<_Args...>, add_volatile>>
+
+ _Result
+ operator()(_Args&&... __args) volatile
+ {
+   return this->__call_v<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args,
+        typename _Result = _Res_type_cv<tuple<_Args...>, add_cv>>
+
+ _Result
+ operator()(_Args&&... __args) const volatile
+ {
+   return this->__call_c_v<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+    };
+
+
+  template<typename _Result, typename _Signature>
+    struct _Bind_result;
+
+  template<typename _Result, typename _Functor, typename... _Bound_args>
+    class _Bind_result<_Result, _Functor(_Bound_args...)>
+    {
+      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
+ _Bound_indexes;
+
+      _Functor _M_f;
+      tuple<_Bound_args...> _M_bound_args;
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+
+ _Res
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
+ {
+   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+
+ _Res
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
+ {
+   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
+        (std::get<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+
+ _Res
+ __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) volatile
+ {
+   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+
+      template<typename _Res, typename... _Args, std::size_t... _Indexes>
+
+ _Res
+ __call(tuple<_Args...>&& __args,
+        _Index_tuple<_Indexes...>) const volatile
+ {
+   return std::__invoke_r<_Res>(_M_f, _Mu<_Bound_args>()
+        (__volget<_Indexes>(_M_bound_args), __args)...);
+ }
+
+    public:
+      typedef _Result result_type;
+
+      template<typename... _Args>
+ explicit
+ _Bind_result(const _Functor& __f, _Args&&... __args)
+ : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      template<typename... _Args>
+ explicit
+ _Bind_result(_Functor&& __f, _Args&&... __args)
+ : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
+ { }
+
+      _Bind_result(const _Bind_result&) = default;
+      _Bind_result(_Bind_result&&) = default;
+
+
+      template<typename... _Args>
+
+ result_type
+ operator()(_Args&&... __args)
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args>
+
+ result_type
+ operator()(_Args&&... __args) const
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args>
+
+ result_type
+ operator()(_Args&&... __args) volatile
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+
+
+      template<typename... _Args>
+
+ result_type
+ operator()(_Args&&... __args) const volatile
+ {
+   return this->__call<_Result>(
+       std::forward_as_tuple(std::forward<_Args>(__args)...),
+       _Bound_indexes());
+ }
+    };
+
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<_Bind<_Signature> >
+    : public true_type { };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<const _Bind<_Signature> >
+    : public true_type { };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<volatile _Bind<_Signature> >
+    : public true_type { };
+
+
+
+
+
+  template<typename _Signature>
+    struct is_bind_expression<const volatile _Bind<_Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<_Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+
+
+
+
+  template<typename _Result, typename _Signature>
+    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
+    : public true_type { };
+
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_check_arity { };
+
+  template<typename _Ret, typename... _Args, typename... _BoundArgs>
+    struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
+    {
+      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
+                   "Wrong number of arguments for function");
+    };
+
+  template<typename _Ret, typename... _Args, typename... _BoundArgs>
+    struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
+    {
+      static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
+                   "Wrong number of arguments for function");
+    };
+
+  template<typename _Tp, typename _Class, typename... _BoundArgs>
+    struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
+    {
+      using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
+      using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
+      static_assert(_Varargs::value
+      ? sizeof...(_BoundArgs) >= _Arity::value + 1
+      : sizeof...(_BoundArgs) == _Arity::value + 1,
+      "Wrong number of arguments for pointer-to-member");
+    };
+
+
+
+
+  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
+    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;
+
+  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
+    struct _Bind_helper
+    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
+    {
+      typedef typename decay<_Func>::type __func_type;
+      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
+    };
+
+
+
+
+  template<typename _Func, typename... _BoundArgs>
+    struct _Bind_helper<true, _Func, _BoundArgs...>
+    { };
+
+
+
+
+
+  template<typename _Func, typename... _BoundArgs>
+    inline typename
+    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
+      return typename __helper_type::type(std::forward<_Func>(__f),
+       std::forward<_BoundArgs>(__args)...);
+    }
+
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    struct _Bindres_helper
+    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
+    {
+      typedef typename decay<_Func>::type __functor_type;
+      typedef _Bind_result<_Result,
+      __functor_type(typename decay<_BoundArgs>::type...)>
+ type;
+    };
+
+
+
+
+
+  template<typename _Result, typename _Func, typename... _BoundArgs>
+    inline
+    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
+    bind(_Func&& __f, _BoundArgs&&... __args)
+    {
+      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
+      return typename __helper_type::type(std::forward<_Func>(__f),
+       std::forward<_BoundArgs>(__args)...);
+    }
+# 918 "/usr/include/c++/10.2.0/functional" 3
+  template<typename _Fn>
+    class _Not_fn
+    {
+      template<typename _Fn2, typename... _Args>
+ using __inv_res_t = typename __invoke_result<_Fn2, _Args...>::type;
+
+      template<typename _Tp>
+ static decltype(!std::declval<_Tp>())
+ _S_not() noexcept(noexcept(!std::declval<_Tp>()));
+
+    public:
+      template<typename _Fn2>
+ constexpr
+ _Not_fn(_Fn2&& __fn, int)
+ : _M_fn(std::forward<_Fn2>(__fn)) { }
+
+      _Not_fn(const _Not_fn& __fn) = default;
+      _Not_fn(_Not_fn&& __fn) = default;
+      ~_Not_fn() = default;
+# 952 "/usr/include/c++/10.2.0/functional" 3
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &, _Args...>>()) operator()(_Args&&... __args) & noexcept(__is_nothrow_invocable<_Fn &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &, _Args...>>())) { return !std::__invoke(std::forward< _Fn & >(_M_fn), std::forward<_Args>(__args)...); }
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &, _Args...>>()) operator()(_Args&&... __args) const & noexcept(__is_nothrow_invocable<_Fn const &, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &, _Args...>>())) { return !std::__invoke(std::forward< _Fn const & >(_M_fn), std::forward<_Args>(__args)...); }
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn &&, _Args...>>()) operator()(_Args&&... __args) && noexcept(__is_nothrow_invocable<_Fn &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn && >(_M_fn), std::forward<_Args>(__args)...); }
+      template<typename... _Args> decltype(_S_not<__inv_res_t<_Fn const &&, _Args...>>()) operator()(_Args&&... __args) const && noexcept(__is_nothrow_invocable<_Fn const &&, _Args...>::value && noexcept(_S_not<__inv_res_t<_Fn const &&, _Args...>>())) { return !std::__invoke(std::forward< _Fn const && >(_M_fn), std::forward<_Args>(__args)...); }
+
+
+    private:
+      _Fn _M_fn;
+    };
+
+  template<typename _Tp, typename _Pred>
+    struct __is_byte_like : false_type { };
+
+  template<typename _Tp>
+    struct __is_byte_like<_Tp, equal_to<_Tp>>
+    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };
+
+  template<typename _Tp>
+    struct __is_byte_like<_Tp, equal_to<void>>
+    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };
+# 1275 "/usr/include/c++/10.2.0/functional" 3
+
+}
+# 21 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h" 2
+
+# 1 "/usr/include/c++/10.2.0/list" 1 3
+# 58 "/usr/include/c++/10.2.0/list" 3
+       
+# 59 "/usr/include/c++/10.2.0/list" 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_list.h" 1 3
+# 67 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  namespace __detail
+  {
+
+
+
+
+
+
+
+    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;
+    };
+
+
+    struct _List_node_header : public _List_node_base
+    {
+
+      std::size_t _M_size;
+
+
+      _List_node_header() noexcept
+      { _M_init(); }
+
+
+      _List_node_header(_List_node_header&& __x) noexcept
+      : _List_node_base{ __x._M_next, __x._M_prev }
+
+      , _M_size(__x._M_size)
+
+      {
+ if (__x._M_base()->_M_next == __x._M_base())
+   this->_M_next = this->_M_prev = this;
+ else
+   {
+     this->_M_next->_M_prev = this->_M_prev->_M_next = this->_M_base();
+     __x._M_init();
+   }
+      }
+
+      void
+      _M_move_nodes(_List_node_header&& __x)
+      {
+ _List_node_base* const __xnode = __x._M_base();
+ if (__xnode->_M_next == __xnode)
+   _M_init();
+ else
+   {
+     _List_node_base* const __node = this->_M_base();
+     __node->_M_next = __xnode->_M_next;
+     __node->_M_prev = __xnode->_M_prev;
+     __node->_M_next->_M_prev = __node->_M_prev->_M_next = __node;
+
+     _M_size = __x._M_size;
+
+     __x._M_init();
+   }
+      }
+
+
+      void
+      _M_init() noexcept
+      {
+ this->_M_next = this->_M_prev = this;
+
+ this->_M_size = 0;
+
+      }
+
+    private:
+      _List_node_base* _M_base() { return this; }
+    };
+  }
+
+
+
+
+  template<typename _Tp>
+    struct _List_node : public __detail::_List_node_base
+    {
+
+      __gnu_cxx::__aligned_membuf<_Tp> _M_storage;
+      _Tp* _M_valptr() { return _M_storage._M_ptr(); }
+      _Tp const* _M_valptr() const { return _M_storage._M_ptr(); }
+
+
+
+
+
+    };
+
+
+
+
+
+
+  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_valptr(); }
+
+      pointer
+      operator->() const noexcept
+      { return static_cast<_Node*>(_M_node)->_M_valptr(); }
+
+      _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;
+      }
+
+      friend bool
+      operator==(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node == __y._M_node; }
+
+
+      friend bool
+      operator!=(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node != __y._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_valptr(); }
+
+      pointer
+      operator->() const noexcept
+      { return static_cast<_Node*>(_M_node)->_M_valptr(); }
+
+      _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;
+      }
+
+      friend bool
+      operator==(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node == __y._M_node; }
+
+
+      friend bool
+      operator!=(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_node != __y._M_node; }
+
+
+
+      const __detail::_List_node_base* _M_node;
+    };
+
+namespace __cxx11 {
+
+  template<typename _Tp, typename _Alloc>
+    class _List_base
+    {
+    protected:
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_Tp>::other _Tp_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tp_alloc_traits;
+      typedef typename _Tp_alloc_traits::template
+ rebind<_List_node<_Tp> >::other _Node_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;
+
+
+      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
+      {
+ __detail::_List_node_header _M_node;
+
+ _List_impl() noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value)
+
+ : _Node_alloc_type()
+ { }
+
+ _List_impl(const _Node_alloc_type& __a) noexcept
+ : _Node_alloc_type(__a)
+ { }
+
+
+ _List_impl(_List_impl&&) = default;
+
+ _List_impl(_Node_alloc_type&& __a, _List_impl&& __x)
+ : _Node_alloc_type(std::move(__a)), _M_node(std::move(__x._M_node))
+ { }
+
+ _List_impl(_Node_alloc_type&& __a) noexcept
+ : _Node_alloc_type(std::move(__a))
+ { }
+
+      };
+
+      _List_impl _M_impl;
+
+
+      size_t _M_get_size() const { return _M_impl._M_node._M_size; }
+
+      void _M_set_size(size_t __n) { _M_impl._M_node._M_size = __n; }
+
+      void _M_inc_size(size_t __n) { _M_impl._M_node._M_size += __n; }
+
+      void _M_dec_size(size_t __n) { _M_impl._M_node._M_size -= __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_get_size(); }
+# 440 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      typename _Node_alloc_traits::pointer
+      _M_get_node()
+      { return _Node_alloc_traits::allocate(_M_impl, 1); }
+
+      void
+      _M_put_node(typename _Node_alloc_traits::pointer __p) noexcept
+      { _Node_alloc_traits::deallocate(_M_impl, __p, 1); }
+
+  public:
+      typedef _Alloc allocator_type;
+
+      _Node_alloc_type&
+      _M_get_Node_allocator() noexcept
+      { return _M_impl; }
+
+      const _Node_alloc_type&
+      _M_get_Node_allocator() const noexcept
+      { return _M_impl; }
+
+
+      _List_base() = default;
+
+
+
+
+      _List_base(const _Node_alloc_type& __a) noexcept
+      : _M_impl(__a)
+      { }
+
+
+      _List_base(_List_base&&) = default;
+
+
+      _List_base(_List_base&& __x, _Node_alloc_type&& __a)
+      : _M_impl(std::move(__a))
+      {
+ if (__x._M_get_Node_allocator() == _M_get_Node_allocator())
+   _M_move_nodes(std::move(__x));
+
+      }
+
+
+
+      _List_base(_Node_alloc_type&& __a, _List_base&& __x)
+      : _M_impl(std::move(__a), std::move(__x._M_impl))
+      { }
+
+
+      _List_base(_Node_alloc_type&& __a)
+      : _M_impl(std::move(__a))
+      { }
+
+      void
+      _M_move_nodes(_List_base&& __x)
+      { _M_impl._M_node._M_move_nodes(std::move(__x._M_impl._M_node)); }
+
+
+
+      ~_List_base() noexcept
+      { _M_clear(); }
+
+      void
+      _M_clear() noexcept;
+
+      void
+      _M_init() noexcept
+      { this->_M_impl._M_node._M_init(); }
+    };
+# 555 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class list : protected _List_base<_Tp, _Alloc>
+    {
+# 568 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
+   "std::list must have a non-const, non-volatile value_type");
+
+
+
+
+
+
+      typedef _List_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+      typedef typename _Base::_Tp_alloc_traits _Tp_alloc_traits;
+      typedef typename _Base::_Node_alloc_type _Node_alloc_type;
+      typedef typename _Base::_Node_alloc_traits _Node_alloc_traits;
+
+    public:
+      typedef _Tp value_type;
+      typedef typename _Tp_alloc_traits::pointer pointer;
+      typedef typename _Tp_alloc_traits::const_pointer const_pointer;
+      typedef typename _Tp_alloc_traits::reference reference;
+      typedef typename _Tp_alloc_traits::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_Node_allocator;
+# 630 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename... _Args>
+ _Node*
+ _M_create_node(_Args&&... __args)
+ {
+   auto __p = this->_M_get_node();
+   auto& __alloc = _M_get_Node_allocator();
+   __allocated_ptr<_Node_alloc_type> __guard{__alloc, __p};
+   _Node_alloc_traits::construct(__alloc, __p->_M_valptr(),
+     std::forward<_Args>(__args)...);
+   __guard = nullptr;
+   return __p;
+ }
+
+
+
+      static size_t
+      _S_distance(const_iterator __first, const_iterator __last)
+      { return std::distance(__first, __last); }
+
+
+      size_t
+      _M_node_count() const
+      { return this->_M_get_size(); }
+# 665 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+    public:
+
+
+
+
+
+
+
+      list() = default;
+# 682 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      explicit
+      list(const allocator_type& __a) noexcept
+      : _Base(_Node_alloc_type(__a)) { }
+# 695 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      explicit
+      list(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(_Node_alloc_type(__a))
+      { _M_default_initialize(__n); }
+# 708 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list(size_type __n, const value_type& __value,
+    const allocator_type& __a = allocator_type())
+      : _Base(_Node_alloc_type(__a))
+      { _M_fill_initialize(__n, __value); }
+# 735 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list(const list& __x)
+      : _Base(_Node_alloc_traits::
+       _S_select_on_copy(__x._M_get_Node_allocator()))
+      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
+# 748 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list(list&&) = default;
+# 758 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list(initializer_list<value_type> __l,
+    const allocator_type& __a = allocator_type())
+      : _Base(_Node_alloc_type(__a))
+      { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); }
+
+      list(const list& __x, const allocator_type& __a)
+      : _Base(_Node_alloc_type(__a))
+      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
+
+    private:
+      list(list&& __x, const allocator_type& __a, true_type) noexcept
+      : _Base(_Node_alloc_type(__a), std::move(__x))
+      { }
+
+      list(list&& __x, const allocator_type& __a, false_type)
+      : _Base(_Node_alloc_type(__a))
+      {
+ if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator())
+   this->_M_move_nodes(std::move(__x));
+ else
+   insert(begin(), std::__make_move_if_noexcept_iterator(__x.begin()),
+     std::__make_move_if_noexcept_iterator(__x.end()));
+      }
+
+    public:
+      list(list&& __x, const allocator_type& __a)
+      noexcept(_Node_alloc_traits::_S_always_equal())
+      : list(std::move(__x), __a,
+      typename _Node_alloc_traits::is_always_equal{})
+      { }
+# 801 "/usr/include/c++/10.2.0/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()); }
+# 827 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      ~list() = default;
+# 838 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list&
+      operator=(const list& __x);
+# 852 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list&
+      operator=(list&& __x)
+      noexcept(_Node_alloc_traits::_S_nothrow_move())
+      {
+ constexpr bool __move_storage =
+   _Node_alloc_traits::_S_propagate_on_move_assign()
+   || _Node_alloc_traits::_S_always_equal();
+ _M_move_assign(std::move(__x), __bool_constant<__move_storage>());
+ return *this;
+      }
+# 870 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      list&
+      operator=(initializer_list<value_type> __l)
+      {
+ this->assign(__l.begin(), __l.end());
+ return *this;
+      }
+# 888 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 905 "/usr/include/c++/10.2.0/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()); }
+# 929 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      assign(initializer_list<value_type> __l)
+      { this->_M_assign_dispatch(__l.begin(), __l.end(), __false_type()); }
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_Base::_M_get_Node_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 _M_node_count(); }
+
+
+      size_type
+      max_size() const noexcept
+      { return _Node_alloc_traits::max_size(_M_get_Node_allocator()); }
+# 1078 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      resize(size_type __new_size);
+# 1091 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      resize(size_type __new_size, const value_type& __x);
+# 1113 "/usr/include/c++/10.2.0/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;
+      }
+# 1160 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      push_front(const value_type& __x)
+      { this->_M_insert(begin(), __x); }
+
+
+      void
+      push_front(value_type&& __x)
+      { this->_M_insert(begin(), std::move(__x)); }
+
+      template<typename... _Args>
+
+
+
+ void
+
+ emplace_front(_Args&&... __args)
+ {
+   this->_M_insert(begin(), std::forward<_Args>(__args)...);
+
+
+
+ }
+# 1196 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      pop_front() noexcept
+      { this->_M_erase(begin()); }
+# 1210 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      push_back(const value_type& __x)
+      { this->_M_insert(end(), __x); }
+
+
+      void
+      push_back(value_type&& __x)
+      { this->_M_insert(end(), std::move(__x)); }
+
+      template<typename... _Args>
+
+
+
+ void
+
+ emplace_back(_Args&&... __args)
+ {
+   this->_M_insert(end(), std::forward<_Args>(__args)...);
+
+
+
+ }
+# 1245 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      pop_back() noexcept
+      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
+# 1262 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(const_iterator __position, _Args&&... __args);
+# 1277 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+# 1307 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+# 1326 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __p, initializer_list<value_type> __l)
+      { return this->insert(__p, __l.begin(), __l.end()); }
+# 1346 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x);
+# 1385 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+ insert(const_iterator __position, _InputIterator __first,
+        _InputIterator __last);
+# 1429 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      iterator
+
+      erase(const_iterator __position) noexcept;
+# 1454 "/usr/include/c++/10.2.0/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();
+      }
+# 1477 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      swap(list& __x) noexcept
+      {
+ __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);
+
+ _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(),
+           __x._M_get_Node_allocator());
+      }
+
+
+
+
+
+
+
+      void
+      clear() noexcept
+      {
+ _Base::_M_clear();
+ _Base::_M_init();
+      }
+# 1516 "/usr/include/c++/10.2.0/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)); }
+# 1552 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list&& __x, const_iterator __i) noexcept
+# 1567 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      {
+ iterator __j = __i._M_const_cast();
+ ++__j;
+ if (__position == __i || __position == __j)
+   return;
+
+ if (this != std::__addressof(__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);
+      }
+# 1594 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list& __x, const_iterator __i) noexcept
+      { splice(__position, std::move(__x), __i); }
+# 1613 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      splice(const_iterator __position, list&& __x, const_iterator __first,
+      const_iterator __last) noexcept
+# 1633 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      {
+ if (__first != __last)
+   {
+     if (this != std::__addressof(__x))
+       _M_check_equal_allocators(__x);
+
+     size_t __n = _S_distance(__first, __last);
+     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());
+   }
+      }
+# 1663 "/usr/include/c++/10.2.0/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); }
+
+
+    private:
+
+
+
+
+
+
+      typedef void __remove_return_type;
+
+
+    public:
+# 1692 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+     
+      __remove_return_type
+      remove(const _Tp& __value);
+# 1707 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _Predicate>
+ __remove_return_type
+ remove_if(_Predicate);
+# 1721 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+     
+      __remove_return_type
+      unique();
+# 1737 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _BinaryPredicate>
+ __remove_return_type
+ unique(_BinaryPredicate);
+# 1753 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      merge(list&& __x);
+
+      void
+      merge(list& __x)
+      { merge(std::move(__x)); }
+# 1778 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _StrictWeakOrdering>
+ void
+ merge(list&& __x, _StrictWeakOrdering __comp);
+
+      template<typename _StrictWeakOrdering>
+ void
+ merge(list& __x, _StrictWeakOrdering __comp)
+ { merge(std::move(__x), __comp); }
+# 1797 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      void
+      reverse() noexcept
+      { this->_M_impl._M_node._M_reverse(); }
+
+
+
+
+
+
+
+      void
+      sort();
+
+
+
+
+
+
+
+      template<typename _StrictWeakOrdering>
+ void
+ sort(_StrictWeakOrdering);
+
+    protected:
+
+
+
+
+
+
+      template<typename _Integer>
+ void
+ _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+ { _M_fill_initialize(static_cast<size_type>(__n), __x); }
+
+
+      template<typename _InputIterator>
+ void
+ _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+ {
+   for (; __first != __last; ++__first)
+
+     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);
+# 1875 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+      template<typename _Integer>
+ void
+ _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+ { _M_fill_assign(__n, __val); }
+
+
+      template<typename _InputIterator>
+ void
+ _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type);
+
+
+
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+
+
+
+      void
+      _M_transfer(iterator __position, iterator __first, iterator __last)
+      { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }
+# 1907 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+     template<typename... _Args>
+       void
+       _M_insert(iterator __position, _Args&&... __args)
+       {
+  _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
+  __tmp->_M_hook(__position._M_node);
+  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);
+
+ _Node_alloc_traits::destroy(_M_get_Node_allocator(), __n->_M_valptr());
+
+
+
+
+ _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();
+      }
+
+
+      const_iterator
+      _M_resize_pos(size_type& __new_size) const;
+
+
+      void
+      _M_move_assign(list&& __x, true_type) noexcept
+      {
+ this->_M_clear();
+ this->_M_move_nodes(std::move(__x));
+ std::__alloc_on_move(this->_M_get_Node_allocator(),
+        __x._M_get_Node_allocator());
+      }
+
+      void
+      _M_move_assign(list&& __x, false_type)
+      {
+ if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator())
+   _M_move_assign(std::move(__x), true_type{});
+ else
+
+
+   _M_assign_dispatch(std::make_move_iterator(__x.begin()),
+        std::make_move_iterator(__x.end()),
+        __false_type{});
+      }
+
+    };
+# 1981 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+}
+# 1993 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    {
+
+      if (__x.size() != __y.size())
+ return false;
+
+
+      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;
+    }
+# 2048 "/usr/include/c++/10.2.0/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+
+
+
+
+  template<typename _Tp>
+    inline ptrdiff_t
+    __distance(std::_List_iterator<_Tp> __first,
+        std::_List_iterator<_Tp> __last,
+        input_iterator_tag __tag)
+    {
+      typedef std::_List_const_iterator<_Tp> _CIter;
+      return std::__distance(_CIter(__first), _CIter(__last), __tag);
+    }
+
+  template<typename _Tp>
+    inline ptrdiff_t
+    __distance(std::_List_const_iterator<_Tp> __first,
+        std::_List_const_iterator<_Tp> __last,
+        input_iterator_tag)
+    {
+      typedef __detail::_List_node_header _Sentinel;
+      std::_List_const_iterator<_Tp> __beyond = __last;
+      ++__beyond;
+      const bool __whole = __first == __beyond;
+      if (__builtin_constant_p (__whole) && __whole)
+ return static_cast<const _Sentinel*>(__last._M_node)->_M_size;
+
+      ptrdiff_t __n = 0;
+      while (__first != __last)
+ {
+   ++__first;
+   ++__n;
+ }
+      return __n;
+    }
+
+
+
+}
+# 64 "/usr/include/c++/10.2.0/list" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/list.tcc" 1 3
+# 59 "/usr/include/c++/10.2.0/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;
+   _Tp* __val = __tmp->_M_valptr();
+
+   _Node_alloc_traits::destroy(_M_get_Node_allocator(), __val);
+
+
+
+   _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;
+    }
+# 173 "/usr/include/c++/10.2.0/bits/list.tcc" 3
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::const_iterator
+    list<_Tp, _Alloc>::
+    _M_resize_pos(size_type& __new_size) const
+    {
+      const_iterator __i;
+
+      const size_type __len = size();
+      if (__new_size < __len)
+ {
+   if (__new_size <= __len / 2)
+     {
+       __i = begin();
+       std::advance(__i, __new_size);
+     }
+   else
+     {
+       __i = end();
+       ptrdiff_t __num_erase = __len - __new_size;
+       std::advance(__i, -__num_erase);
+     }
+   __new_size = 0;
+   return __i;
+ }
+      else
+ __i = end();
+
+
+
+
+
+      __new_size -= __len;
+      return __i;
+    }
+
+
+  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)
+    {
+      const_iterator __i = _M_resize_pos(__new_size);
+      if (__new_size)
+ _M_default_append(__new_size);
+      else
+        erase(__i, end());
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    resize(size_type __new_size, const value_type& __x)
+    {
+      const_iterator __i = _M_resize_pos(__new_size);
+      if (__new_size)
+        insert(end(), __new_size, __x);
+      else
+        erase(__i, end());
+    }
+# 265 "/usr/include/c++/10.2.0/bits/list.tcc" 3
+  template<typename _Tp, typename _Alloc>
+    list<_Tp, _Alloc>&
+    list<_Tp, _Alloc>::
+    operator=(const list& __x)
+    {
+      if (this != std::__addressof(__x))
+ {
+
+   if (_Node_alloc_traits::_S_propagate_on_copy_assign())
+     {
+              auto& __this_alloc = this->_M_get_Node_allocator();
+              auto& __that_alloc = __x._M_get_Node_allocator();
+              if (!_Node_alloc_traits::_S_always_equal()
+           && __this_alloc != __that_alloc)
+         {
+
+    clear();
+  }
+       std::__alloc_on_copy(__this_alloc, __that_alloc);
+            }
+
+   _M_assign_dispatch(__x.begin(), __x.end(), __false_type());
+ }
+      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, (void)++__first2)
+          *__first1 = *__first2;
+        if (__first2 == __last2)
+          erase(__first1, __last1);
+        else
+          insert(__last1, __first2, __last2);
+      }
+
+
+
+
+
+
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::__remove_return_type
+    list<_Tp, _Alloc>::
+    remove(const value_type& __value)
+    {
+      size_type __removed __attribute__((__unused__)) = 0;
+      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);
+   ;
+ }
+      return ;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::__remove_return_type
+    list<_Tp, _Alloc>::
+    unique()
+    {
+      iterator __first = begin();
+      iterator __last = end();
+      if (__first == __last)
+ return ;
+      size_type __removed __attribute__((__unused__)) = 0;
+      iterator __next = __first;
+      while (++__next != __last)
+ {
+   if (*__first == *__next)
+     {
+       _M_erase(__next);
+       ;
+     }
+   else
+     __first = __next;
+   __next = __first;
+ }
+      return ;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+
+    merge(list&& __x)
+
+
+
+    {
+
+
+      if (this != std::__addressof(__x))
+ {
+   _M_check_equal_allocators(__x);
+
+   iterator __first1 = begin();
+   iterator __last1 = end();
+   iterator __first2 = __x.begin();
+   iterator __last2 = __x.end();
+   const size_t __orig_size = __x.size();
+   try {
+     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);
+   }
+   catch(...)
+     {
+       const size_t __dist = std::distance(__first2, __last2);
+       this->_M_inc_size(__orig_size - __dist);
+       __x._M_set_size(__dist);
+       throw;
+     }
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _StrictWeakOrdering>
+      void
+      list<_Tp, _Alloc>::
+
+      merge(list&& __x, _StrictWeakOrdering __comp)
+
+
+
+      {
+
+
+ if (this != std::__addressof(__x))
+   {
+     _M_check_equal_allocators(__x);
+
+     iterator __first1 = begin();
+     iterator __last1 = end();
+     iterator __first2 = __x.begin();
+     iterator __last2 = __x.end();
+     const size_t __orig_size = __x.size();
+     try
+       {
+  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);
+       }
+     catch(...)
+       {
+  const size_t __dist = std::distance(__first2, __last2);
+  this->_M_inc_size(__orig_size - __dist);
+  __x._M_set_size(__dist);
+  throw;
+       }
+   }
+      }
+
+  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;
+        list * __counter;
+ try
+   {
+     do
+       {
+  __carry.splice(__carry.begin(), *this, begin());
+
+  for(__counter = __tmp;
+      __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) );
+   }
+ catch(...)
+   {
+     this->splice(this->end(), __carry);
+     for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
+       this->splice(this->end(), __tmp[__i]);
+     throw;
+   }
+      }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _Predicate>
+      typename list<_Tp, _Alloc>::__remove_return_type
+      list<_Tp, _Alloc>::
+      remove_if(_Predicate __pred)
+      {
+ size_type __removed __attribute__((__unused__)) = 0;
+        iterator __first = begin();
+        iterator __last = end();
+        while (__first != __last)
+   {
+     iterator __next = __first;
+     ++__next;
+     if (__pred(*__first))
+       {
+  _M_erase(__first);
+  ;
+       }
+     __first = __next;
+   }
+ return ;
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _BinaryPredicate>
+      typename list<_Tp, _Alloc>::__remove_return_type
+      list<_Tp, _Alloc>::
+      unique(_BinaryPredicate __binary_pred)
+      {
+        iterator __first = begin();
+        iterator __last = end();
+        if (__first == __last)
+   return ;
+        size_type __removed __attribute__((__unused__)) = 0;
+        iterator __next = __first;
+        while (++__next != __last)
+   {
+     if (__binary_pred(*__first, *__next))
+       {
+  _M_erase(__next);
+  ;
+       }
+     else
+       __first = __next;
+     __next = __first;
+   }
+ return ;
+      }
+
+
+
+  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;
+     list * __counter;
+     try
+       {
+  do
+    {
+      __carry.splice(__carry.begin(), *this, begin());
+
+      for(__counter = __tmp;
+   __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));
+       }
+     catch(...)
+       {
+  this->splice(this->end(), __carry);
+  for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
+    this->splice(this->end(), __tmp[__i]);
+  throw;
+       }
+   }
+      }
+
+
+
+}
+# 65 "/usr/include/c++/10.2.0/list" 2 3
+# 23 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h" 2
+
+
+
+# 25 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h"
+struct rct_drawpixelinfo;
+struct rct_window;
+union rct_window_event;
+struct track_design_file_ref;
+struct TitleSequence;
+struct TextInputSession;
+struct scenario_index_entry;
+
+enum class VisibilityCache : uint8_t;
+enum class CursorID : uint8_t;
+# 44 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h"
+extern uint16_t TextInputDescriptionArgs[4];
+extern char gTextBoxInput[1024];
+extern int32_t gMaxTextBoxInputLength;
+extern int32_t gTextBoxFrameNo;
+extern bool gUsingWidgetTextBox;
+extern struct TextInputSession* gTextInput;
+
+using wndproc = void(struct rct_window*, union rct_window_event*);
+
+using rct_windowclass = uint8_t;
+using rct_windownumber = uint16_t;
+using rct_widgetindex = int16_t;
+
+struct window_identifier
+{
+    rct_windowclass classification;
+    rct_windownumber number;
+};
+
+struct widget_identifier
+{
+    window_identifier window;
+    rct_widgetindex widget_index;
+};
+
+extern widget_identifier gCurrentTextBox;
+
+using WidgetFlags = uint32_t;
+namespace WIDGET_FLAGS
+{
+    const WidgetFlags TEXT_IS_STRING = 1 << 0;
+    const WidgetFlags IS_ENABLED = 1 << 1;
+    const WidgetFlags IS_PRESSED = 1 << 2;
+    const WidgetFlags IS_DISABLED = 1 << 3;
+    const WidgetFlags TOOLTIP_IS_STRING = 1 << 4;
+    const WidgetFlags IS_HIDDEN = 1 << 5;
+    const WidgetFlags IS_HOLDABLE = 1 << 6;
+}
+
+enum class WindowWidgetType : uint8_t;
+
+
+
+
+
+struct rct_widget
+{
+    WindowWidgetType type;
+    uint8_t colour;
+    int16_t left;
+    int16_t right;
+    int16_t top;
+    int16_t bottom;
+    union
+    {
+        uint32_t image;
+        rct_string_id text;
+        uint32_t content;
+        utf8* string;
+    };
+    rct_string_id tooltip;
+
+
+    WidgetFlags flags{};
+    utf8* sztooltip{};
+
+    int16_t width() const
+    {
+        return right - left;
+    }
+
+    int16_t height() const
+    {
+        return bottom - top;
+    }
+
+    int16_t midX() const
+    {
+        return (left + right) / 2;
+    }
+
+    int16_t midY() const
+    {
+        return (top + bottom) / 2;
+    }
+
+    int16_t textTop() const
+    {
+        if (height() >= 10)
+            return std::max<int32_t>(top, top + (height() / 2) - 5);
+        else
+            return top - 1;
+    }
+
+    bool IsVisible() const
+    {
+        return !(flags & WIDGET_FLAGS::IS_HIDDEN);
+    }
+};
+
+
+
+
+struct rct_viewport
+{
+    int16_t width;
+    int16_t height;
+    ScreenCoordsXY pos;
+    ScreenCoordsXY viewPos;
+    int16_t view_width;
+    int16_t view_height;
+    uint32_t flags;
+    ZoomLevel zoom;
+    uint8_t var_11;
+    VisibilityCache visibility;
+
+
+
+    [[nodiscard]] constexpr bool Contains(const ScreenCoordsXY& vpos) const
+    {
+        return (
+            vpos.y >= viewPos.y && vpos.y < viewPos.y + view_height && vpos.x >= viewPos.x && vpos.x < viewPos.x + view_width);
+    }
+
+
+    [[nodiscard]] constexpr bool ContainsScreen(const ScreenCoordsXY& sPos) const
+    {
+        return (sPos.x >= pos.x && sPos.x < pos.x + width && sPos.y >= pos.y && sPos.y < pos.y + height);
+    }
+
+    [[nodiscard]] ScreenCoordsXY ScreenToViewportCoord(const ScreenCoordsXY& screenCoord) const;
+
+    void Invalidate() const;
+};
+
+
+
+
+
+struct rct_scroll
+{
+    uint16_t flags{};
+    uint16_t h_left{};
+    uint16_t h_right{};
+    uint16_t h_thumb_left{};
+    uint16_t h_thumb_right{};
+    uint16_t v_top{};
+    uint16_t v_bottom{};
+    uint16_t v_thumb_top{};
+    uint16_t v_thumb_bottom{};
+};
+
+constexpr auto WINDOW_SCROLL_UNDEFINED = std::numeric_limits<uint16_t>::max();
+
+
+
+
+
+
+struct coordinate_focus
+{
+    int16_t var_480;
+    int16_t x;
+    int16_t y;
+    int16_t z;
+    uint8_t rotation;
+    uint8_t zoom;
+    int16_t width;
+    int16_t height;
+};
+
+
+struct sprite_focus
+{
+    int16_t var_480;
+    uint16_t sprite_id;
+    uint8_t pad_484;
+    uint8_t type;
+    uint16_t pad_486;
+    uint8_t rotation;
+    uint8_t zoom;
+};
+
+
+enum VIEWPORT_FOCUS_TYPE : uint8_t
+{
+    VIEWPORT_FOCUS_TYPE_COORDINATE = (1 << 6),
+    VIEWPORT_FOCUS_TYPE_SPRITE = (1 << 7)
+};
+
+
+struct viewport_focus
+{
+    VIEWPORT_FOCUS_TYPE type{};
+    union
+    {
+        sprite_focus sprite;
+        coordinate_focus coordinate;
+    };
+};
+
+struct rct_window_event_list
+{
+    void (*close)(struct rct_window*);
+    void (*mouse_up)(struct rct_window*, rct_widgetindex);
+    void (*resize)(struct rct_window*);
+    void (*mouse_down)(struct rct_window*, rct_widgetindex, rct_widget*);
+    void (*dropdown)(struct rct_window*, rct_widgetindex, int32_t);
+    void (*unknown_05)(struct rct_window*);
+    void (*update)(struct rct_window*);
+    void (*periodic_update)(struct rct_window*);
+    void (*unknown_08)(struct rct_window*);
+    void (*tool_update)(struct rct_window*, rct_widgetindex, const ScreenCoordsXY&);
+    void (*tool_down)(struct rct_window*, rct_widgetindex, const ScreenCoordsXY&);
+    void (*tool_drag)(struct rct_window*, rct_widgetindex, const ScreenCoordsXY&);
+    void (*tool_up)(struct rct_window*, rct_widgetindex, const ScreenCoordsXY&);
+    void (*tool_abort)(struct rct_window*, rct_widgetindex);
+    void (*unknown_0E)(struct rct_window*);
+    void (*get_scroll_size)(struct rct_window*, int32_t, int32_t*, int32_t*);
+    void (*scroll_mousedown)(struct rct_window*, int32_t, const ScreenCoordsXY&);
+    void (*scroll_mousedrag)(struct rct_window*, int32_t, const ScreenCoordsXY&);
+    void (*scroll_mouseover)(struct rct_window*, int32_t, const ScreenCoordsXY&);
+    void (*text_input)(struct rct_window*, rct_widgetindex, char*);
+    void (*viewport_rotate)(struct rct_window*);
+    void (*unknown_15)(struct rct_window*, int32_t, int32_t);
+    OpenRCT2String (*tooltip)(struct rct_window*, const rct_widgetindex, const rct_string_id);
+    void (*cursor)(struct rct_window*, rct_widgetindex, const ScreenCoordsXY&, CursorID*);
+    void (*moved)(struct rct_window*, const ScreenCoordsXY&);
+    void (*invalidate)(struct rct_window*);
+    void (*paint)(struct rct_window*, rct_drawpixelinfo*);
+    void (*scroll_paint)(struct rct_window*, rct_drawpixelinfo*, int32_t);
+
+    typedef void (*fnEventInitializer)(rct_window_event_list&);
+    rct_window_event_list(fnEventInitializer fn)
+    {
+        fn(*this);
+    }
+};
+
+struct campaign_variables
+{
+    int16_t campaign_type;
+    int16_t no_weeks;
+    union
+    {
+        ride_id_t RideId;
+        ObjectEntryIndex ShopItemId;
+    };
+    uint32_t pad_486;
+};
+
+struct new_ride_variables
+{
+    RideSelection SelectedRide;
+    RideSelection HighlightedRide;
+    uint16_t pad_484;
+    uint16_t pad_486;
+    uint16_t selected_ride_countdown;
+};
+
+struct news_variables
+{
+    int16_t var_480;
+    int16_t var_482;
+    uint16_t var_484;
+    uint16_t var_486;
+    uint16_t var_488;
+};
+
+struct map_variables
+{
+    int16_t rotation;
+    int16_t var_482;
+    uint16_t var_484;
+    uint16_t var_486;
+    uint16_t var_488;
+};
+
+struct ride_variables
+{
+    int16_t view;
+    int32_t var_482;
+    int32_t var_486;
+};
+
+struct scenery_variables
+{
+    ScenerySelection SelectedScenery;
+    int16_t hover_counter;
+};
+
+struct track_list_variables
+{
+    bool track_list_being_updated;
+    bool reload_track_designs;
+};
+
+struct error_variables
+{
+    uint16_t var_480;
+};
+
+struct rct_window;
+
+
+
+
+enum WINDOW_FLAGS
+{
+# 363 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h"
+    WF_STICK_TO_BACK = (1 << 0),
+    WF_STICK_TO_FRONT = (1 << 1),
+    WF_NO_SCROLLING = (1 << 2),
+    WF_SCROLLING_TO_LOCATION = (1 << 3),
+    WF_TRANSPARENT = (1 << 4),
+    WF_NO_BACKGROUND = (1 << 5),
+    WF_7 = (1 << 7),
+    WF_RESIZABLE = (1 << 8),
+    WF_NO_AUTO_CLOSE = (1 << 9),
+    WF_10 = (1 << 10),
+    WF_WHITE_BORDER_ONE = (1 << 12),
+    WF_WHITE_BORDER_MASK = (1 << 12) | (1 << 13),
+
+    WF_NO_SNAPPING = (1 << 15),
+
+
+    WF_AUTO_POSITION = (1 << 16),
+    WF_CENTRE_SCREEN = (1 << 17),
+};
+
+enum SCROLL_FLAGS
+{
+    HSCROLLBAR_VISIBLE = (1 << 0),
+    HSCROLLBAR_THUMB_PRESSED = (1 << 1),
+    HSCROLLBAR_LEFT_PRESSED = (1 << 2),
+    HSCROLLBAR_RIGHT_PRESSED = (1 << 3),
+    VSCROLLBAR_VISIBLE = (1 << 4),
+    VSCROLLBAR_THUMB_PRESSED = (1 << 5),
+    VSCROLLBAR_UP_PRESSED = (1 << 6),
+    VSCROLLBAR_DOWN_PRESSED = (1 << 7),
+};
+
+
+
+enum
+{
+    SCROLL_PART_NONE = -1,
+    SCROLL_PART_VIEW = 0,
+    SCROLL_PART_HSCROLLBAR_LEFT = 1,
+    SCROLL_PART_HSCROLLBAR_RIGHT = 2,
+    SCROLL_PART_HSCROLLBAR_LEFT_TROUGH = 3,
+    SCROLL_PART_HSCROLLBAR_RIGHT_TROUGH = 4,
+    SCROLL_PART_HSCROLLBAR_THUMB = 5,
+    SCROLL_PART_VSCROLLBAR_TOP = 6,
+    SCROLL_PART_VSCROLLBAR_BOTTOM = 7,
+    SCROLL_PART_VSCROLLBAR_TOP_TROUGH = 8,
+    SCROLL_PART_VSCROLLBAR_BOTTOM_TROUGH = 9,
+    SCROLL_PART_VSCROLLBAR_THUMB = 10,
+};
+
+enum
+{
+    WC_MAIN_WINDOW = 0,
+    WC_TOP_TOOLBAR = 1,
+    WC_BOTTOM_TOOLBAR = 2,
+    WC_TOOLTIP = 5,
+    WC_DROPDOWN = 6,
+    WC_ABOUT = 8,
+    WC_PUBLISHER_CREDITS = 9,
+    WC_MUSIC_CREDITS = 10,
+    WC_ERROR = 11,
+    WC_RIDE = 12,
+    WC_RIDE_CONSTRUCTION = 13,
+    WC_SAVE_PROMPT = 14,
+    WC_RIDE_LIST = 15,
+    WC_CONSTRUCT_RIDE = 16,
+    WC_DEMOLISH_RIDE_PROMPT = 17,
+    WC_SCENERY = 18,
+    WC_OPTIONS = 19,
+    WC_FOOTPATH = 20,
+    WC_LAND = 21,
+    WC_WATER = 22,
+    WC_PEEP = 23,
+    WC_GUEST_LIST = 24,
+    WC_STAFF_LIST = 25,
+    WC_FIRE_PROMPT = 26,
+    WC_PARK_INFORMATION = 27,
+    WC_FINANCES = 28,
+    WC_TITLE_MENU = 29,
+    WC_TITLE_EXIT = 30,
+    WC_RECENT_NEWS = 31,
+    WC_SCENARIO_SELECT = 32,
+    WC_TRACK_DESIGN_LIST = 33,
+    WC_TRACK_DESIGN_PLACE = 34,
+    WC_NEW_CAMPAIGN = 35,
+    WC_KEYBOARD_SHORTCUT_LIST = 36,
+    WC_CHANGE_KEYBOARD_SHORTCUT = 37,
+    WC_MAP = 38,
+    WC_TITLE_LOGO = 39,
+    WC_BANNER = 40,
+    WC_MAP_TOOLTIP = 41,
+    WC_EDITOR_OBJECT_SELECTION = 42,
+    WC_EDITOR_INVENTION_LIST = 43,
+    WC_EDITOR_INVENTION_LIST_DRAG = 44,
+    WC_EDITOR_SCENARIO_OPTIONS = 45,
+    WC_EDITOR_OBJECTIVE_OPTIONS = 46,
+    WC_MANAGE_TRACK_DESIGN = 47,
+    WC_TRACK_DELETE_PROMPT = 48,
+    WC_INSTALL_TRACK = 49,
+    WC_CLEAR_SCENERY = 50,
+    WC_SCENERY_SCATTER = 51,
+    WC_NOTIFICATION_OPTIONS = 109,
+    WC_CHEATS = 110,
+    WC_RESEARCH = 111,
+    WC_VIEWPORT = 112,
+    WC_TEXTINPUT = 113,
+    WC_MAPGEN = 114,
+    WC_LOADSAVE = 115,
+    WC_LOADSAVE_OVERWRITE_PROMPT = 116,
+    WC_TITLE_OPTIONS = 117,
+    WC_LAND_RIGHTS = 118,
+    WC_THEMES = 119,
+    WC_TILE_INSPECTOR = 120,
+    WC_CHANGELOG = 121,
+    WC_TITLE_EDITOR = 122,
+    WC_TITLE_COMMAND_EDITOR = 123,
+    WC_MULTIPLAYER = 124,
+    WC_PLAYER = 125,
+    WC_NETWORK_STATUS = 126,
+    WC_SERVER_LIST = 127,
+    WC_SERVER_START = 128,
+    WC_CUSTOM_CURRENCY_CONFIG = 129,
+    WC_DEBUG_PAINT = 130,
+    WC_VIEW_CLIPPING = 131,
+    WC_OBJECT_LOAD_ERROR = 132,
+
+
+    WC_STAFF = 220,
+    WC_EDITOR_TRACK_BOTTOM_TOOLBAR = 221,
+    WC_EDITOR_SCENARIO_BOTTOM_TOOLBAR = 222,
+    WC_CHAT = 223,
+    WC_CONSOLE = 224,
+    WC_CUSTOM = 225,
+
+    WC_NULL = 255,
+};
+
+enum
+{
+    WV_PARK_AWARDS,
+    WV_PARK_RATING,
+    WV_PARK_OBJECTIVE,
+    WV_PARK_GUESTS,
+    WV_FINANCES_RESEARCH,
+    WV_RIDE_RESEARCH,
+    WV_MAZE_CONSTRUCTION,
+    WV_NETWORK_PASSWORD,
+    WV_EDITOR_BOTTOM_TOOLBAR,
+    WV_EDITOR_MAIN,
+    WV_CHANGELOG,
+    WV_NEW_VERSION_INFO,
+};
+
+enum
+{
+    WD_BANNER,
+    WD_NEW_CAMPAIGN,
+    WD_DEMOLISH_RIDE,
+    WD_REFURBISH_RIDE,
+    WD_SIGN,
+    WD_SIGN_SMALL,
+
+    WD_PLAYER,
+
+    WD_VEHICLE,
+    WD_TRACK,
+};
+# 592 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Window.h"
+enum class PromptMode : uint8_t
+{
+    SaveBeforeLoad = 0,
+    SaveBeforeQuit,
+    SaveBeforeQuit2,
+    Quit
+};
+
+enum BTM_TOOLBAR_DIRTY_FLAGS
+{
+    BTM_TB_DIRTY_FLAG_MONEY = (1 << 0),
+    BTM_TB_DIRTY_FLAG_DATE = (1 << 1),
+    BTM_TB_DIRTY_FLAG_PEEP_COUNT = (1 << 2),
+    BTM_TB_DIRTY_FLAG_CLIMATE = (1 << 3),
+    BTM_TB_DIRTY_FLAG_PARK_RATING = (1 << 4)
+};
+
+
+enum
+{
+    LOADSAVETYPE_LOAD = 0 << 0,
+    LOADSAVETYPE_SAVE = 1 << 0,
+
+    LOADSAVETYPE_GAME = 0 << 1,
+    LOADSAVETYPE_LANDSCAPE = 1 << 1,
+    LOADSAVETYPE_SCENARIO = 2 << 1,
+    LOADSAVETYPE_TRACK = 3 << 1,
+    LOADSAVETYPE_HEIGHTMAP = 4 << 1,
+};
+
+enum
+{
+    MODAL_RESULT_FAIL = -1,
+    MODAL_RESULT_CANCEL,
+    MODAL_RESULT_OK
+};
+
+enum class VisibilityCache : uint8_t
+{
+    Unknown,
+    Visible,
+    Covered
+};
+
+enum class GuestListFilterType : int32_t
+{
+    GuestsOnRide,
+    GuestsInQueue,
+    GuestsThinkingAboutRide,
+    GuestsThinkingX,
+};
+
+enum class Tool
+{
+    Arrow = 0,
+    UpArrow = 2,
+    UpDownArrow = 3,
+    Picker = 7,
+    Crosshair = 12,
+    PathDown = 17,
+    DigDown = 18,
+    WaterDown = 19,
+    WalkDown = 22,
+    PaintDown = 23,
+    EntranceDown = 24,
+};
+
+using modal_callback = void (*)(int32_t result);
+using close_callback = void (*)();
+
+
+
+
+
+extern rct_window* gWindowAudioExclusive;
+
+extern uint16_t gWindowUpdateTicks;
+namespace MapFlashingFlags
+{
+    constexpr uint16_t GuestListOpen = (1 << 0);
+    constexpr uint16_t FlashGuests = (1 << 1);
+    constexpr uint16_t StaffListOpen = (1 << 2);
+    constexpr uint16_t FlashStaff = (1 << 3);
+    constexpr uint16_t SwitchColour = (1 << 15);
+}
+extern uint16_t gWindowMapFlashingFlags;
+
+extern colour_t gCurrentWindowColours[4];
+
+extern bool gDisableErrorWindowSound;
+
+std::list<std::shared_ptr<rct_window>>::iterator window_get_iterator(const rct_window* w);
+void window_visit_each(std::function<void(rct_window*)> func);
+
+void window_dispatch_update_all();
+void window_update_all_viewports();
+void window_update_all();
+
+void window_set_window_limit(int32_t value);
+
+rct_window* window_bring_to_front(rct_window* w);
+rct_window* window_bring_to_front_by_class(rct_windowclass cls);
+rct_window* window_bring_to_front_by_class_with_flags(rct_windowclass cls, uint16_t flags);
+rct_window* window_bring_to_front_by_number(rct_windowclass cls, rct_windownumber number);
+
+rct_window* WindowCreate(
+    std::unique_ptr<rct_window>&& w, rct_windowclass cls, ScreenCoordsXY pos, int32_t width, int32_t height, uint32_t flags);
+template<typename T, typename std::enable_if<std::is_base_of<rct_window, T>::value>::type* = nullptr>
+T* WindowCreate(rct_windowclass cls, const ScreenCoordsXY& pos, int32_t width, int32_t height, uint32_t flags = 0)
+{
+    return static_cast<T*>(WindowCreate(std::make_unique<T>(), cls, pos, width, height, flags));
+}
+template<typename T, typename std::enable_if<std::is_base_of<rct_window, T>::value>::type* = nullptr>
+T* WindowCreate(rct_windowclass cls, int32_t width, int32_t height, uint32_t flags = 0)
+{
+    return static_cast<T*>(WindowCreate(std::make_unique<T>(), cls, {}, width, height, flags | WF_AUTO_POSITION));
+}
+template<typename T, typename std::enable_if<std::is_base_of<rct_window, T>::value>::type* = nullptr>
+T* WindowFocusOrCreate(rct_windowclass cls, const ScreenCoordsXY& pos, int32_t width, int32_t height, uint32_t flags = 0)
+{
+    auto* w = window_bring_to_front_by_class(cls);
+    if (w == nullptr)
+    {
+        w = WindowCreate<T>(cls, pos, width, height, flags);
+    }
+    return static_cast<T*>(w);
+}
+template<typename T, typename std::enable_if<std::is_base_of<rct_window, T>::value>::type* = nullptr>
+T* WindowFocusOrCreate(rct_windowclass cls, int32_t width, int32_t height, uint32_t flags = 0)
+{
+    auto* w = window_bring_to_front_by_class(cls);
+    if (w == nullptr)
+    {
+        w = WindowCreate<T>(cls, width, height, flags);
+    }
+    return static_cast<T*>(w);
+}
+
+rct_window* WindowCreate(
+    const ScreenCoordsXY& pos, int32_t width, int32_t height, rct_window_event_list* event_handlers, rct_windowclass cls,
+    uint32_t flags);
+rct_window* WindowCreateAutoPos(
+    int32_t width, int32_t height, rct_window_event_list* event_handlers, rct_windowclass cls, uint32_t flags);
+rct_window* WindowCreateCentred(
+    int32_t width, int32_t height, rct_window_event_list* event_handlers, rct_windowclass cls, uint32_t flags);
+
+void window_close(rct_window* window);
+void window_close_by_class(rct_windowclass cls);
+void window_close_by_number(rct_windowclass cls, rct_windownumber number);
+void window_close_top();
+void window_close_all();
+void window_close_all_except_class(rct_windowclass cls);
+void window_close_all_except_flags(uint16_t flags);
+rct_window* window_find_by_class(rct_windowclass cls);
+rct_window* window_find_by_number(rct_windowclass cls, rct_windownumber number);
+rct_window* window_find_from_point(const ScreenCoordsXY& screenCoords);
+rct_widgetindex window_find_widget_from_point(rct_window* w, const ScreenCoordsXY& screenCoords);
+void window_invalidate_by_class(rct_windowclass cls);
+void window_invalidate_by_number(rct_windowclass cls, rct_windownumber number);
+void window_invalidate_all();
+void widget_invalidate(rct_window* w, rct_widgetindex widgetIndex);
+void widget_invalidate_by_class(rct_windowclass cls, rct_widgetindex widgetIndex);
+void widget_invalidate_by_number(rct_windowclass cls, rct_windownumber number, rct_widgetindex widgetIndex);
+void WindowInitScrollWidgets(rct_window* w);
+void window_update_scroll_widgets(rct_window* w);
+int32_t window_get_scroll_data_index(rct_window* w, rct_widgetindex widget_index);
+
+void window_push_others_right(rct_window* w);
+void window_push_others_below(rct_window* w1);
+
+rct_window* window_get_main();
+
+void window_scroll_to_location(rct_window* w, const CoordsXYZ& coords);
+void window_rotate_camera(rct_window* w, int32_t direction);
+void window_viewport_get_map_coords_by_cursor(
+    rct_window* w, int16_t* map_x, int16_t* map_y, int16_t* offset_x, int16_t* offset_y);
+void window_viewport_centre_tile_around_cursor(rct_window* w, int16_t map_x, int16_t map_y, int16_t offset_x, int16_t offset_y);
+void window_check_all_valid_zoom();
+void window_zoom_set(rct_window* w, ZoomLevel zoomLevel, bool atCursor);
+void window_zoom_in(rct_window* w, bool atCursor);
+void window_zoom_out(rct_window* w, bool atCursor);
+void main_window_zoom(bool zoomIn, bool atCursor);
+
+void window_show_textinput(rct_window* w, rct_widgetindex widgetIndex, uint16_t title, uint16_t text, int32_t value);
+
+void window_draw_all(rct_drawpixelinfo* dpi, int16_t left, int16_t top, int16_t right, int16_t bottom);
+void window_draw(rct_drawpixelinfo* dpi, rct_window* w, int32_t left, int32_t top, int32_t right, int32_t bottom);
+void WindowDrawWidgets(rct_window* w, rct_drawpixelinfo* dpi);
+void window_draw_viewport(rct_drawpixelinfo* dpi, rct_window* w);
+
+void window_set_position(rct_window* w, const ScreenCoordsXY& screenCoords);
+void window_move_position(rct_window* w, const ScreenCoordsXY& screenCoords);
+void window_resize(rct_window* w, int32_t dw, int32_t dh);
+void window_set_resize(rct_window* w, int32_t minWidth, int32_t minHeight, int32_t maxWidth, int32_t maxHeight);
+
+bool tool_set(rct_window* w, rct_widgetindex widgetIndex, Tool tool);
+void tool_cancel();
+
+void window_close_construction_windows();
+
+void window_update_viewport_ride_music();
+
+rct_viewport* window_get_viewport(rct_window* window);
+
+
+void window_relocate_windows(int32_t width, int32_t height);
+void window_resize_gui(int32_t width, int32_t height);
+void window_resize_gui_scenario_editor(int32_t width, int32_t height);
+void window_ride_construct(rct_window* w);
+void ride_construction_toolupdate_entrance_exit(const ScreenCoordsXY& screenCoords);
+void ride_construction_toolupdate_construct(const ScreenCoordsXY& screenCoords);
+void ride_construction_tooldown_construct(const ScreenCoordsXY& screenCoords);
+
+void window_bubble_list_item(rct_window* w, int32_t item_position);
+
+void window_align_tabs(rct_window* w, rct_widgetindex start_tab_id, rct_widgetindex end_tab_id);
+
+void window_staff_list_init_vars();
+
+void window_event_close_call(rct_window* w);
+void window_event_mouse_up_call(rct_window* w, rct_widgetindex widgetIndex);
+void window_event_resize_call(rct_window* w);
+void window_event_mouse_down_call(rct_window* w, rct_widgetindex widgetIndex);
+void window_event_dropdown_call(rct_window* w, rct_widgetindex widgetIndex, int32_t dropdownIndex);
+void window_event_unknown_05_call(rct_window* w);
+void window_event_update_call(rct_window* w);
+void window_event_periodic_update_call(rct_window* w);
+void window_event_unknown_08_call(rct_window* w);
+void window_event_tool_update_call(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords);
+void window_event_tool_down_call(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords);
+void window_event_tool_drag_call(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords);
+void window_event_tool_up_call(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords);
+void window_event_tool_abort_call(rct_window* w, rct_widgetindex widgetIndex);
+void window_event_unknown_0E_call(rct_window* w);
+void window_get_scroll_size(rct_window* w, int32_t scrollIndex, int32_t* width, int32_t* height);
+void window_event_scroll_mousedown_call(rct_window* w, int32_t scrollIndex, const ScreenCoordsXY& screenCoords);
+void window_event_scroll_mousedrag_call(rct_window* w, int32_t scrollIndex, const ScreenCoordsXY& screenCoords);
+void window_event_scroll_mouseover_call(rct_window* w, int32_t scrollIndex, const ScreenCoordsXY& screenCoords);
+void window_event_textinput_call(rct_window* w, rct_widgetindex widgetIndex, char* text);
+void window_event_viewport_rotate_call(rct_window* w);
+void window_event_unknown_15_call(rct_window* w, int32_t scrollIndex, int32_t scrollAreaType);
+OpenRCT2String window_event_tooltip_call(rct_window* w, const rct_widgetindex widgetIndex, const rct_string_id fallback);
+CursorID window_event_cursor_call(rct_window* w, rct_widgetindex widgetIndex, const ScreenCoordsXY& screenCoords);
+void window_event_moved_call(rct_window* w, const ScreenCoordsXY& screenCoords);
+void window_event_invalidate_call(rct_window* w);
+void window_event_paint_call(rct_window* w, rct_drawpixelinfo* dpi);
+void window_event_scroll_paint_call(rct_window* w, rct_drawpixelinfo* dpi, int32_t scrollIndex);
+
+void InvalidateAllWindowsAfterInput();
+void textinput_cancel();
+
+void window_move_and_snap(rct_window* w, ScreenCoordsXY newWindowCoords, int32_t snapProximity);
+int32_t window_can_resize(rct_window* w);
+
+void window_start_textbox(
+    rct_window* call_w, rct_widgetindex call_widget, rct_string_id existing_text, char* existing_args, int32_t maxLength);
+void window_cancel_textbox();
+void window_update_textbox_caret();
+void window_update_textbox();
+
+bool window_is_visible(rct_window* w);
+
+bool scenery_tool_is_active();
+
+rct_viewport* window_get_previous_viewport(rct_viewport* current);
+void window_reset_visibilities();
+void window_init_all();
+
+
+void toggle_ingame_land_ownership_editor();
+
+void window_ride_construction_keyboard_shortcut_turn_left();
+void window_ride_construction_keyboard_shortcut_turn_right();
+void window_ride_construction_keyboard_shortcut_use_track_default();
+void window_ride_construction_keyboard_shortcut_slope_down();
+void window_ride_construction_keyboard_shortcut_slope_up();
+void window_ride_construction_keyboard_shortcut_chain_lift_toggle();
+void window_ride_construction_keyboard_shortcut_bank_left();
+void window_ride_construction_keyboard_shortcut_bank_right();
+void window_ride_construction_keyboard_shortcut_previous_track();
+void window_ride_construction_keyboard_shortcut_next_track();
+void window_ride_construction_keyboard_shortcut_build_current();
+void window_ride_construction_keyboard_shortcut_demolish_current();
+
+void window_footpath_keyboard_shortcut_turn_left();
+void window_footpath_keyboard_shortcut_turn_right();
+void window_footpath_keyboard_shortcut_slope_down();
+void window_footpath_keyboard_shortcut_slope_up();
+void window_footpath_keyboard_shortcut_build_current();
+void window_footpath_keyboard_shortcut_demolish_current();
+
+void window_follow_sprite(rct_window* w, size_t spriteIndex);
+void window_unfollow_sprite(rct_window* w);
+
+bool window_ride_construction_update_state(
+    int32_t* trackType, int32_t* trackDirection, ride_id_t* rideIndex, int32_t* _liftHillAndAlternativeState,
+    CoordsXYZ* trackPos, int32_t* properties);
+money32 place_provisional_track_piece(
+    ride_id_t rideIndex, int32_t trackType, int32_t trackDirection, int32_t liftHillAndAlternativeState,
+    const CoordsXYZ& trackPos);
+
+extern uint64_t _enabledRidePieces;
+extern uint8_t _rideConstructionState2;
+extern bool _stationConstructed;
+extern bool _deferClose;
+
+rct_window* window_get_listening();
+rct_windowclass window_get_classification(rct_window* window);
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/../interface/Viewport.h" 2
+
+
+
+
+
+struct paint_session;
+struct paint_struct;
+struct rct_drawpixelinfo;
+struct Peep;
+struct TileElement;
+struct rct_window;
+union paint_entry;
+struct SpriteBase;
+
+enum
+{
+    VIEWPORT_FLAG_UNDERGROUND_INSIDE = (1 << 0),
+    VIEWPORT_FLAG_SEETHROUGH_RIDES = (1 << 1),
+    VIEWPORT_FLAG_SEETHROUGH_SCENERY = (1 << 2),
+    VIEWPORT_FLAG_INVISIBLE_SUPPORTS = (1 << 3),
+    VIEWPORT_FLAG_LAND_HEIGHTS = (1 << 4),
+    VIEWPORT_FLAG_TRACK_HEIGHTS = (1 << 5),
+    VIEWPORT_FLAG_PATH_HEIGHTS = (1 << 6),
+    VIEWPORT_FLAG_GRIDLINES = (1 << 7),
+    VIEWPORT_FLAG_LAND_OWNERSHIP = (1 << 8),
+    VIEWPORT_FLAG_CONSTRUCTION_RIGHTS = (1 << 9),
+    VIEWPORT_FLAG_SOUND_ON = (1 << 10),
+    VIEWPORT_FLAG_INVISIBLE_PEEPS = (1 << 11),
+    VIEWPORT_FLAG_HIDE_BASE = (1 << 12),
+    VIEWPORT_FLAG_HIDE_VERTICAL = (1 << 13),
+    VIEWPORT_FLAG_INVISIBLE_SPRITES = (1 << 14),
+    VIEWPORT_FLAG_15 = (1 << 15),
+    VIEWPORT_FLAG_SEETHROUGH_PATHS = (1 << 16),
+    VIEWPORT_FLAG_CLIP_VIEW = (1 << 17),
+    VIEWPORT_FLAG_HIGHLIGHT_PATH_ISSUES = (1 << 18),
+    VIEWPORT_FLAG_TRANSPARENT_BACKGROUND = (1 << 19),
+};
+
+enum class ViewportInteractionItem : uint8_t
+{
+    None,
+    Terrain,
+    Entity,
+    Ride,
+    Water,
+    Scenery,
+    Footpath,
+    FootpathItem,
+    ParkEntrance,
+    Wall,
+    LargeScenery,
+    Label,
+    Banner
+};
+
+constexpr uint16_t ViewportInteractionItemAll = std::numeric_limits<uint16_t>::max();
+
+struct InteractionInfo
+{
+    InteractionInfo() = default;
+    InteractionInfo(const paint_struct* ps);
+    CoordsXY Loc;
+    union
+    {
+        TileElement* Element = nullptr;
+        SpriteBase* Entity;
+    };
+    ViewportInteractionItem SpriteType = ViewportInteractionItem::None;
+};
+
+
+
+
+
+
+
+extern uint8_t gShowGridLinesRefCount;
+extern uint8_t gShowLandRightsRefCount;
+extern uint8_t gShowConstuctionRightsRefCount;
+
+
+extern rct_viewport* g_music_tracking_viewport;
+extern ScreenCoordsXY gSavedView;
+extern ZoomLevel gSavedViewZoom;
+extern uint8_t gSavedViewRotation;
+
+extern paint_entry* gNextFreePaintStruct;
+extern uint8_t gCurrentRotation;
+
+void viewport_init_all();
+std::optional<ScreenCoordsXY> centre_2d_coordinates(const CoordsXYZ& loc, rct_viewport* viewport);
+void viewport_create(
+    rct_window* w, const ScreenCoordsXY& screenCoords, int32_t width, int32_t height, int32_t zoom, CoordsXYZ centrePos,
+    char flags, uint16_t sprite);
+void viewport_remove(rct_viewport* viewport);
+void viewports_invalidate(int32_t left, int32_t top, int32_t right, int32_t bottom, int32_t maxZoom = -1);
+void viewport_update_position(rct_window* window);
+void viewport_update_sprite_follow(rct_window* window);
+void viewport_update_smart_sprite_follow(rct_window* window);
+viewport_focus viewport_update_smart_guest_follow(rct_window* window, Peep* peep);
+void viewport_update_smart_staff_follow(rct_window* window, Peep* peep);
+void viewport_update_smart_vehicle_follow(rct_window* window);
+void viewport_render(
+    rct_drawpixelinfo* dpi, const rct_viewport* viewport, int32_t left, int32_t top, int32_t right, int32_t bottom,
+    std::vector<paint_session>* sessions = nullptr);
+void viewport_paint(
+    const rct_viewport* viewport, rct_drawpixelinfo* dpi, int16_t left, int16_t top, int16_t right, int16_t bottom,
+    std::vector<paint_session>* sessions = nullptr);
+
+CoordsXYZ viewport_adjust_for_map_height(const ScreenCoordsXY& startCoords);
+
+CoordsXY viewport_coord_to_map_coord(const ScreenCoordsXY& coords, int32_t z);
+std::optional<CoordsXY> screen_pos_to_map_pos(const ScreenCoordsXY& screenCoords, int32_t* direction);
+
+void show_gridlines();
+void hide_gridlines();
+void show_land_rights();
+void hide_land_rights();
+void show_construction_rights();
+void hide_construction_rights();
+void viewport_set_visibility(uint8_t mode);
+
+InteractionInfo get_map_coordinates_from_pos(const ScreenCoordsXY& screenCoords, int32_t flags);
+InteractionInfo get_map_coordinates_from_pos_window(rct_window* window, const ScreenCoordsXY& screenCoords, int32_t flags);
+
+InteractionInfo set_interaction_info_from_paint_session(paint_session* session, uint16_t filter);
+InteractionInfo ViewportInteractionGetItemLeft(const ScreenCoordsXY& screenCoords);
+bool ViewportInteractionLeftOver(const ScreenCoordsXY& screenCoords);
+bool ViewportInteractionLeftClick(const ScreenCoordsXY& screenCoords);
+InteractionInfo ViewportInteractionGetItemRight(const ScreenCoordsXY& screenCoords);
+bool ViewportInteractionRightOver(const ScreenCoordsXY& screenCoords);
+bool ViewportInteractionRightClick(const ScreenCoordsXY& screenCoords);
+
+CoordsXY ViewportInteractionGetTileStartAtCursor(const ScreenCoordsXY& screenCoords);
+void sub_68B2B7(paint_session* session, const CoordsXY& mapCoords);
+
+void viewport_invalidate(const rct_viewport* viewport, int32_t left, int32_t top, int32_t right, int32_t bottom);
+
+std::optional<CoordsXY> screen_get_map_xy(const ScreenCoordsXY& screenCoords, rct_viewport** viewport);
+std::optional<CoordsXY> screen_get_map_xy_with_z(const ScreenCoordsXY& screenCoords, int16_t z);
+std::optional<CoordsXY> screen_get_map_xy_quadrant(const ScreenCoordsXY& screenCoords, uint8_t* quadrant);
+std::optional<CoordsXY> screen_get_map_xy_quadrant_with_z(const ScreenCoordsXY& screenCoords, int16_t z, uint8_t* quadrant);
+std::optional<CoordsXY> screen_get_map_xy_side(const ScreenCoordsXY& screenCoords, uint8_t* side);
+std::optional<CoordsXY> screen_get_map_xy_side_with_z(const ScreenCoordsXY& screenCoords, int16_t z, uint8_t* side);
+
+uint8_t get_current_rotation();
+int16_t get_height_marker_offset();
+
+void viewport_set_saved_view();
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Footpath.h" 2
+
+
+enum
+{
+    PROVISIONAL_PATH_FLAG_SHOW_ARROW = (1 << 0),
+    PROVISIONAL_PATH_FLAG_1 = (1 << 1),
+    PROVISIONAL_PATH_FLAG_2 = (1 << 2),
+};
+
+constexpr auto FootpathMaxHeight = 248 * COORDS_Z_STEP;
+constexpr auto FootpathMinHeight = 2 * COORDS_Z_STEP;
+constexpr auto PATH_HEIGHT_STEP = 2 * COORDS_Z_STEP;
+constexpr auto PATH_CLEARANCE = 4 * COORDS_Z_STEP;
+
+
+
+using PathSurfaceIndex = uint16_t;
+constexpr PathSurfaceIndex PATH_SURFACE_INDEX_NULL = static_cast<PathSurfaceIndex>(-1);
+
+using PathRailingsIndex = uint8_t;
+constexpr PathRailingsIndex PATH_RAILINGS_INDEX_NULL = static_cast<PathRailingsIndex>(-1);
+
+enum class RailingEntrySupportType : uint8_t
+{
+    Box = 0,
+    Pole = 1,
+    Count
+};
+
+#pragma pack(push, 1)
+struct rct_footpath_entry
+{
+    rct_string_id string_idx;
+    uint32_t image;
+    uint32_t bridge_image;
+    RailingEntrySupportType support_type;
+    uint8_t flags;
+    uint8_t scrolling_mode;
+};
+static_assert(sizeof(rct_footpath_entry) == (13), "Improper struct size");
+#pragma pack(pop)
+
+struct PathSurfaceEntry
+{
+    rct_string_id string_idx;
+    uint32_t image;
+    uint32_t preview;
+    uint8_t flags;
+};
+
+struct PathRailingsEntry
+{
+    rct_string_id string_idx;
+    uint32_t preview;
+    uint32_t bridge_image;
+    uint32_t railings_image;
+    RailingEntrySupportType support_type;
+    uint8_t flags;
+    uint8_t scrolling_mode;
+};
+
+
+enum
+{
+    FOOTPATH_ELEMENT_TYPE_FLAG_IS_QUEUE = (1 << 0),
+    FOOTPATH_ELEMENT_TYPE_FLAG_IS_WIDE = (1 << 1),
+    FOOTPATH_ELEMENT_TYPE_DIRECTION_MASK = (1 << 6) | (1 << 7),
+};
+
+
+enum
+{
+    FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK = (1 << 0) | (1 << 1),
+    FOOTPATH_PROPERTIES_FLAG_IS_SLOPED = (1 << 2),
+    FOOTPATH_PROPERTIES_FLAG_HAS_QUEUE_BANNER = (1 << 3),
+    FOOTPATH_PROPERTIES_TYPE_MASK = (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7),
+};
+
+
+enum
+{
+    FOOTPATH_PROPERTIES_EDGES_EDGES_MASK = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3),
+    FOOTPATH_PROPERTIES_EDGES_CORNERS_MASK = (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7),
+};
+
+enum
+{
+    FOOTPATH_ELEMENT_FLAGS2_IS_SLOPED = 1 << 0,
+    FOOTPATH_ELEMENT_FLAGS2_HAS_QUEUE_BANNER = (1 << 1),
+    FOOTPATH_ELEMENT_FLAGS2_ADDITION_IS_GHOST = (1 << 2),
+    FOOTPATH_ELEMENT_FLAGS2_BLOCKED_BY_VEHICLE = (1 << 3),
+    FOOTPATH_ELEMENT_FLAGS2_ADDITION_IS_BROKEN = (1 << 4),
+};
+
+enum
+{
+    FOOTPATH_ENTRY_FLAG_SHOW_ONLY_IN_SCENARIO_EDITOR = (1 << 2),
+    FOOTPATH_ENTRY_FLAG_IS_QUEUE = (1 << 3),
+};
+
+enum
+{
+    RAILING_ENTRY_FLAG_HAS_SUPPORT_BASE_SPRITE = (1 << 0),
+    RAILING_ENTRY_FLAG_DRAW_PATH_OVER_SUPPORTS = (1 << 1),
+};
+
+enum
+{
+    FOOTPATH_SEARCH_SUCCESS,
+    FOOTPATH_SEARCH_NOT_FOUND,
+    FOOTPATH_SEARCH_INCOMPLETE,
+    FOOTPATH_SEARCH_TOO_COMPLEX
+};
+
+enum
+{
+    SLOPE_IS_IRREGULAR_FLAG = (1 << 3),
+    RAISE_FOOTPATH_FLAG = (1 << 4)
+};
+
+enum
+{
+    FOOTPATH_CORNER_0 = (1 << 0),
+    FOOTPATH_CORNER_1 = (1 << 1),
+    FOOTPATH_CORNER_2 = (1 << 2),
+    FOOTPATH_CORNER_3 = (1 << 3),
+};
+
+enum
+{
+    FOOTPATH_CONNECTION_S = (1 << 0),
+    FOOTPATH_CONNECTION_NE = (1 << 1),
+    FOOTPATH_CONNECTION_W = (1 << 2),
+    FOOTPATH_CONNECTION_SE = (1 << 3),
+    FOOTPATH_CONNECTION_N = (1 << 4),
+    FOOTPATH_CONNECTION_SW = (1 << 5),
+    FOOTPATH_CONNECTION_E = (1 << 6),
+    FOOTPATH_CONNECTION_NW = (1 << 7),
+};
+
+enum
+{
+    FOOTPATH_CONNECTED_MAP_EDGE_IGNORE_QUEUES = (1 << 0),
+    FOOTPATH_CONNECTED_MAP_EDGE_UNOWN = (1 << 5),
+    FOOTPATH_CONNECTED_MAP_EDGE_IGNORE_NO_ENTRY = (1 << 7)
+};
+
+extern uint8_t gFootpathProvisionalFlags;
+extern CoordsXYZ gFootpathProvisionalPosition;
+extern uint8_t gFootpathProvisionalType;
+extern uint8_t gFootpathProvisionalSlope;
+extern uint8_t gFootpathConstructionMode;
+extern uint16_t gFootpathSelectedId;
+extern uint8_t gFootpathSelectedType;
+extern CoordsXYZ gFootpathConstructFromPosition;
+extern uint8_t gFootpathConstructDirection;
+extern uint8_t gFootpathConstructSlope;
+extern uint8_t gFootpathConstructValidDirections;
+extern money32 gFootpathPrice;
+extern uint8_t gFootpathGroundFlags;
+
+
+extern const CoordsXY DirectionOffsets[NumOrthogonalDirections];
+extern const CoordsXY BinUseOffsets[NumOrthogonalDirections];
+extern const CoordsXY BenchUseOffsets[NumOrthogonalDirections * 2];
+
+TileElement* map_get_footpath_element(const CoordsXYZ& coords);
+void footpath_interrupt_peeps(const CoordsXYZ& footpathPos);
+money32 footpath_remove(const CoordsXYZ& footpathLoc, int32_t flags);
+money32 footpath_provisional_set(int32_t type, const CoordsXYZ& footpathLoc, int32_t slope);
+void footpath_provisional_remove();
+void footpath_provisional_update();
+CoordsXY footpath_get_coordinates_from_pos(const ScreenCoordsXY& screenCoords, int32_t* direction, TileElement** tileElement);
+CoordsXY footpath_bridge_get_info_from_pos(const ScreenCoordsXY& screenCoords, int32_t* direction, TileElement** tileElement);
+void footpath_remove_litter(const CoordsXYZ& footpathPos);
+void footpath_connect_edges(const CoordsXY& footpathPos, TileElement* tileElement, int32_t flags);
+void footpath_update_queue_chains();
+bool fence_in_the_way(const CoordsXYRangedZ& fencePos, int32_t direction);
+void footpath_chain_ride_queue(
+    ride_id_t rideIndex, int32_t entranceIndex, const CoordsXY& footpathPos, TileElement* tileElement, int32_t direction);
+void footpath_update_path_wide_flags(const CoordsXY& footpathPos);
+bool footpath_is_blocked_by_vehicle(const TileCoordsXYZ& position);
+
+int32_t footpath_is_connected_to_map_edge(const CoordsXYZ& footpathPos, int32_t direction, int32_t flags);
+void footpath_remove_edges_at(const CoordsXY& footpathPos, TileElement* tileElement);
+int32_t entrance_get_directions(const TileElement* tileElement);
+
+PathSurfaceEntry* get_path_surface_entry(PathSurfaceIndex entryIndex);
+PathRailingsEntry* get_path_railings_entry(PathRailingsIndex entryIndex);
+
+void footpath_queue_chain_reset();
+void footpath_queue_chain_push(ride_id_t rideIndex);
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/TileElement.h" 2
+
+struct Banner;
+struct CoordsXY;
+struct rct_scenery_entry;
+struct rct_footpath_entry;
+class LargeSceneryObject;
+class TerrainSurfaceObject;
+class TerrainEdgeObject;
+using track_type_t = uint16_t;
+
+constexpr const uint8_t MAX_ELEMENT_HEIGHT = 255;
+constexpr const uint8_t OWNER_MASK = 0b00001111;
+
+#pragma pack(push, 1)
+
+enum
+{
+    TILE_ELEMENT_TYPE_SURFACE = (0 << 2),
+    TILE_ELEMENT_TYPE_PATH = (1 << 2),
+    TILE_ELEMENT_TYPE_TRACK = (2 << 2),
+    TILE_ELEMENT_TYPE_SMALL_SCENERY = (3 << 2),
+    TILE_ELEMENT_TYPE_ENTRANCE = (4 << 2),
+    TILE_ELEMENT_TYPE_WALL = (5 << 2),
+    TILE_ELEMENT_TYPE_LARGE_SCENERY = (6 << 2),
+    TILE_ELEMENT_TYPE_BANNER = (7 << 2),
+};
+
+enum class TileElementType : uint8_t
+{
+    Surface = (0 << 2),
+    Path = (1 << 2),
+    Track = (2 << 2),
+    SmallScenery = (3 << 2),
+    Entrance = (4 << 2),
+    Wall = (5 << 2),
+    LargeScenery = (6 << 2),
+    Banner = (7 << 2),
+};
+
+struct TileElement;
+struct SurfaceElement;
+struct PathElement;
+struct TrackElement;
+struct SmallSceneryElement;
+struct LargeSceneryElement;
+struct WallElement;
+struct EntranceElement;
+struct BannerElement;
+
+struct TileElementBase
+{
+    uint8_t type;
+    uint8_t Flags;
+    uint8_t base_height;
+    uint8_t clearance_height;
+    uint8_t owner;
+
+    void Remove();
+
+    uint8_t GetType() const;
+    void SetType(uint8_t newType);
+
+    Direction GetDirection() const;
+    void SetDirection(Direction direction);
+    Direction GetDirectionWithOffset(uint8_t offset) const;
+
+    bool IsLastForTile() const;
+    void SetLastForTile(bool on);
+    bool IsGhost() const;
+    void SetGhost(bool isGhost);
+    bool IsInvisible() const;
+    void SetInvisible(bool on);
+
+    uint8_t GetOccupiedQuadrants() const;
+    void SetOccupiedQuadrants(uint8_t quadrants);
+
+    int32_t GetBaseZ() const;
+    void SetBaseZ(int32_t newZ);
+
+    int32_t GetClearanceZ() const;
+    void SetClearanceZ(int32_t newZ);
+
+    uint8_t GetOwner() const;
+    void SetOwner(uint8_t newOwner);
+
+    template<typename TType> const TType* as() const
+    {
+        if constexpr (std::is_same_v<TType, TileElement>)
+            return reinterpret_cast<const TileElement*>(this);
+        else
+            return static_cast<TileElementType>(GetType()) == TType::ElementType ? reinterpret_cast<const TType*>(this)
+                                                                                 : nullptr;
+    }
+
+    template<typename TType> TType* as()
+    {
+        if constexpr (std::is_same_v<TType, TileElement>)
+            return reinterpret_cast<TileElement*>(this);
+        else
+            return static_cast<TileElementType>(GetType()) == TType::ElementType ? reinterpret_cast<TType*>(this) : nullptr;
+    }
+
+    const SurfaceElement* AsSurface() const
+    {
+        return as<SurfaceElement>();
+    }
+    SurfaceElement* AsSurface()
+    {
+        return as<SurfaceElement>();
+    }
+    const PathElement* AsPath() const
+    {
+        return as<PathElement>();
+    }
+    PathElement* AsPath()
+    {
+        return as<PathElement>();
+    }
+    const TrackElement* AsTrack() const
+    {
+        return as<TrackElement>();
+    }
+    TrackElement* AsTrack()
+    {
+        return as<TrackElement>();
+    }
+    const SmallSceneryElement* AsSmallScenery() const
+    {
+        return as<SmallSceneryElement>();
+    }
+    SmallSceneryElement* AsSmallScenery()
+    {
+        return as<SmallSceneryElement>();
+    }
+    const LargeSceneryElement* AsLargeScenery() const
+    {
+        return as<LargeSceneryElement>();
+    }
+    LargeSceneryElement* AsLargeScenery()
+    {
+        return as<LargeSceneryElement>();
+    }
+    const WallElement* AsWall() const
+    {
+        return as<WallElement>();
+    }
+    WallElement* AsWall()
+    {
+        return as<WallElement>();
+    }
+    const EntranceElement* AsEntrance() const
+    {
+        return as<EntranceElement>();
+    }
+    EntranceElement* AsEntrance()
+    {
+        return as<EntranceElement>();
+    }
+    const BannerElement* AsBanner() const
+    {
+        return as<BannerElement>();
+    }
+    BannerElement* AsBanner()
+    {
+        return as<BannerElement>();
+    }
+};
+
+
+
+
+
+struct TileElement : public TileElementBase
+{
+    uint8_t pad_05[3];
+    uint8_t pad_08[8];
+
+    void ClearAs(uint8_t newType);
+
+    ride_id_t GetRideIndex() const;
+
+    void SetBannerIndex(BannerIndex newIndex);
+    void RemoveBannerEntry();
+    BannerIndex GetBannerIndex() const;
+};
+static_assert(sizeof(TileElement) == (16), "Improper struct size");
+
+struct SurfaceElement : TileElementBase
+{
+    static constexpr TileElementType ElementType = TileElementType::Surface;
+
+private:
+    uint8_t Slope;
+    uint8_t WaterHeight;
+    uint8_t GrassLength;
+    uint8_t Ownership;
+    uint8_t SurfaceStyle;
+    uint8_t EdgeStyle;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint8_t pad_0B[5];
+#pragma clang diagnostic pop
+
+public:
+    uint8_t GetSlope() const;
+    void SetSlope(uint8_t newSlope);
+
+    uint32_t GetSurfaceStyle() const;
+    TerrainSurfaceObject* GetSurfaceStyleObject() const;
+    void SetSurfaceStyle(uint32_t newStyle);
+    uint32_t GetEdgeStyle() const;
+    TerrainEdgeObject* GetEdgeStyleObject() const;
+    void SetEdgeStyle(uint32_t newStyle);
+
+    bool CanGrassGrow() const;
+    uint8_t GetGrassLength() const;
+    void SetGrassLength(uint8_t newLength);
+    void SetGrassLengthAndInvalidate(uint8_t newLength, const CoordsXY& coords);
+    void UpdateGrassLength(const CoordsXY& coords);
+
+    uint8_t GetOwnership() const;
+    void SetOwnership(uint8_t newOwnership);
+
+    int32_t GetWaterHeight() const;
+    void SetWaterHeight(int32_t newWaterHeight);
+
+    uint8_t GetParkFences() const;
+    void SetParkFences(uint8_t newParkFences);
+
+    bool HasTrackThatNeedsWater() const;
+    void SetHasTrackThatNeedsWater(bool on);
+};
+static_assert(sizeof(SurfaceElement) == (16), "Improper struct size");
+
+struct PathElement : TileElementBase
+{
+    static constexpr TileElementType ElementType = TileElementType::Path;
+
+private:
+    PathSurfaceIndex SurfaceIndex;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    PathRailingsIndex RailingsIndex;
+#pragma clang diagnostic pop
+    uint8_t Additions;
+    uint8_t EdgesAndCorners;
+    uint8_t Flags2;
+    uint8_t SlopeDirection;
+    union
+    {
+        uint8_t AdditionStatus;
+        ride_id_t rideIndex;
+    };
+    ::StationIndex StationIndex;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint8_t pad_0F[1];
+#pragma clang diagnostic pop
+
+public:
+    PathSurfaceIndex GetSurfaceEntryIndex() const;
+    PathSurfaceEntry* GetSurfaceEntry() const;
+    void SetSurfaceEntryIndex(PathSurfaceIndex newIndex);
+
+    PathRailingsIndex GetRailingEntryIndex() const;
+    PathRailingsEntry* GetRailingEntry() const;
+    void SetRailingEntryIndex(PathRailingsIndex newIndex);
+
+    uint8_t GetQueueBannerDirection() const;
+    void SetQueueBannerDirection(uint8_t direction);
+
+    bool IsSloped() const;
+    void SetSloped(bool isSloped);
+
+    Direction GetSlopeDirection() const;
+    void SetSlopeDirection(Direction newSlope);
+
+    ride_id_t GetRideIndex() const;
+    void SetRideIndex(ride_id_t newRideIndex);
+
+    ::StationIndex GetStationIndex() const;
+    void SetStationIndex(::StationIndex newStationIndex);
+
+    bool IsWide() const;
+    void SetWide(bool isWide);
+
+    bool IsQueue() const;
+    void SetIsQueue(bool isQueue);
+    bool HasQueueBanner() const;
+    void SetHasQueueBanner(bool hasQueueBanner);
+
+    bool IsBroken() const;
+    void SetIsBroken(bool isBroken);
+
+    bool IsBlockedByVehicle() const;
+    void SetIsBlockedByVehicle(bool isBlocked);
+
+    uint8_t GetEdges() const;
+    void SetEdges(uint8_t newEdges);
+    uint8_t GetCorners() const;
+    void SetCorners(uint8_t newCorners);
+    uint8_t GetEdgesAndCorners() const;
+    void SetEdgesAndCorners(uint8_t newEdgesAndCorners);
+
+    bool HasAddition() const;
+    uint8_t GetAddition() const;
+    ObjectEntryIndex GetAdditionEntryIndex() const;
+    rct_scenery_entry* GetAdditionEntry() const;
+    void SetAddition(uint8_t newAddition);
+
+    bool AdditionIsGhost() const;
+    void SetAdditionIsGhost(bool isGhost);
+
+    uint8_t GetAdditionStatus() const;
+    void SetAdditionStatus(uint8_t newStatus);
+
+    bool ShouldDrawPathOverSupports() const;
+    void SetShouldDrawPathOverSupports(bool on);
+
+    bool IsLevelCrossing(const CoordsXY& coords) const;
+};
+static_assert(sizeof(PathElement) == (16), "Improper struct size");
+
+struct TrackElement : TileElementBase
+{
+    static constexpr TileElementType ElementType = TileElementType::Track;
+
+private:
+    track_type_t TrackType;
+    union
+    {
+        struct
+        {
+            uint8_t Sequence;
+            uint8_t ColourScheme;
+            union
+            {
+
+
+
+                uint8_t OnridePhotoBits;
+
+                uint8_t BrakeBoosterSpeed;
+            };
+            uint8_t StationIndex;
+        };
+        struct
+        {
+            uint16_t MazeEntry;
+        };
+    };
+    uint8_t Flags2;
+    ride_id_t RideIndex;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint8_t pad[2];
+#pragma clang diagnostic pop
+
+public:
+    track_type_t GetTrackType() const;
+    void SetTrackType(track_type_t newEntryIndex);
+
+    uint8_t GetSequenceIndex() const;
+    void SetSequenceIndex(uint8_t newSequenceIndex);
+
+    ride_id_t GetRideIndex() const;
+    void SetRideIndex(ride_id_t newRideIndex);
+
+    uint8_t GetColourScheme() const;
+    void SetColourScheme(uint8_t newColourScheme);
+
+    uint8_t GetStationIndex() const;
+    void SetStationIndex(uint8_t newStationIndex);
+
+    bool HasChain() const;
+    void SetHasChain(bool on);
+
+    bool HasCableLift() const;
+    void SetHasCableLift(bool on);
+
+    bool IsInverted() const;
+    void SetInverted(bool inverted);
+
+    bool BlockBrakeClosed() const;
+    void SetBlockBrakeClosed(bool isClosed);
+
+    bool IsIndestructible() const;
+    void SetIsIndestructible(bool isIndestructible);
+
+    uint8_t GetBrakeBoosterSpeed() const;
+    void SetBrakeBoosterSpeed(uint8_t speed);
+
+    bool HasGreenLight() const;
+    void SetHasGreenLight(bool on);
+
+    uint8_t GetSeatRotation() const;
+    void SetSeatRotation(uint8_t newSeatRotation);
+
+    uint16_t GetMazeEntry() const;
+    void SetMazeEntry(uint16_t newMazeEntry);
+    void MazeEntryAdd(uint16_t addVal);
+    void MazeEntrySubtract(uint16_t subVal);
+
+    bool IsTakingPhoto() const;
+    void SetPhotoTimeout();
+    void SetPhotoTimeout(uint8_t newValue);
+    void DecrementPhotoTimeout();
+    uint8_t GetPhotoTimeout() const;
+
+    bool IsHighlighted() const;
+    void SetHighlight(bool on);
+
+
+
+    uint8_t GetDoorAState() const;
+    uint8_t GetDoorBState() const;
+    void SetDoorAState(uint8_t newState);
+    void SetDoorBState(uint8_t newState);
+
+    bool IsStation() const;
+    bool IsBlockStart() const;
+};
+static_assert(sizeof(TrackElement) == (16), "Improper struct size");
+
+struct SmallSceneryElement : TileElementBase
+{
+    static constexpr TileElementType ElementType = TileElementType::SmallScenery;
+
+private:
+    ObjectEntryIndex entryIndex;
+    uint8_t age;
+    uint8_t colour_1;
+    uint8_t colour_2;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint8_t pad_0A[6];
+#pragma clang diagnostic pop
+
+public:
+    ObjectEntryIndex GetEntryIndex() const;
+    void SetEntryIndex(ObjectEntryIndex newIndex);
+    rct_scenery_entry* GetEntry() const;
+    uint8_t GetAge() const;
+    void SetAge(uint8_t newAge);
+    void IncreaseAge(const CoordsXY& sceneryPos);
+    uint8_t GetSceneryQuadrant() const;
+    void SetSceneryQuadrant(uint8_t newQuadrant);
+    colour_t GetPrimaryColour() const;
+    void SetPrimaryColour(colour_t colour);
+    colour_t GetSecondaryColour() const;
+    void SetSecondaryColour(colour_t colour);
+    bool NeedsSupports() const;
+    void SetNeedsSupports();
+    void UpdateAge(const CoordsXY& sceneryPos);
+};
+static_assert(sizeof(SmallSceneryElement) == (16), "Improper struct size");
+
+struct LargeSceneryElement : TileElementBase
+{
+    static constexpr TileElementType ElementType = TileElementType::LargeScenery;
+
+private:
+    ObjectEntryIndex EntryIndex;
+    ::BannerIndex BannerIndex;
+    uint8_t SequenceIndex;
+    uint8_t Colour[3];
+    uint8_t Flags2;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint8_t pad[2];
+#pragma clang diagnostic pop
+
+public:
+    ObjectEntryIndex GetEntryIndex() const;
+    void SetEntryIndex(ObjectEntryIndex newIndex);
+    rct_scenery_entry* GetEntry() const;
+    const LargeSceneryObject* GetObject() const;
+
+    uint8_t GetSequenceIndex() const;
+    void SetSequenceIndex(uint8_t newIndex);
+
+    colour_t GetPrimaryColour() const;
+    void SetPrimaryColour(colour_t colour);
+    colour_t GetSecondaryColour() const;
+    void SetSecondaryColour(colour_t colour);
+
+    Banner* GetBanner() const;
+    ::BannerIndex GetBannerIndex() const;
+    void SetBannerIndex(::BannerIndex newIndex);
+
+    bool IsAccounted() const;
+    void SetIsAccounted(bool isAccounted);
+};
+static_assert(sizeof(LargeSceneryElement) == (16), "Improper struct size");
+
+struct WallElement : TileElementBase
+{
+    static constexpr TileElementType ElementType = TileElementType::Wall;
+
+private:
+    ObjectEntryIndex entryIndex;
+    colour_t colour_1;
+    colour_t colour_2;
+    colour_t colour_3;
+    BannerIndex banner_index;
+    uint8_t animation;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint8_t pad_0D[3];
+#pragma clang diagnostic pop
+
+public:
+    uint16_t GetEntryIndex() const;
+    void SetEntryIndex(uint16_t newIndex);
+    rct_scenery_entry* GetEntry() const;
+
+    uint8_t GetSlope() const;
+    void SetSlope(uint8_t newslope);
+
+    colour_t GetPrimaryColour() const;
+    void SetPrimaryColour(colour_t newColour);
+    colour_t GetSecondaryColour() const;
+    void SetSecondaryColour(colour_t newColour);
+    colour_t GetTertiaryColour() const;
+    void SetTertiaryColour(colour_t newColour);
+
+    uint8_t GetAnimationFrame() const;
+    void SetAnimationFrame(uint8_t frameNum);
+
+    Banner* GetBanner() const;
+    BannerIndex GetBannerIndex() const;
+    void SetBannerIndex(BannerIndex newIndex);
+
+    bool IsAcrossTrack() const;
+    void SetAcrossTrack(bool acrossTrack);
+    bool AnimationIsBackwards() const;
+    void SetAnimationIsBackwards(bool isBackwards);
+};
+static_assert(sizeof(WallElement) == (16), "Improper struct size");
+
+struct EntranceElement : TileElementBase
+{
+    static constexpr TileElementType ElementType = TileElementType::Entrance;
+
+private:
+    uint8_t entranceType;
+    uint8_t SequenceIndex;
+    uint8_t StationIndex;
+    PathSurfaceIndex PathType;
+    ride_id_t rideIndex;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint8_t pad_0C[4];
+#pragma clang diagnostic pop
+
+public:
+    uint8_t GetEntranceType() const;
+    void SetEntranceType(uint8_t newType);
+
+    ride_id_t GetRideIndex() const;
+    void SetRideIndex(ride_id_t newRideIndex);
+
+    uint8_t GetStationIndex() const;
+    void SetStationIndex(uint8_t newStationIndex);
+
+    uint8_t GetSequenceIndex() const;
+    void SetSequenceIndex(uint8_t newSequenceIndex);
+
+    PathSurfaceIndex GetPathType() const;
+    void SetPathType(PathSurfaceIndex newPathType);
+};
+static_assert(sizeof(EntranceElement) == (16), "Improper struct size");
+
+struct BannerElement : TileElementBase
+{
+    static constexpr TileElementType ElementType = TileElementType::Banner;
+
+private:
+    BannerIndex index;
+    uint8_t position;
+    uint8_t AllowedEdges;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-private-field"
+    uint8_t pad_09[7];
+#pragma clang diagnostic pop
+public:
+    Banner* GetBanner() const;
+    rct_scenery_entry* GetEntry() const;
+
+    BannerIndex GetIndex() const;
+    void SetIndex(BannerIndex newIndex);
+
+    uint8_t GetPosition() const;
+    void SetPosition(uint8_t newPosition);
+
+    uint8_t GetAllowedEdges() const;
+    void SetAllowedEdges(uint8_t newEdges);
+    void ResetAllowedEdges();
+};
+static_assert(sizeof(BannerElement) == (16), "Improper struct size");
+
+#pragma pack(pop)
+
+class QuarterTile
+{
+private:
+    uint8_t _val{ 0 };
+
+public:
+    constexpr QuarterTile(uint8_t tileQuarter, uint8_t zQuarter)
+        : _val(tileQuarter | (zQuarter << 4))
+    {
+    }
+
+    QuarterTile(uint8_t tileAndZQuarter)
+        : _val(tileAndZQuarter)
+    {
+    }
+
+
+    const QuarterTile Rotate(uint8_t amount) const;
+
+    uint8_t GetBaseQuarterOccupied() const
+    {
+        return _val & 0xF;
+    }
+
+    uint8_t GetZQuarterOccupied() const
+    {
+        return (_val >> 4) & 0xF;
+    }
+};
+
+enum
+{
+    TILE_ELEMENT_QUADRANT_SW,
+    TILE_ELEMENT_QUADRANT_NW,
+    TILE_ELEMENT_QUADRANT_NE,
+    TILE_ELEMENT_QUADRANT_SE
+};
+
+enum
+{
+    SURFACE_ELEMENT_HAS_TRACK_THAT_NEEDS_WATER = (1 << 6),
+};
+
+enum
+{
+    TILE_ELEMENT_DIRECTION_WEST,
+    TILE_ELEMENT_DIRECTION_NORTH,
+    TILE_ELEMENT_DIRECTION_EAST,
+    TILE_ELEMENT_DIRECTION_SOUTH
+};
+
+enum
+{
+    TILE_ELEMENT_FLAG_GHOST = (1 << 4),
+    TILE_ELEMENT_FLAG_INVISIBLE = (1 << 5),
+    TILE_ELEMENT_FLAG_LAST_TILE = (1 << 7)
+};
+
+enum
+{
+    ENTRANCE_TYPE_RIDE_ENTRANCE,
+    ENTRANCE_TYPE_RIDE_EXIT,
+    ENTRANCE_TYPE_PARK_ENTRANCE
+};
+
+enum
+{
+    ELEMENT_IS_ABOVE_GROUND = 1 << 0,
+    ELEMENT_IS_UNDERGROUND = 1 << 1,
+    ELEMENT_IS_UNDERWATER = 1 << 2,
+};
+
+enum
+{
+    MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT = (1 << 7),
+};
+# 704 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/TileElement.h"
+enum
+{
+    LANDSCAPE_DOOR_CLOSED = 0,
+    LANDSCAPE_DOOR_HALF_OPEN = 2,
+    LANDSCAPE_DOOR_OPEN = 3,
+};
+
+bool tile_element_is_underground(TileElement* tileElement);
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Map.h" 2
+# 29 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../world/Map.h"
+constexpr const int32_t MAXIMUM_MAP_SIZE_BIG = COORDS_XY_STEP * 256;
+constexpr const int32_t MAXIMUM_TILE_START_XY = MAXIMUM_MAP_SIZE_BIG - COORDS_XY_STEP;
+constexpr const int32_t LAND_HEIGHT_STEP = 2 * COORDS_Z_STEP;
+constexpr const int32_t MINIMUM_LAND_HEIGHT_BIG = 2 * COORDS_Z_STEP;
+
+
+
+constexpr const uint32_t MAX_TILE_ELEMENTS_WITH_SPARE_ROOM = 0x100000;
+constexpr const uint32_t MAX_TILE_ELEMENTS = MAX_TILE_ELEMENTS_WITH_SPARE_ROOM - 512;
+
+
+
+
+
+using PeepSpawn = CoordsXYZD;
+
+struct CoordsXYE : public CoordsXY
+{
+    CoordsXYE() = default;
+    constexpr CoordsXYE(int32_t _x, int32_t _y, TileElement* _e)
+        : CoordsXY(_x, _y)
+        , element(_e)
+    {
+    }
+
+    constexpr CoordsXYE(const CoordsXY& c, TileElement* _e)
+        : CoordsXY(c)
+        , element(_e)
+    {
+    }
+    TileElement* element = nullptr;
+};
+
+enum
+{
+    MAP_SELECT_FLAG_ENABLE = 1 << 0,
+    MAP_SELECT_FLAG_ENABLE_CONSTRUCT = 1 << 1,
+    MAP_SELECT_FLAG_ENABLE_ARROW = 1 << 2,
+    MAP_SELECT_FLAG_GREEN = 1 << 3,
+};
+
+enum
+{
+    MAP_SELECT_TYPE_CORNER_0,
+    MAP_SELECT_TYPE_CORNER_1,
+    MAP_SELECT_TYPE_CORNER_2,
+    MAP_SELECT_TYPE_CORNER_3,
+    MAP_SELECT_TYPE_FULL,
+    MAP_SELECT_TYPE_FULL_WATER,
+    MAP_SELECT_TYPE_QUARTER_0,
+    MAP_SELECT_TYPE_QUARTER_1,
+    MAP_SELECT_TYPE_QUARTER_2,
+    MAP_SELECT_TYPE_QUARTER_3,
+    MAP_SELECT_TYPE_EDGE_0,
+    MAP_SELECT_TYPE_EDGE_1,
+    MAP_SELECT_TYPE_EDGE_2,
+    MAP_SELECT_TYPE_EDGE_3,
+};
+
+
+
+
+enum
+{
+    CREATE_CROSSING_MODE_NONE,
+    CREATE_CROSSING_MODE_TRACK_OVER_PATH,
+    CREATE_CROSSING_MODE_PATH_OVER_TRACK,
+};
+
+extern const std::array<CoordsXY, 8> CoordsDirectionDelta;
+extern const TileCoordsXY TileDirectionDelta[];
+
+extern uint16_t gWidePathTileLoopX;
+extern uint16_t gWidePathTileLoopY;
+extern uint16_t gGrassSceneryTileLoopPosition;
+
+extern int16_t gMapSizeUnits;
+extern int16_t gMapSizeMinus2;
+extern int16_t gMapSize;
+extern int16_t gMapSizeMaxXY;
+extern int16_t gMapBaseZ;
+
+extern uint16_t gMapSelectFlags;
+extern uint16_t gMapSelectType;
+extern CoordsXY gMapSelectPositionA;
+extern CoordsXY gMapSelectPositionB;
+extern CoordsXYZ gMapSelectArrowPosition;
+extern uint8_t gMapSelectArrowDirection;
+
+extern uint8_t gMapGroundFlags;
+
+extern TileElement gTileElements[MAX_TILE_ELEMENTS_WITH_SPARE_ROOM];
+extern TileElement* gTileElementTilePointers[(256 * 256)];
+
+extern std::vector<CoordsXY> gMapSelectionTiles;
+extern std::vector<PeepSpawn> gPeepSpawns;
+
+extern TileElement* gNextFreeTileElement;
+extern uint32_t gNextFreeTileElementPointerIndex;
+
+
+extern bool gLandMountainMode;
+
+extern bool gLandPaintMode;
+
+extern bool gClearSmallScenery;
+extern bool gClearLargeScenery;
+extern bool gClearFootpath;
+
+extern uint16_t gLandRemainingOwnershipSales;
+extern uint16_t gLandRemainingConstructionSales;
+
+extern bool gMapLandRightsUpdateSuccess;
+
+constexpr auto SURFACE_STYLE_FLAG_RAISE_OR_LOWER_BASE_HEIGHT = 0x20;
+extern const uint8_t tile_element_lower_styles[9][32];
+extern const uint8_t tile_element_raise_styles[9][32];
+
+template<typename T> class TilePointerIndex
+{
+    std::vector<T*> TilePointers;
+    uint16_t MapSize;
+
+public:
+    explicit TilePointerIndex(const uint16_t mapSize, T* tileElements)
+    {
+        MapSize = mapSize;
+        const uint16_t MaxTileElementPointers = MapSize * MapSize;
+        TilePointers.reserve(MaxTileElementPointers);
+
+        T* tileElement = tileElements;
+        for (size_t y = 0; y < MapSize; y++)
+        {
+            for (size_t x = 0; x < MapSize; x++)
+            {
+                TilePointers.emplace_back(tileElement);
+                while (!(tileElement++)->IsLastForTile())
+                    ;
+            }
+        }
+    }
+
+    T* GetFirstElementAt(TileCoordsXY coords)
+    {
+        return TilePointers[coords.x + (coords.y * MapSize)];
+    }
+};
+
+void map_init(int32_t size);
+
+void map_count_remaining_land_rights();
+void map_strip_ghost_flag_from_elements();
+void map_update_tile_pointers();
+TileElement* map_get_first_element_at(const CoordsXY& elementPos);
+TileElement* map_get_nth_element_at(const CoordsXY& coords, int32_t n);
+void map_set_tile_element(const TileCoordsXY& tilePos, TileElement* elements);
+int32_t map_height_from_slope(const CoordsXY& coords, int32_t slopeDirection, bool isSloped);
+BannerElement* map_get_banner_element_at(const CoordsXYZ& bannerPos, uint8_t direction);
+SurfaceElement* map_get_surface_element_at(const CoordsXY& coords);
+PathElement* map_get_path_element_at(const TileCoordsXYZ& loc);
+WallElement* map_get_wall_element_at(const CoordsXYZD& wallCoords);
+WallElement* map_get_wall_element_at(const CoordsXYRangedZ& coords);
+SmallSceneryElement* map_get_small_scenery_element_at(const CoordsXYZ& sceneryCoords, int32_t type, uint8_t quadrant);
+EntranceElement* map_get_park_entrance_element_at(const CoordsXYZ& entranceCoords, bool ghost);
+EntranceElement* map_get_ride_entrance_element_at(const CoordsXYZ& entranceCoords, bool ghost);
+EntranceElement* map_get_ride_exit_element_at(const CoordsXYZ& exitCoords, bool ghost);
+int16_t tile_element_height(const CoordsXY& loc);
+int16_t tile_element_water_height(const CoordsXY& loc);
+uint8_t map_get_highest_land_height(const MapRange& range);
+uint8_t map_get_lowest_land_height(const MapRange& range);
+bool map_coord_is_connected(const TileCoordsXYZ& loc, uint8_t faceDirection);
+void map_remove_provisional_elements();
+void map_restore_provisional_elements();
+void map_update_path_wide_flags();
+bool map_is_location_valid(const CoordsXY& coords);
+bool map_is_edge(const CoordsXY& coords);
+bool map_can_build_at(const CoordsXYZ& loc);
+bool map_is_location_owned(const CoordsXYZ& loc);
+bool map_is_location_in_park(const CoordsXY& coords);
+bool map_is_location_owned_or_has_rights(const CoordsXY& loc);
+bool map_surface_is_blocked(const CoordsXY& mapCoords);
+void tile_element_remove(TileElement* tileElement);
+void map_remove_all_rides();
+void map_invalidate_map_selection_tiles();
+void map_invalidate_selection_rect();
+void map_reorganise_elements();
+bool map_check_free_elements_and_reorganise(int32_t num_elements);
+TileElement* tile_element_insert(const CoordsXYZ& loc, int32_t occupiedQuadrants, TileElementType type);
+
+template<typename T> T* TileElementInsert(const CoordsXYZ& loc, int32_t occupiedQuadrants)
+{
+    auto* element = tile_element_insert(loc, occupiedQuadrants, T::ElementType);
+    return (element != nullptr) ? element->template as<T>() : nullptr;
+}
+
+namespace GameActions
+{
+    class Result;
+    class ConstructClearResult;
+}
+
+using CLEAR_FUNC = int32_t (*)(TileElement** tile_element, const CoordsXY& coords, uint8_t flags, money32* price);
+
+int32_t map_place_non_scenery_clear_func(TileElement** tile_element, const CoordsXY& coords, uint8_t flags, money32* price);
+int32_t map_place_scenery_clear_func(TileElement** tile_element, const CoordsXY& coords, uint8_t flags, money32* price);
+bool map_can_construct_with_clear_at(
+    const CoordsXYRangedZ& pos, CLEAR_FUNC clearFunc, QuarterTile quarterTile, uint8_t flags, money32* price,
+    uint8_t crossingMode);
+std::unique_ptr<GameActions::ConstructClearResult> MapCanConstructWithClearAt(
+    const CoordsXYRangedZ& pos, CLEAR_FUNC clearFunc, QuarterTile quarterTile, uint8_t flags, uint8_t crossingMode);
+std::unique_ptr<GameActions::ConstructClearResult> MapCanConstructAt(const CoordsXYRangedZ& pos, QuarterTile bl);
+int32_t map_can_construct_at(const CoordsXYRangedZ& pos, QuarterTile bl);
+
+struct tile_element_iterator
+{
+    int32_t x;
+    int32_t y;
+    TileElement* element;
+};
+
+
+
+
+void tile_element_iterator_begin(tile_element_iterator* it);
+int32_t tile_element_iterator_next(tile_element_iterator* it);
+void tile_element_iterator_restart_for_tile(tile_element_iterator* it);
+
+void map_update_tiles();
+int32_t map_get_highest_z(const CoordsXY& loc);
+
+bool tile_element_wants_path_connection_towards(const TileCoordsXYZD& coords, const TileElement* const elementToBeRemoved);
+
+void map_remove_out_of_range_elements();
+void map_extend_boundary_surface();
+
+bool map_large_scenery_sign_set_colour(const CoordsXYZD& signPos, int32_t sequence, uint8_t mainColour, uint8_t textColour);
+void wall_remove_at(const CoordsXYRangedZ& wallPos);
+void wall_remove_at_z(const CoordsXYZ& wallPos);
+void wall_remove_intersecting_walls(const CoordsXYRangedZ& wallPos, Direction direction);
+
+void map_invalidate_tile(const CoordsXYRangedZ& tilePos);
+void map_invalidate_tile_zoom1(const CoordsXYRangedZ& tilePos);
+void map_invalidate_tile_zoom0(const CoordsXYRangedZ& tilePos);
+void map_invalidate_tile_full(const CoordsXY& tilePos);
+void map_invalidate_element(const CoordsXY& elementPos, TileElement* tileElement);
+void map_invalidate_region(const CoordsXY& mins, const CoordsXY& maxs);
+
+int32_t map_get_tile_side(const CoordsXY& mapPos);
+int32_t map_get_tile_quadrant(const CoordsXY& mapPos);
+int32_t map_get_corner_height(int32_t z, int32_t slope, int32_t direction);
+int32_t tile_element_get_corner_height(const SurfaceElement* surfaceElement, int32_t direction);
+
+void map_clear_all_elements();
+
+LargeSceneryElement* map_get_large_scenery_segment(const CoordsXYZD& sceneryPos, int32_t sequence);
+std::optional<CoordsXYZ> map_large_scenery_get_origin(
+    const CoordsXYZD& sceneryPos, int32_t sequence, LargeSceneryElement** outElement);
+
+ScreenCoordsXY translate_3d_to_2d_with_z(int32_t rotation, const CoordsXYZ& pos);
+
+TrackElement* map_get_track_element_at(const CoordsXYZ& trackPos);
+TileElement* map_get_track_element_at_of_type(const CoordsXYZ& trackPos, track_type_t trackType);
+TileElement* map_get_track_element_at_of_type_seq(const CoordsXYZ& trackPos, track_type_t trackType, int32_t sequence);
+TrackElement* map_get_track_element_at_of_type(const CoordsXYZD& location, track_type_t trackType);
+TrackElement* map_get_track_element_at_of_type_seq(const CoordsXYZD& location, track_type_t trackType, int32_t sequence);
+TileElement* map_get_track_element_at_of_type_from_ride(const CoordsXYZ& trackPos, track_type_t trackType, ride_id_t rideIndex);
+TileElement* map_get_track_element_at_from_ride(const CoordsXYZ& trackPos, ride_id_t rideIndex);
+TileElement* map_get_track_element_at_with_direction_from_ride(const CoordsXYZD& trackPos, ride_id_t rideIndex);
+
+bool map_is_location_at_edge(const CoordsXY& loc);
+void map_obstruction_set_error_text(TileElement* tileElement, GameActions::Result& res);
+
+uint16_t check_max_allowable_land_rights_for_tile(const CoordsXYZ& tileMapPos);
+
+void FixLandOwnershipTiles(std::initializer_list<TileCoordsXY> tiles);
+void FixLandOwnershipTilesWithOwnership(std::initializer_list<TileCoordsXY> tiles, uint8_t ownership);
+# 18 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h" 2
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/ShopItem.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/ShopItem.h"
+       
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../util/Util.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../ride/ShopItem.h" 2
+
+struct Ride;
+enum class PeepThoughtType : uint8_t;
+
+enum class ShopItem : uint8_t
+{
+    Balloon,
+    Toy,
+    Map,
+    Photo,
+    Umbrella,
+    Drink,
+    Burger,
+    Chips,
+    IceCream,
+    Candyfloss,
+    EmptyCan,
+    Rubbish,
+    EmptyBurgerBox,
+    Pizza,
+    Voucher,
+    Popcorn,
+    HotDog,
+    Tentacle,
+    Hat,
+    ToffeeApple,
+    TShirt,
+    Doughnut,
+    Coffee,
+    EmptyCup,
+    Chicken,
+    Lemonade,
+    EmptyBox,
+    EmptyBottle = 27,
+    Admission = 31,
+    Photo2 = 32,
+    Photo3,
+    Photo4,
+    Pretzel,
+    Chocolate,
+    IcedTea,
+    FunnelCake,
+    Sunglasses,
+    BeefNoodles,
+    FriedRiceNoodles,
+    WontonSoup,
+    MeatballSoup,
+    FruitJuice,
+    SoybeanMilk,
+    Sujeonggwa,
+    SubSandwich,
+    Cookie,
+    EmptyBowlRed,
+    EmptyDrinkCarton,
+    EmptyJuiceCup,
+    RoastSausage,
+    EmptyBowlBlue,
+    Count = 56,
+    None = 255
+};
+
+ShopItem& operator++(ShopItem& d, int);
+
+using ShopItemIndex = ShopItem;
+
+struct ShopItemStrings
+{
+    rct_string_id PriceLabel;
+    rct_string_id Singular;
+    rct_string_id Plural;
+    rct_string_id Indefinite;
+    rct_string_id Display;
+};
+
+struct ShopItemDescriptor
+{
+    uint16_t Cost;
+    uint16_t BaseValue;
+    uint16_t HotValue;
+    uint16_t ColdValue;
+    money8 DefaultPrice;
+    uint32_t Image;
+    ShopItemStrings Naming;
+    uint16_t Flags;
+    uint8_t LitterType;
+    uint8_t ConsumptionTime;
+    ShopItem DiscardContainer;
+    PeepThoughtType TooMuchThought;
+    PeepThoughtType GoodValueThought;
+
+    constexpr bool HasFlag(const uint16_t flag) const
+    {
+        return (Flags & flag) != 0;
+    }
+    bool IsFood() const;
+    bool IsDrink() const;
+    bool IsFoodOrDrink() const;
+    bool IsSouvenir() const;
+    bool IsPhoto() const;
+};
+
+uint64_t ShopItemsGetAllFoods();
+uint64_t ShopItemsGetAllDrinks();
+uint64_t ShopItemsGetAllContainers();
+
+enum
+{
+    SHOP_ITEM_FLAG_IS_FOOD = (1 << 0),
+    SHOP_ITEM_FLAG_IS_DRINK = (1 << 1),
+    SHOP_ITEM_FLAG_IS_SOUVENIR = (1 << 2),
+    SHOP_ITEM_FLAG_IS_PHOTO = (1 << 3),
+    SHOP_ITEM_FLAG_IS_CONTAINER = (1 << 4),
+};
+
+extern uint64_t gSamePriceThroughoutPark;
+
+money32 shop_item_get_common_price(Ride* forRide, const ShopItem shopItem);
+bool shop_item_has_common_price(const ShopItem shopItem);
+
+const ShopItemDescriptor& GetShopItemDescriptor(ShopItem item);
+# 21 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/VehicleEntry.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/VehicleEntry.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/AudioMixer.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/AudioMixer.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/AudioMixer.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/IStream.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/IStream.hpp"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/IStream.hpp" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Memory.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Memory.hpp"
+       
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/10.2.0/include/stdbool.h" 1 3 4
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 2
+
+
+void openrct2_assert_fwd(bool expression, const char* message, ...);
+
+
+
+
+
+
+
+enum class ASSERT_BEHAVIOUR
+{
+    ABORT,
+    CASSERT,
+    MESSAGE_BOX,
+};
+
+
+
+
+namespace Guard
+{
+    ASSERT_BEHAVIOUR GetAssertBehaviour();
+    void SetAssertBehaviour(ASSERT_BEHAVIOUR behaviour);
+
+    void Assert(bool expression, const char* message = nullptr, ...);
+    void Assert_VA(bool expression, const char* message, va_list args);
+    void Fail(const char* message = nullptr, ...);
+    void Fail_VA(const char* message, va_list args);
+
+    std::optional<std::string> GetLastAssertMessage();
+
+    template<typename T> static void ArgumentNotNull(T* argument, const char* message = nullptr, ...)
+    {
+        va_list args;
+        
+# 51 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       __builtin_va_start(
+# 51 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       args
+# 51 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       ,
+# 51 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       message
+# 51 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       )
+# 51 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+                              ;
+        Assert_VA(argument != nullptr, message, args);
+        
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       __builtin_va_end(
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       args
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       )
+# 53 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+                   ;
+    }
+
+    template<typename T> static void ArgumentNotNull(const std::shared_ptr<T>& argument, const char* message = nullptr, ...)
+    {
+        va_list args;
+        
+# 59 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       __builtin_va_start(
+# 59 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       args
+# 59 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       ,
+# 59 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       message
+# 59 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       )
+# 59 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+                              ;
+        Assert_VA(argument != nullptr, message, args);
+        
+# 61 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       __builtin_va_end(
+# 61 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       args
+# 61 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       )
+# 61 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+                   ;
+    }
+
+    template<typename T> static void ArgumentInRange(T argument, T min, T max, const char* message = nullptr, ...)
+    {
+        va_list args;
+        
+# 67 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       __builtin_va_start(
+# 67 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       args
+# 67 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       ,
+# 67 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       message
+# 67 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       )
+# 67 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+                              ;
+        Assert(argument >= min && argument <= max, message, args);
+        
+# 69 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       __builtin_va_end(
+# 69 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+       args
+# 69 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp" 3 4
+       )
+# 69 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Guard.hpp"
+                   ;
+    }
+
+    template<typename T> static void IndexInRange(size_t index, const T& container)
+    {
+        Guard::Assert(index < container.size(), "Index %zu out of bounds (%zu)", index, container.size());
+    }
+
+}
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Memory.hpp" 2
+
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Memory.hpp" 2
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3
+# 39 "/usr/include/c++/10.2.0/cstring" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/Memory.hpp" 2
+
+
+
+
+
+namespace Memory
+{
+    template<typename T> static T* Allocate()
+    {
+        T* result = static_cast<T*>(malloc(sizeof(T)));
+        Guard::ArgumentNotNull(result, "Failed to allocate %zu bytes for %s", sizeof(T), typeid(T).name());
+        return result;
+    }
+
+    template<typename T> static T* Allocate(size_t size)
+    {
+        T* result = static_cast<T*>(malloc(size));
+        Guard::ArgumentNotNull(result, "Failed to allocate %zu bytes for %s", size, typeid(T).name());
+        return result;
+    }
+
+    template<typename T> static T* AllocateArray(size_t count)
+    {
+        T* result = static_cast<T*>(malloc(count * sizeof(T)));
+        Guard::ArgumentNotNull(result, "Failed to allocate array of %zu * %s (%zu bytes)", count, typeid(T).name(), sizeof(T));
+        return result;
+    }
+
+    template<typename T> static T* Reallocate(T* ptr, size_t size)
+    {
+        T* result;
+        if (ptr == nullptr)
+        {
+            result = static_cast<T*>(malloc(size));
+        }
+        else
+        {
+            result = static_cast<T*>(realloc(reinterpret_cast<void*>(ptr), size));
+        }
+        Guard::ArgumentNotNull(result, "Failed to reallocate %x (%s) to have %zu bytes", ptr, typeid(T).name(), size);
+        return result;
+    }
+
+    template<typename T> static T* ReallocateArray(T* ptr, size_t count)
+    {
+        T* result;
+        if (ptr == nullptr)
+        {
+            result = static_cast<T*>(malloc(count * sizeof(T)));
+        }
+        else
+        {
+            result = static_cast<T*>(realloc(reinterpret_cast<void*>(ptr), count * sizeof(T)));
+        }
+        Guard::ArgumentNotNull(
+            result, "Failed to reallocate array at %x (%s) to have %zu entries", ptr, typeid(T).name(), count);
+        return result;
+    }
+
+    template<typename T> static void Free(T* ptr)
+    {
+        free(const_cast<void*>(reinterpret_cast<const void*>(ptr)));
+    }
+
+    template<typename T> static void FreeArray(T* ptr, size_t count)
+    {
+        for (size_t i = 0; i < count; i++)
+        {
+            ptr[i].~T();
+        }
+        Free(ptr);
+    }
+}
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/IStream.hpp" 2
+
+# 1 "/usr/include/c++/10.2.0/istream" 1 3
+# 36 "/usr/include/c++/10.2.0/istream" 3
+       
+# 37 "/usr/include/c++/10.2.0/istream" 3
+
+# 1 "/usr/include/c++/10.2.0/ios" 1 3
+# 36 "/usr/include/c++/10.2.0/ios" 3
+       
+# 37 "/usr/include/c++/10.2.0/ios" 3
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/ios_base.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_classes.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+
+
+
+
+
+
+# 43 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 62 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+  class locale
+  {
+  public:
+
+
+    typedef int category;
+
+
+    class facet;
+    class id;
+    class _Impl;
+
+    friend class facet;
+    friend class _Impl;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+# 98 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    static const category none = 0;
+    static const category ctype = 1L << 0;
+    static const category numeric = 1L << 1;
+    static const category collate = 1L << 2;
+    static const category time = 1L << 3;
+    static const category monetary = 1L << 4;
+    static const category messages = 1L << 5;
+    static const category all = (ctype | numeric | collate |
+        time | monetary | messages);
+# 117 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale() throw();
+# 126 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale(const locale& __other) throw();
+# 136 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    explicit
+    locale(const char* __s);
+# 151 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale(const locale& __base, const char* __s, category __cat);
+# 162 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    explicit
+    locale(const std::string& __s) : locale(__s.c_str()) { }
+# 177 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale(const locale& __base, const std::string& __s, category __cat)
+    : locale(__base, __s.c_str(), __cat) { }
+# 192 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    locale(const locale& __base, const locale& __add, category __cat);
+# 205 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale(const locale& __other, _Facet* __f);
+
+
+    ~locale() throw();
+# 219 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    const locale&
+    operator=(const locale& __other) throw();
+# 234 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale
+      combine(const locale& __other) const;
+
+
+
+
+
+
+    __attribute ((__abi_tag__ ("cxx11")))
+    string
+    name() const;
+# 254 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    bool
+    operator==(const locale& __other) const throw();
+# 264 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    bool
+    operator!=(const locale& __other) const throw()
+    { return !(this->operator==(__other)); }
+# 284 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    template<typename _Char, typename _Traits, typename _Alloc>
+      bool
+      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
+   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
+# 300 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    static locale
+    global(const locale& __loc);
+
+
+
+
+    static const locale&
+    classic();
+
+  private:
+
+    _Impl* _M_impl;
+
+
+    static _Impl* _S_classic;
+
+
+    static _Impl* _S_global;
+
+
+
+
+
+    static const char* const* const _S_categories;
+# 335 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    enum { _S_categories_size = 6 + 6 };
+
+
+    static __gthread_once_t _S_once;
+
+
+    explicit
+    locale(_Impl*) throw();
+
+    static void
+    _S_initialize();
+
+    static void
+    _S_initialize_once() throw();
+
+    static category
+    _S_normalize_category(category);
+
+    void
+    _M_coalesce(const locale& __base, const locale& __add, category __cat);
+
+
+    static const id* const _S_twinned_facets[];
+
+  };
+# 373 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+  class locale::facet
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    mutable _Atomic_word _M_refcount;
+
+
+    static __c_locale _S_c_locale;
+
+
+    static const char _S_c_name[2];
+
+
+    static __gthread_once_t _S_once;
+
+
+    static void
+    _S_initialize_once();
+
+  protected:
+# 404 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    explicit
+    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
+    { }
+
+
+    virtual
+    ~facet();
+
+    static void
+    _S_create_c_locale(__c_locale& __cloc, const char* __s,
+         __c_locale __old = 0);
+
+    static __c_locale
+    _S_clone_c_locale(__c_locale& __cloc) throw();
+
+    static void
+    _S_destroy_c_locale(__c_locale& __cloc);
+
+    static __c_locale
+    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
+
+
+
+    static __c_locale
+    _S_get_c_locale();
+
+    __attribute__ ((__const__)) static const char*
+    _S_get_c_name() throw();
+# 440 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+    facet(const facet&) = delete;
+
+    facet&
+    operator=(const facet&) = delete;
+
+
+  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(...)
+     { }
+ }
+    }
+
+    const facet* _M_sso_shim(const id*) const;
+    const facet* _M_cow_shim(const id*) const;
+
+  protected:
+    class __shim;
+  };
+# 485 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+  class locale::id
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+
+
+
+    mutable size_t _M_index;
+
+
+    static _Atomic_word _S_refcount;
+
+    void
+    operator=(const id&);
+
+    id(const id&);
+
+  public:
+
+
+
+    id() { }
+
+    size_t
+    _M_id() const throw();
+  };
+
+
+
+  class locale::_Impl
+  {
+  public:
+
+    friend class locale;
+    friend class locale::facet;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+
+  private:
+
+    _Atomic_word _M_refcount;
+    const facet** _M_facets;
+    size_t _M_facets_size;
+    const facet** _M_caches;
+    char** _M_names;
+    static const locale::id* const _S_id_ctype[];
+    static const locale::id* const _S_id_numeric[];
+    static const locale::id* const _S_id_collate[];
+    static const locale::id* const _S_id_time[];
+    static const locale::id* const _S_id_monetary[];
+    static const locale::id* const _S_id_messages[];
+    static const locale::id* const* const _S_facet_categories[];
+
+    void
+    _M_add_reference() throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() throw()
+    {
+
+      ;
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+          ;
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+
+    _Impl(const _Impl&, size_t);
+    _Impl(const char*, size_t);
+    _Impl(size_t) throw();
+
+   ~_Impl() throw();
+
+    _Impl(const _Impl&);
+
+    void
+    operator=(const _Impl&);
+
+    bool
+    _M_check_same_name()
+    {
+      bool __ret = true;
+      if (_M_names[1])
+
+ for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
+   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
+      return __ret;
+    }
+
+    void
+    _M_replace_categories(const _Impl*, category);
+
+    void
+    _M_replace_category(const _Impl*, const locale::id* const*);
+
+    void
+    _M_replace_facet(const _Impl*, const locale::id*);
+
+    void
+    _M_install_facet(const locale::id*, const facet*);
+
+    template<typename _Facet>
+      void
+      _M_init_facet(_Facet* __facet)
+      { _M_install_facet(&_Facet::id, __facet); }
+
+    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*);
+  };
+# 643 "/usr/include/c++/10.2.0/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;
+# 670 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      explicit
+      collate(size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
+      { }
+# 684 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      explicit
+      collate(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
+      { }
+# 701 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      int
+      compare(const _CharT* __lo1, const _CharT* __hi1,
+       const _CharT* __lo2, const _CharT* __hi2) const
+      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
+# 720 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      string_type
+      transform(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_transform(__lo, __hi); }
+# 734 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      long
+      hash(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_hash(__lo, __hi); }
+
+
+      int
+      _M_compare(const _CharT*, const _CharT*) const throw();
+
+      size_t
+      _M_transform(_CharT*, const _CharT*, size_t) const throw();
+
+  protected:
+
+      virtual
+      ~collate()
+      { _S_destroy_c_locale(_M_c_locale_collate); }
+# 763 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      virtual int
+      do_compare(const _CharT* __lo1, const _CharT* __hi1,
+   const _CharT* __lo2, const _CharT* __hi2) const;
+# 777 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      virtual string_type
+      do_transform(const _CharT* __lo, const _CharT* __hi) const;
+# 790 "/usr/include/c++/10.2.0/bits/locale_classes.h" 3
+      virtual long
+      do_hash(const _CharT* __lo, const _CharT* __hi) const;
+    };
+
+  template<typename _CharT>
+    locale::id collate<_CharT>::id;
+
+
+  template<>
+    int
+    collate<char>::_M_compare(const char*, const char*) const throw();
+
+  template<>
+    size_t
+    collate<char>::_M_transform(char*, const char*, size_t) const throw();
+
+
+  template<>
+    int
+    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
+
+  template<>
+    size_t
+    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
+
+
+
+  template<typename _CharT>
+    class __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 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Facet>
+    locale::
+    locale(const locale& __other, _Facet* __f)
+    {
+      _M_impl = new _Impl(*__other._M_impl, 1);
+
+      try
+ { _M_impl->_M_install_facet(&_Facet::id, __f); }
+      catch(...)
+ {
+   _M_impl->_M_remove_reference();
+   throw;
+ }
+      delete [] _M_impl->_M_names[0];
+      _M_impl->_M_names[0] = 0;
+    }
+
+  template<typename _Facet>
+    locale
+    locale::
+    combine(const locale& __other) const
+    {
+      _Impl* __tmp = new _Impl(*_M_impl, 1);
+      try
+ {
+   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
+ }
+      catch(...)
+ {
+   __tmp->_M_remove_reference();
+   throw;
+ }
+      return locale(__tmp);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    bool
+    locale::
+    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
+        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
+    {
+      typedef std::collate<_CharT> __collate_type;
+      const __collate_type& __collate = use_facet<__collate_type>(*this);
+      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
+    __s2.data(), __s2.data() + __s2.length()) < 0);
+    }
+# 102 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 3
+  template<typename _Facet>
+    bool
+    has_facet(const locale& __loc) throw()
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      return (__i < __loc._M_impl->_M_facets_size
+
+       && dynamic_cast<const _Facet*>(__facets[__i]));
+
+
+
+    }
+# 130 "/usr/include/c++/10.2.0/bits/locale_classes.tcc" 3
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale& __loc)
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
+        __throw_bad_cast();
+
+      return dynamic_cast<const _Facet&>(*__facets[__i]);
+
+
+
+    }
+
+
+
+  template<typename _CharT>
+    int
+    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
+    { return 0; }
+
+
+  template<typename _CharT>
+    size_t
+    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
+    { return 0; }
+
+  template<typename _CharT>
+    int
+    collate<_CharT>::
+    do_compare(const _CharT* __lo1, const _CharT* __hi1,
+        const _CharT* __lo2, const _CharT* __hi2) const
+    {
+
+
+      const string_type __one(__lo1, __hi1);
+      const string_type __two(__lo2, __hi2);
+
+      const _CharT* __p = __one.c_str();
+      const _CharT* __pend = __one.data() + __one.length();
+      const _CharT* __q = __two.c_str();
+      const _CharT* __qend = __two.data() + __two.length();
+
+
+
+
+      for (;;)
+ {
+   const int __res = _M_compare(__p, __q);
+   if (__res)
+     return __res;
+
+   __p += char_traits<_CharT>::length(__p);
+   __q += char_traits<_CharT>::length(__q);
+   if (__p == __pend && __q == __qend)
+     return 0;
+   else if (__p == __pend)
+     return -1;
+   else if (__q == __qend)
+     return 1;
+
+   __p++;
+   __q++;
+ }
+    }
+
+  template<typename _CharT>
+    typename collate<_CharT>::string_type
+    collate<_CharT>::
+    do_transform(const _CharT* __lo, const _CharT* __hi) const
+    {
+      string_type __ret;
+
+
+      const string_type __str(__lo, __hi);
+
+      const _CharT* __p = __str.c_str();
+      const _CharT* __pend = __str.data() + __str.length();
+
+      size_t __len = (__hi - __lo) * 2;
+
+      _CharT* __c = new _CharT[__len];
+
+      try
+ {
+
+
+
+   for (;;)
+     {
+
+       size_t __res = _M_transform(__c, __p, __len);
+
+
+       if (__res >= __len)
+  {
+    __len = __res + 1;
+    delete [] __c, __c = 0;
+    __c = new _CharT[__len];
+    __res = _M_transform(__c, __p, __len);
+  }
+
+       __ret.append(__c, __res);
+       __p += char_traits<_CharT>::length(__p);
+       if (__p == __pend)
+  break;
+
+       __p++;
+       __ret.push_back(_CharT());
+     }
+ }
+      catch(...)
+ {
+   delete [] __c;
+   throw;
+ }
+
+      delete [] __c;
+
+      return __ret;
+    }
+
+  template<typename _CharT>
+    long
+    collate<_CharT>::
+    do_hash(const _CharT* __lo, const _CharT* __hi) const
+    {
+      unsigned long __val = 0;
+      for (; __lo < __hi; ++__lo)
+ __val =
+   *__lo + ((__val << 7)
+     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
+    __digits - 7)));
+      return static_cast<long>(__val);
+    }
+
+
+
+
+  extern template class collate<char>;
+  extern template class collate_byname<char>;
+
+  extern template
+    const collate<char>&
+    use_facet<collate<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<char> >(const locale&);
+
+
+  extern template class collate<wchar_t>;
+  extern template class collate_byname<wchar_t>;
+
+  extern template
+    const collate<wchar_t>&
+    use_facet<collate<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<wchar_t> >(const locale&);
+
+
+
+
+}
+# 854 "/usr/include/c++/10.2.0/bits/locale_classes.h" 2 3
+# 42 "/usr/include/c++/10.2.0/bits/ios_base.h" 2 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/system_error" 1 3
+# 32 "/usr/include/c++/10.2.0/system_error" 3
+       
+# 33 "/usr/include/c++/10.2.0/system_error" 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 1 3
+# 34 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/error_constants.h" 3
+# 1 "/usr/include/c++/10.2.0/cerrno" 1 3
+# 39 "/usr/include/c++/10.2.0/cerrno" 3
+       
+# 40 "/usr/include/c++/10.2.0/cerrno" 3
+# 35 "/usr/include/c++/10.2.0/x86_64-pc-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 "/usr/include/c++/10.2.0/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 { };
+# 78 "/usr/include/c++/10.2.0/system_error" 3
+  inline namespace _V2 {
+# 89 "/usr/include/c++/10.2.0/system_error" 3
+  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;
+# 125 "/usr/include/c++/10.2.0/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 this == &__other; }
+
+
+
+
+
+
+    bool
+    operator!=(const error_category& __other) const noexcept
+    { return this != &__other; }
+
+    bool
+    operator<(const error_category& __other) const noexcept
+    { return less<const error_category*>()(this, &__other); }
+
+  };
+
+
+
+
+  __attribute__ ((__const__)) const error_category& generic_category() noexcept;
+
+
+  __attribute__ ((__const__)) const error_category& system_category() noexcept;
+
+  }
+
+  error_code make_error_code(errc) noexcept;
+# 180 "/usr/include/c++/10.2.0/system_error" 3
+  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; }
+
+
+  private:
+    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()); }
+# 251 "/usr/include/c++/10.2.0/system_error" 3
+  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;
+# 278 "/usr/include/c++/10.2.0/system_error" 3
+  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; }
+
+
+  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_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_condition& __rhs) noexcept
+  {
+    return (__lhs.category() == __rhs.category()
+     && __lhs.value() == __rhs.value());
+  }
+# 378 "/usr/include/c++/10.2.0/system_error" 3
+  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_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_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); }
+# 428 "/usr/include/c++/10.2.0/system_error" 3
+  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) { }
+
+
+    system_error (const system_error &) = default;
+    system_error &operator= (const system_error &) = default;
+
+
+    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.value());
+ return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
+      }
+    };
+# 508 "/usr/include/c++/10.2.0/system_error" 3
+
+}
+# 47 "/usr/include/c++/10.2.0/bits/ios_base.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+  enum _Ios_Fmtflags
+    {
+      _S_boolalpha = 1L << 0,
+      _S_dec = 1L << 1,
+      _S_fixed = 1L << 2,
+      _S_hex = 1L << 3,
+      _S_internal = 1L << 4,
+      _S_left = 1L << 5,
+      _S_oct = 1L << 6,
+      _S_right = 1L << 7,
+      _S_scientific = 1L << 8,
+      _S_showbase = 1L << 9,
+      _S_showpoint = 1L << 10,
+      _S_showpos = 1L << 11,
+      _S_skipws = 1L << 12,
+      _S_unitbuf = 1L << 13,
+      _S_uppercase = 1L << 14,
+      _S_adjustfield = _S_left | _S_right | _S_internal,
+      _S_basefield = _S_dec | _S_oct | _S_hex,
+      _S_floatfield = _S_scientific | _S_fixed,
+      _S_ios_fmtflags_end = 1L << 16,
+      _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 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+  class ios_base
+  {
+# 246 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+  public:
+# 255 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef _Ios_Fmtflags fmtflags;
+
+
+    static const fmtflags boolalpha = _S_boolalpha;
+
+
+    static const fmtflags dec = _S_dec;
+
+
+    static const fmtflags fixed = _S_fixed;
+
+
+    static const fmtflags hex = _S_hex;
+
+
+
+
+    static const fmtflags internal = _S_internal;
+
+
+
+    static const fmtflags left = _S_left;
+
+
+    static const fmtflags oct = _S_oct;
+
+
+
+    static const fmtflags right = _S_right;
+
+
+    static const fmtflags scientific = _S_scientific;
+
+
+
+    static const fmtflags showbase = _S_showbase;
+
+
+
+    static const fmtflags showpoint = _S_showpoint;
+
+
+    static const fmtflags showpos = _S_showpos;
+
+
+    static const fmtflags skipws = _S_skipws;
+
+
+    static const fmtflags unitbuf = _S_unitbuf;
+
+
+
+    static const fmtflags uppercase = _S_uppercase;
+
+
+    static const fmtflags adjustfield = _S_adjustfield;
+
+
+    static const fmtflags basefield = _S_basefield;
+
+
+    static const fmtflags floatfield = _S_floatfield;
+# 398 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef _Ios_Iostate iostate;
+
+
+
+    static const iostate badbit = _S_badbit;
+
+
+    static const iostate eofbit = _S_eofbit;
+
+
+
+
+    static const iostate failbit = _S_failbit;
+
+
+    static const iostate goodbit = _S_goodbit;
+# 429 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef _Ios_Openmode openmode;
+
+
+    static const openmode app = _S_app;
+
+
+    static const openmode ate = _S_ate;
+
+
+
+
+    static const openmode binary = _S_bin;
+
+
+    static const openmode in = _S_in;
+
+
+    static const openmode out = _S_out;
+
+
+    static const openmode trunc = _S_trunc;
+# 461 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef _Ios_Seekdir seekdir;
+
+
+    static const seekdir beg = _S_beg;
+
+
+    static const seekdir cur = _S_cur;
+
+
+    static const seekdir end = _S_end;
+
+
+
+    typedef int io_state;
+    typedef int open_mode;
+    typedef int seek_dir;
+
+    typedef std::streampos streampos;
+    typedef std::streamoff streamoff;
+# 489 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    enum event
+    {
+      erase_event,
+      imbue_event,
+      copyfmt_event
+    };
+# 506 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
+# 518 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    void
+    register_callback(event_callback __fn, int __index);
+
+  protected:
+    streamsize _M_precision;
+    streamsize _M_width;
+    fmtflags _M_flags;
+    iostate _M_exception;
+    iostate _M_streambuf_state;
+
+
+
+    struct _Callback_list
+    {
+
+      _Callback_list* _M_next;
+      ios_base::event_callback _M_fn;
+      int _M_index;
+      _Atomic_word _M_refcount;
+
+      _Callback_list(ios_base::event_callback __fn, int __index,
+       _Callback_list* __cb)
+      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
+
+      void
+      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+
+      int
+      _M_remove_reference()
+      {
+
+        ;
+        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
+        if (__res == 0)
+          {
+            ;
+          }
+        return __res;
+      }
+    };
+
+     _Callback_list* _M_callbacks;
+
+    void
+    _M_call_callbacks(event __ev) throw();
+
+    void
+    _M_dispose_callbacks(void) throw();
+
+
+    struct _Words
+    {
+      void* _M_pword;
+      long _M_iword;
+      _Words() : _M_pword(0), _M_iword(0) { }
+    };
+
+
+    _Words _M_word_zero;
+
+
+
+    enum { _S_local_word_size = 8 };
+    _Words _M_local_word[_S_local_word_size];
+
+
+    int _M_word_size;
+    _Words* _M_word;
+
+    _Words&
+    _M_grow_words(int __index, bool __iword);
+
+
+    locale _M_ios_locale;
+
+    void
+    _M_init() throw();
+
+  public:
+
+
+
+
+
+    class Init
+    {
+      friend class ios_base;
+    public:
+      Init();
+      ~Init();
+
+
+      Init(const Init&) = default;
+      Init& operator=(const Init&) = default;
+
+
+    private:
+      static _Atomic_word _S_refcount;
+      static bool _S_synced_with_stdio;
+    };
+
+
+
+
+
+
+    fmtflags
+    flags() const
+    { return _M_flags; }
+# 636 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    fmtflags
+    flags(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags = __fmtfl;
+      return __old;
+    }
+# 652 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags |= __fmtfl;
+      return __old;
+    }
+# 669 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl, fmtflags __mask)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags &= ~__mask;
+      _M_flags |= (__fmtfl & __mask);
+      return __old;
+    }
+
+
+
+
+
+
+
+    void
+    unsetf(fmtflags __mask)
+    { _M_flags &= ~__mask; }
+# 695 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    streamsize
+    precision() const
+    { return _M_precision; }
+
+
+
+
+
+
+    streamsize
+    precision(streamsize __prec)
+    {
+      streamsize __old = _M_precision;
+      _M_precision = __prec;
+      return __old;
+    }
+
+
+
+
+
+
+
+    streamsize
+    width() const
+    { return _M_width; }
+
+
+
+
+
+
+    streamsize
+    width(streamsize __wide)
+    {
+      streamsize __old = _M_width;
+      _M_width = __wide;
+      return __old;
+    }
+# 746 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    static bool
+    sync_with_stdio(bool __sync = true);
+# 758 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    locale
+    imbue(const locale& __loc) throw();
+# 769 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    locale
+    getloc() const
+    { return _M_ios_locale; }
+# 780 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    const locale&
+    _M_getloc() const
+    { return _M_ios_locale; }
+# 799 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    static int
+    xalloc() throw();
+# 815 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    long&
+    iword(int __ix)
+    {
+      _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, true);
+      return __word._M_iword;
+    }
+# 836 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    void*&
+    pword(int __ix)
+    {
+      _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, false);
+      return __word._M_pword;
+    }
+# 853 "/usr/include/c++/10.2.0/bits/ios_base.h" 3
+    virtual ~ios_base();
+
+  protected:
+    ios_base() throw ();
+# 867 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/ios" 2 3
+# 1 "/usr/include/c++/10.2.0/streambuf" 1 3
+# 36 "/usr/include/c++/10.2.0/streambuf" 3
+       
+# 37 "/usr/include/c++/10.2.0/streambuf" 3
+# 45 "/usr/include/c++/10.2.0/streambuf" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
+     basic_streambuf<_CharT, _Traits>*, bool&);
+# 121 "/usr/include/c++/10.2.0/streambuf" 3
+  template<typename _CharT, typename _Traits>
+    class basic_streambuf
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+
+
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+
+
+      friend class basic_ios<char_type, traits_type>;
+      friend class basic_istream<char_type, traits_type>;
+      friend class basic_ostream<char_type, traits_type>;
+      friend class istreambuf_iterator<char_type, traits_type>;
+      friend class ostreambuf_iterator<char_type, traits_type>;
+
+      friend streamsize
+      __copy_streambufs_eof<>(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 _Distance>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            void>::__type
+        advance(istreambuf_iterator<_CharT2>&, _Distance);
+
+      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()
+      { }
+# 215 "/usr/include/c++/10.2.0/streambuf" 3
+      locale
+      pubimbue(const locale& __loc)
+      {
+ locale __tmp(this->getloc());
+ this->imbue(__loc);
+ _M_buf_locale = __loc;
+ return __tmp;
+      }
+# 232 "/usr/include/c++/10.2.0/streambuf" 3
+      locale
+      getloc() const
+      { return _M_buf_locale; }
+# 245 "/usr/include/c++/10.2.0/streambuf" 3
+      basic_streambuf*
+      pubsetbuf(char_type* __s, streamsize __n)
+      { return this->setbuf(__s, __n); }
+# 257 "/usr/include/c++/10.2.0/streambuf" 3
+      pos_type
+      pubseekoff(off_type __off, ios_base::seekdir __way,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekoff(__off, __way, __mode); }
+# 269 "/usr/include/c++/10.2.0/streambuf" 3
+      pos_type
+      pubseekpos(pos_type __sp,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekpos(__sp, __mode); }
+
+
+
+
+      int
+      pubsync() { return this->sync(); }
+# 290 "/usr/include/c++/10.2.0/streambuf" 3
+      streamsize
+      in_avail()
+      {
+ const streamsize __ret = this->egptr() - this->gptr();
+ return __ret ? __ret : this->showmanyc();
+      }
+# 304 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      snextc()
+      {
+ int_type __ret = traits_type::eof();
+ if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
+             __ret), true))
+   __ret = this->sgetc();
+ return __ret;
+      }
+# 322 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sbumpc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ else
+   __ret = this->uflow();
+ return __ret;
+      }
+# 344 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sgetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   __ret = traits_type::to_int_type(*this->gptr());
+ else
+   __ret = this->underflow();
+ return __ret;
+      }
+# 363 "/usr/include/c++/10.2.0/streambuf" 3
+      streamsize
+      sgetn(char_type* __s, streamsize __n)
+      { return this->xsgetn(__s, __n); }
+# 378 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sputbackc(char_type __c)
+      {
+ int_type __ret;
+ const bool __testpos = this->eback() < this->gptr();
+ if (__builtin_expect(!__testpos ||
+        !traits_type::eq(__c, this->gptr()[-1]), false))
+   __ret = this->pbackfail(traits_type::to_int_type(__c));
+ else
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ return __ret;
+      }
+# 403 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sungetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->eback() < this->gptr(), true))
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ else
+   __ret = this->pbackfail();
+ return __ret;
+      }
+# 430 "/usr/include/c++/10.2.0/streambuf" 3
+      int_type
+      sputc(char_type __c)
+      {
+ int_type __ret;
+ if (__builtin_expect(this->pptr() < this->epptr(), true))
+   {
+     *this->pptr() = __c;
+     this->pbump(1);
+     __ret = traits_type::to_int_type(__c);
+   }
+ else
+   __ret = this->overflow(traits_type::to_int_type(__c));
+ return __ret;
+      }
+# 456 "/usr/include/c++/10.2.0/streambuf" 3
+      streamsize
+      sputn(const char_type* __s, streamsize __n)
+      { return this->xsputn(__s, __n); }
+
+    protected:
+# 470 "/usr/include/c++/10.2.0/streambuf" 3
+      basic_streambuf()
+      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
+      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
+      _M_buf_locale(locale())
+      { }
+# 488 "/usr/include/c++/10.2.0/streambuf" 3
+      char_type*
+      eback() const { return _M_in_beg; }
+
+      char_type*
+      gptr() const { return _M_in_cur; }
+
+      char_type*
+      egptr() const { return _M_in_end; }
+# 504 "/usr/include/c++/10.2.0/streambuf" 3
+      void
+      gbump(int __n) { _M_in_cur += __n; }
+# 515 "/usr/include/c++/10.2.0/streambuf" 3
+      void
+      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
+      {
+ _M_in_beg = __gbeg;
+ _M_in_cur = __gnext;
+ _M_in_end = __gend;
+      }
+# 535 "/usr/include/c++/10.2.0/streambuf" 3
+      char_type*
+      pbase() const { return _M_out_beg; }
+
+      char_type*
+      pptr() const { return _M_out_cur; }
+
+      char_type*
+      epptr() const { return _M_out_end; }
+# 551 "/usr/include/c++/10.2.0/streambuf" 3
+      void
+      pbump(int __n) { _M_out_cur += __n; }
+# 561 "/usr/include/c++/10.2.0/streambuf" 3
+      void
+      setp(char_type* __pbeg, char_type* __pend)
+      {
+ _M_out_beg = _M_out_cur = __pbeg;
+ _M_out_end = __pend;
+      }
+# 582 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual void
+      imbue(const locale& __loc __attribute__ ((__unused__)))
+      { }
+# 597 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual basic_streambuf<char_type,_Traits>*
+      setbuf(char_type*, streamsize)
+      { return this; }
+# 608 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual pos_type
+      seekoff(off_type, ios_base::seekdir,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 620 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual pos_type
+      seekpos(pos_type,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 633 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int
+      sync() { return 0; }
+# 655 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual streamsize
+      showmanyc() { return 0; }
+# 671 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+# 693 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int_type
+      underflow()
+      { return traits_type::eof(); }
+# 706 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int_type
+      uflow()
+      {
+ int_type __ret = traits_type::eof();
+ const bool __testeof = traits_type::eq_int_type(this->underflow(),
+       __ret);
+ if (!__testeof)
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ return __ret;
+      }
+# 730 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int_type
+      pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
+      { return traits_type::eof(); }
+# 748 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+# 774 "/usr/include/c++/10.2.0/streambuf" 3
+      virtual int_type
+      overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
+      { return traits_type::eof(); }
+
+
+
+    public:
+# 790 "/usr/include/c++/10.2.0/streambuf" 3
+      [[__deprecated__("stossc is deprecated, use sbumpc instead")]]
+
+      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 "/usr/include/c++/10.2.0/bits/streambuf.tcc" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/streambuf.tcc" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/streambuf.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsgetn(char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->egptr() - this->gptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(__s, this->gptr(), __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_gbump(__len);
+     }
+
+   if (__ret < __n)
+     {
+       const int_type __c = this->uflow();
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    traits_type::assign(*__s++, traits_type::to_char_type(__c));
+    ++__ret;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsputn(const char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->epptr() - this->pptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(this->pptr(), __s, __len);
+       __ret += __len;
+       __s += __len;
+       this->__safe_pbump(__len);
+     }
+
+   if (__ret < __n)
+     {
+       int_type __c = this->overflow(traits_type::to_int_type(*__s));
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    ++__ret;
+    ++__s;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
+     basic_streambuf<_CharT, _Traits>* __sbout,
+     bool& __ineof)
+    {
+      streamsize __ret = 0;
+      __ineof = true;
+      typename _Traits::int_type __c = __sbin->sgetc();
+      while (!_Traits::eq_int_type(__c, _Traits::eof()))
+ {
+   __c = __sbout->sputc(_Traits::to_char_type(__c));
+   if (_Traits::eq_int_type(__c, _Traits::eof()))
+     {
+       __ineof = false;
+       break;
+     }
+   ++__ret;
+   __c = __sbin->snextc();
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline streamsize
+    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
+        basic_streambuf<_CharT, _Traits>* __sbout)
+    {
+      bool __ineof;
+      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
+    }
+
+
+
+
+  extern template class basic_streambuf<char>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<char>*,
+        basic_streambuf<char>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>*,
+     basic_streambuf<char>*, bool&);
+
+
+  extern template class basic_streambuf<wchar_t>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<wchar_t>*,
+        basic_streambuf<wchar_t>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
+     basic_streambuf<wchar_t>*, bool&);
+
+
+
+
+}
+# 863 "/usr/include/c++/10.2.0/streambuf" 2 3
+# 44 "/usr/include/c++/10.2.0/ios" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/basic_ios.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_facets.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+
+# 1 "/usr/include/c++/10.2.0/cwctype" 1 3
+# 39 "/usr/include/c++/10.2.0/cwctype" 3
+       
+# 40 "/usr/include/c++/10.2.0/cwctype" 3
+# 50 "/usr/include/c++/10.2.0/cwctype" 3
+# 1 "/usr/include/wctype.h" 1 3 4
+# 38 "/usr/include/wctype.h" 3 4
+# 1 "/usr/include/bits/wctype-wchar.h" 1 3 4
+# 38 "/usr/include/bits/wctype-wchar.h" 3 4
+typedef unsigned long int wctype_t;
+# 56 "/usr/include/bits/wctype-wchar.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) noexcept (true);
+
+
+
+
+
+extern int iswalpha (wint_t __wc) noexcept (true);
+
+
+extern int iswcntrl (wint_t __wc) noexcept (true);
+
+
+
+extern int iswdigit (wint_t __wc) noexcept (true);
+
+
+
+extern int iswgraph (wint_t __wc) noexcept (true);
+
+
+
+
+extern int iswlower (wint_t __wc) noexcept (true);
+
+
+extern int iswprint (wint_t __wc) noexcept (true);
+
+
+
+
+extern int iswpunct (wint_t __wc) noexcept (true);
+
+
+
+
+extern int iswspace (wint_t __wc) noexcept (true);
+
+
+
+
+extern int iswupper (wint_t __wc) noexcept (true);
+
+
+
+
+extern int iswxdigit (wint_t __wc) noexcept (true);
+
+
+
+
+
+extern int iswblank (wint_t __wc) noexcept (true);
+# 155 "/usr/include/bits/wctype-wchar.h" 3 4
+extern wctype_t wctype (const char *__property) noexcept (true);
+
+
+
+extern int iswctype (wint_t __wc, wctype_t __desc) noexcept (true);
+
+
+
+
+
+
+extern wint_t towlower (wint_t __wc) noexcept (true);
+
+
+extern wint_t towupper (wint_t __wc) noexcept (true);
+
+}
+# 39 "/usr/include/wctype.h" 2 3 4
+
+
+
+
+
+extern "C" {
+
+
+
+typedef const __int32_t *wctrans_t;
+
+
+
+extern wctrans_t wctrans (const char *__property) noexcept (true);
+
+
+extern wint_t towctrans (wint_t __wc, wctrans_t __desc) noexcept (true);
+
+
+
+
+
+
+
+extern int iswalnum_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+
+
+extern int iswalpha_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+extern int iswcntrl_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+extern int iswdigit_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+extern int iswgraph_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+
+extern int iswlower_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+extern int iswprint_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+
+extern int iswpunct_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+
+extern int iswspace_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+
+extern int iswupper_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+
+extern int iswxdigit_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+
+extern int iswblank_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+extern wctype_t wctype_l (const char *__property, locale_t __locale)
+     noexcept (true);
+
+
+
+extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale)
+     noexcept (true);
+
+
+
+
+
+
+extern wint_t towlower_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+extern wint_t towupper_l (wint_t __wc, locale_t __locale) noexcept (true);
+
+
+
+extern wctrans_t wctrans_l (const char *__property, locale_t __locale)
+     noexcept (true);
+
+
+extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
+      locale_t __locale) noexcept (true);
+
+
+
+}
+# 51 "/usr/include/c++/10.2.0/cwctype" 2 3
+# 80 "/usr/include/c++/10.2.0/cwctype" 3
+namespace std
+{
+  using ::wctrans_t;
+  using ::wctype_t;
+  using ::wint_t;
+
+  using ::iswalnum;
+  using ::iswalpha;
+
+  using ::iswblank;
+
+  using ::iswcntrl;
+  using ::iswctype;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::towctrans;
+  using ::towlower;
+  using ::towupper;
+  using ::wctrans;
+  using ::wctype;
+}
+# 40 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+# 1 "/usr/include/c++/10.2.0/cctype" 1 3
+# 39 "/usr/include/c++/10.2.0/cctype" 3
+       
+# 40 "/usr/include/c++/10.2.0/cctype" 3
+# 41 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3
+# 36 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/ctype_base.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  struct ctype_base
+  {
+
+    typedef const int* __to_type;
+
+
+
+    typedef unsigned short mask;
+    static const mask upper = _ISupper;
+    static const mask lower = _ISlower;
+    static const mask alpha = _ISalpha;
+    static const mask digit = _ISdigit;
+    static const mask xdigit = _ISxdigit;
+    static const mask space = _ISspace;
+    static const mask print = _ISprint;
+    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
+    static const mask cntrl = _IScntrl;
+    static const mask punct = _ISpunct;
+    static const mask alnum = _ISalpha | _ISdigit;
+
+    static const mask blank = _ISblank;
+
+  };
+
+
+}
+# 42 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 49 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator
+    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
+        _CharT*, _CharT>
+    {
+    public:
+# 66 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+      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, typename _Size>
+ friend __enable_if_t<__is_char<_CharT2>::__value, _CharT2*>
+ __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _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 _Distance>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            void>::__type
+ advance(istreambuf_iterator<_CharT2>&, _Distance);
+
+    private:
+
+
+
+
+
+
+
+      mutable streambuf_type* _M_sbuf;
+      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()) { }
+
+
+      istreambuf_iterator&
+      operator=(const istreambuf_iterator&) noexcept = default;
+
+
+
+
+
+      char_type
+      operator*() const
+      {
+ int_type __c = _M_get();
+# 157 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+ return traits_type::to_char_type(__c);
+      }
+
+
+      istreambuf_iterator&
+      operator++()
+      {
+
+
+
+                        ;
+
+ _M_sbuf->sbumpc();
+ _M_c = traits_type::eof();
+ return *this;
+      }
+
+
+      istreambuf_iterator
+      operator++(int)
+      {
+
+
+
+                        ;
+
+ istreambuf_iterator __old = *this;
+ __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
+      {
+ int_type __ret = _M_c;
+ if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc()))
+   _M_sbuf = 0;
+ return __ret;
+      }
+
+      bool
+      _M_at_eof() const
+      { return _S_is_eof(_M_get()); }
+
+      static bool
+      _S_is_eof(int_type __c)
+      {
+ const int_type __eof = traits_type::eof();
+ return traits_type::eq_int_type(__c, __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:
+# 274 "/usr/include/c++/10.2.0/bits/streambuf_iterator.h" 3
+      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 _Size>
+    __enable_if_t<__is_char<_CharT>::__value, _CharT*>
+    __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result)
+    {
+      if (__n == 0)
+ return __result;
+
+     
+
+                            ;
+      _CharT* __beg = __result;
+      __result += __it._M_sbuf->sgetn(__beg, __n);
+     
+
+                            ;
+      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;
+      const int_type __eof = traits_type::eof();
+
+      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, __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();
+     }
+
+   __first._M_c = __eof;
+ }
+
+      return __first;
+    }
+
+  template<typename _CharT, typename _Distance>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        void>::__type
+    advance(istreambuf_iterator<_CharT>& __i, _Distance __n)
+    {
+      if (__n == 0)
+ return;
+
+      ;
+     
+
+                           ;
+
+      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;
+      const int_type __eof = traits_type::eof();
+
+      streambuf_type* __sb = __i._M_sbuf;
+      while (__n > 0)
+ {
+   streamsize __size = __sb->egptr() - __sb->gptr();
+   if (__size > __n)
+     {
+       __sb->__safe_gbump(__n);
+       break;
+     }
+
+   __sb->__safe_gbump(__size);
+   __n -= __size;
+   if (traits_type::eq_int_type(__sb->underflow(), __eof))
+     {
+      
+
+                      ;
+       break;
+     }
+ }
+
+      __i._M_c = __eof;
+    }
+
+
+
+
+}
+# 49 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 71 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _Tp>
+    void
+    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+
+  template<>
+    void
+    __convert_to_v(const char*, float&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, double&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, long double&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+
+
+  template<typename _CharT, typename _Traits>
+    struct __pad
+    {
+      static void
+      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
+      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
+    };
+
+
+
+
+
+
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last);
+
+
+
+
+  template<typename _CharT>
+    inline
+    ostreambuf_iterator<_CharT>
+    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
+    {
+      __s._M_put(__ws, __len);
+      return __s;
+    }
+
+
+  template<typename _CharT, typename _OutIter>
+    inline
+    _OutIter
+    __write(_OutIter __s, const _CharT* __ws, int __len)
+    {
+      for (int __j = 0; __j < __len; __j++, ++__s)
+ *__s = __ws[__j];
+      return __s;
+    }
+# 149 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class __ctype_abstract_base : public locale::facet, public ctype_base
+    {
+    public:
+
+
+      typedef _CharT char_type;
+# 168 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      bool
+      is(mask __m, char_type __c) const
+      { return this->do_is(__m, __c); }
+# 185 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
+      { return this->do_is(__lo, __hi, __vec); }
+# 201 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_is(__m, __lo, __hi); }
+# 217 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_not(__m, __lo, __hi); }
+# 231 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 246 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 260 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 275 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 292 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      widen(char __c) const
+      { return this->do_widen(__c); }
+# 311 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      { return this->do_widen(__lo, __hi, __to); }
+# 330 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return this->do_narrow(__c, __dfault); }
+# 352 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+       char __dfault, char* __to) const
+      { return this->do_narrow(__lo, __hi, __dfault, __to); }
+
+    protected:
+      explicit
+      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
+
+      virtual
+      ~__ctype_abstract_base() { }
+# 377 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const = 0;
+# 396 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi,
+     mask* __vec) const = 0;
+# 415 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo,
+   const char_type* __hi) const = 0;
+# 434 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const = 0;
+# 452 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const = 0;
+# 469 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
+# 485 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const = 0;
+# 502 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
+# 521 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const = 0;
+# 542 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
+# 563 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const = 0;
+# 588 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const = 0;
+    };
+# 611 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class ctype : public __ctype_abstract_base<_CharT>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename __ctype_abstract_base<_CharT>::mask mask;
+
+
+      static locale::id id;
+
+      explicit
+      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
+
+   protected:
+      virtual
+      ~ctype();
+
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+
+      virtual char_type
+      do_toupper(char_type __c) const;
+
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_tolower(char_type __c) const;
+
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_widen(char __c) const;
+
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
+
+      virtual char
+      do_narrow(char_type, char __dfault) const;
+
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const;
+    };
+
+  template<typename _CharT>
+    locale::id ctype<_CharT>::id;
+# 680 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<>
+    class ctype<char> : public locale::facet, public ctype_base
+    {
+    public:
+
+
+      typedef char char_type;
+
+    protected:
+
+      __c_locale _M_c_locale_ctype;
+      bool _M_del;
+      __to_type _M_toupper;
+      __to_type _M_tolower;
+      const mask* _M_table;
+      mutable char _M_widen_ok;
+      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow_ok;
+
+
+    public:
+
+      static locale::id id;
+
+      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
+# 717 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
+# 730 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
+     size_t __refs = 0);
+# 743 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      inline bool
+      is(mask __m, char __c) const;
+# 758 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      inline const char*
+      is(const char* __lo, const char* __hi, mask* __vec) const;
+# 772 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      inline const char*
+      scan_is(mask __m, const char* __lo, const char* __hi) const;
+# 786 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      inline const char*
+      scan_not(mask __m, const char* __lo, const char* __hi) const;
+# 801 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 818 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 834 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 851 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 871 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      widen(char __c) const
+      {
+ if (_M_widen_ok)
+   return _M_widen[static_cast<unsigned char>(__c)];
+ this->_M_widen_init();
+ return this->do_widen(__c);
+      }
+# 898 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (_M_widen_ok == 1)
+   {
+     if (__builtin_expect(__hi != __lo, true))
+       __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_widen_ok)
+   _M_widen_init();
+ return this->do_widen(__lo, __hi, __to);
+      }
+# 930 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      {
+ if (_M_narrow[static_cast<unsigned char>(__c)])
+   return _M_narrow[static_cast<unsigned char>(__c)];
+ const char __t = do_narrow(__c, __dfault);
+ if (__t != __dfault)
+   _M_narrow[static_cast<unsigned char>(__c)] = __t;
+ return __t;
+      }
+# 963 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+      char __dfault, char* __to) const
+      {
+ if (__builtin_expect(_M_narrow_ok == 1, true))
+   {
+     if (__builtin_expect(__hi != __lo, 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();
+# 1013 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const;
+# 1030 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1046 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const;
+# 1063 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1083 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const
+      { return __c; }
+# 1106 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (__builtin_expect(__hi != __lo, true))
+   __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+# 1133 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
+      { return __c; }
+# 1159 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault __attribute__((__unused__)), char* __to) const
+      {
+ if (__builtin_expect(__hi != __lo, true))
+   __builtin_memcpy(__to, __lo, __hi - __lo);
+ return __hi;
+      }
+
+    private:
+      void _M_narrow_init() const;
+      void _M_widen_init() const;
+    };
+# 1185 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<>
+    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
+    {
+    public:
+
+
+      typedef wchar_t char_type;
+      typedef wctype_t __wmask_type;
+
+    protected:
+      __c_locale _M_c_locale_ctype;
+
+
+      bool _M_narrow_ok;
+      char _M_narrow[128];
+      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
+
+
+      mask _M_bit[16];
+      __wmask_type _M_wmask[16];
+
+    public:
+
+
+      static locale::id id;
+# 1218 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      ctype(size_t __refs = 0);
+# 1229 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      __wmask_type
+      _M_convert_to_wmask(const mask __m) const throw();
+
+
+      virtual
+      ~ctype();
+# 1253 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+# 1272 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+# 1290 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+# 1308 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+# 1325 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type __c) const;
+# 1342 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1358 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type __c) const;
+# 1375 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1395 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const;
+# 1417 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
+# 1440 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char __dfault) const;
+# 1466 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __to) const;
+
+
+      void
+      _M_initialize_ctype() throw();
+    };
+
+
+
+  template<typename _CharT>
+    class ctype_byname : public ctype<_CharT>
+    {
+    public:
+      typedef typename ctype<_CharT>::mask mask;
+
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+
+      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 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3
+# 37 "/usr/include/c++/10.2.0/x86_64-pc-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;
+  }
+
+
+}
+# 1539 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  class __num_base
+  {
+  public:
+
+
+    enum
+      {
+ _S_ominus,
+ _S_oplus,
+ _S_ox,
+ _S_oX,
+ _S_odigits,
+ _S_odigits_end = _S_odigits + 16,
+ _S_oudigits = _S_odigits_end,
+ _S_oudigits_end = _S_oudigits + 16,
+ _S_oe = _S_odigits + 14,
+ _S_oE = _S_oudigits + 14,
+ _S_oend = _S_oudigits_end
+      };
+
+
+
+
+
+
+    static const char* _S_atoms_out;
+
+
+
+    static const char* _S_atoms_in;
+
+    enum
+    {
+      _S_iminus,
+      _S_iplus,
+      _S_ix,
+      _S_iX,
+      _S_izero,
+      _S_ie = _S_izero + 14,
+      _S_iE = _S_izero + 20,
+      _S_iend = 26
+    };
+
+
+
+    static void
+    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
+  };
+
+  template<typename _CharT>
+    struct __numpunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      const _CharT* _M_truename;
+      size_t _M_truename_size;
+      const _CharT* _M_falsename;
+      size_t _M_falsename_size;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+
+
+
+
+
+      _CharT _M_atoms_out[__num_base::_S_oend];
+
+
+
+
+
+      _CharT _M_atoms_in[__num_base::_S_iend];
+
+      bool _M_allocated;
+
+      __numpunct_cache(size_t __refs = 0)
+      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
+ _M_use_grouping(false),
+ _M_truename(0), _M_truename_size(0), _M_falsename(0),
+ _M_falsename_size(0), _M_decimal_point(_CharT()),
+ _M_thousands_sep(_CharT()), _M_allocated(false)
+ { }
+
+      ~__numpunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __numpunct_cache&
+      operator=(const __numpunct_cache&);
+
+      explicit
+      __numpunct_cache(const __numpunct_cache&);
+    };
+
+  template<typename _CharT>
+    __numpunct_cache<_CharT>::~__numpunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_truename;
+   delete [] _M_falsename;
+ }
+    }
+
+namespace __cxx11 {
+# 1669 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class numpunct : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      typedef __numpunct_cache<_CharT> __cache_type;
+
+    protected:
+      __cache_type* _M_data;
+
+    public:
+
+      static locale::id id;
+
+
+
+
+
+
+      explicit
+      numpunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(); }
+# 1707 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      numpunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_numpunct(); }
+# 1721 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      numpunct(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_numpunct(__cloc); }
+# 1735 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+# 1748 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+# 1779 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      string
+      grouping() const
+      { return this->do_grouping(); }
+# 1792 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      string_type
+      truename() const
+      { return this->do_truename(); }
+# 1805 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      string_type
+      falsename() const
+      { return this->do_falsename(); }
+
+    protected:
+
+      virtual
+      ~numpunct();
+# 1822 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+# 1834 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+# 1847 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+# 1860 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual string_type
+      do_truename() const
+      { return _M_data->_M_truename; }
+# 1873 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual string_type
+      do_falsename() const
+      { return _M_data->_M_falsename; }
+
+
+      void
+      _M_initialize_numpunct(__c_locale __cloc = 0);
+    };
+
+  template<typename _CharT>
+    locale::id numpunct<_CharT>::id;
+
+  template<>
+    numpunct<char>::~numpunct();
+
+  template<>
+    void
+    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
+
+
+  template<>
+    numpunct<wchar_t>::~numpunct();
+
+  template<>
+    void
+    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
+
+
+
+  template<typename _CharT>
+    class numpunct_byname : public numpunct<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      explicit
+      numpunct_byname(const char* __s, size_t __refs = 0)
+      : numpunct<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     __c_locale __tmp;
+     this->_S_create_c_locale(__tmp, __s);
+     this->_M_initialize_numpunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+
+
+      explicit
+      numpunct_byname(const string& __s, size_t __refs = 0)
+      : numpunct_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~numpunct_byname() { }
+    };
+
+}
+
+
+# 1951 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT, typename _InIter>
+    class num_get : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+
+
+      static locale::id id;
+# 1972 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      num_get(size_t __refs = 0) : facet(__refs) { }
+# 1998 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, bool& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2035 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned short& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned int& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2095 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, float& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2138 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, void*& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+    protected:
+
+      virtual ~num_get() { }
+
+      __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;
+ }
+# 2211 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned short& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned int& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      double&) const;
+
+
+
+
+
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
+      long double&) const;
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
+# 2274 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id num_get<_CharT, _InIter>::id;
+# 2292 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+  template<typename _CharT, typename _OutIter>
+    class num_put : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+
+
+      static locale::id id;
+# 2313 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      explicit
+      num_put(size_t __refs = 0) : facet(__refs) { }
+# 2331 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2373 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   unsigned long long __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2436 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   long double __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+# 2461 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   const void* __v) const
+      { return this->do_put(__s, __io, __fill, __v); }
+
+    protected:
+      template<typename _ValueT>
+ iter_type
+ _M_insert_float(iter_type, ios_base& __io, char_type __fill,
+   char __mod, _ValueT __v) const;
+
+      void
+      _M_group_float(const char* __grouping, size_t __grouping_size,
+       char_type __sep, const char_type* __p, char_type* __new,
+       char_type* __cs, int& __len) const;
+
+      template<typename _ValueT>
+ iter_type
+ _M_insert_int(iter_type, ios_base& __io, char_type __fill,
+        _ValueT __v) const;
+
+      void
+      _M_group_int(const char* __grouping, size_t __grouping_size,
+     char_type __sep, ios_base& __io, char_type* __new,
+     char_type* __cs, int& __len) const;
+
+      void
+      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
+      char_type* __new, const char_type* __cs, int& __len) const;
+
+
+      virtual
+      ~num_put() { }
+# 2509 "/usr/include/c++/10.2.0/bits/locale_facets.h" 3
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, double) const;
+
+
+
+
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, long double) const;
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type, const void*) const;
+
+
+
+
+
+
+
+    };
+
+  template <typename _CharT, typename _OutIter>
+    locale::id num_put<_CharT, _OutIter>::id;
+
+
+
+
+
+
+
+
+
+  template<typename _CharT>
+    inline bool
+    isspace(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isprint(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    iscntrl(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    islower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isalpha(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    ispunct(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isxdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isalnum(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isgraph(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
+
+
+
+  template<typename _CharT>
+    inline 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 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<typename _Facet>
+    struct __use_cache
+    {
+      const _Facet*
+      operator() (const locale& __loc) const;
+    };
+
+
+  template<typename _CharT>
+    struct __use_cache<__numpunct_cache<_CharT> >
+    {
+      const __numpunct_cache<_CharT>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = numpunct<_CharT>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __numpunct_cache<_CharT>* __tmp = 0;
+     try
+       {
+  __tmp = new __numpunct_cache<_CharT>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
+      }
+    };
+
+  template<typename _CharT>
+    void
+    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
+    {
+      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 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  __attribute__ ((__pure__)) bool
+  __verify_grouping(const char* __grouping, size_t __grouping_size,
+      const string& __grouping_tmp) throw ();
+
+
+
+  template<typename _CharT, typename _InIter>
+    __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);
+
+
+ typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits;
+ string __found_grouping;
+ if (__lc->_M_use_grouping)
+   __found_grouping.reserve(32);
+ bool __testfail = false;
+ bool __testoverflow = false;
+ const __unsigned_type __max =
+   (__negative && __num_traits::__is_signed)
+   ? -static_cast<__unsigned_type>(__num_traits::__min)
+   : __num_traits::__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 && __num_traits::__is_signed)
+       __v = __num_traits::__min;
+     else
+       __v = __num_traits::__max;
+     __err = ios_base::failbit;
+   }
+ else
+   __v = __negative ? -__result : __result;
+
+ if (__testeof)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, bool& __v) const
+    {
+      if (!(__io.flags() & ios_base::boolalpha))
+        {
+
+
+
+   long __l = -1;
+          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
+   if (__l == 0 || __l == 1)
+     __v = bool(__l);
+   else
+     {
+
+
+       __v = true;
+       __err = ios_base::failbit;
+       if (__beg == __end)
+  __err |= ios_base::eofbit;
+     }
+        }
+      else
+        {
+
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+
+   bool __testf = true;
+   bool __testt = true;
+   bool __donef = __lc->_M_falsename_size == 0;
+   bool __donet = __lc->_M_truename_size == 0;
+   bool __testeof = false;
+   size_t __n = 0;
+   while (!__donef || !__donet)
+     {
+       if (__beg == __end)
+  {
+    __testeof = true;
+    break;
+  }
+
+       const char_type __c = *__beg;
+
+       if (!__donef)
+  __testf = __c == __lc->_M_falsename[__n];
+
+       if (!__testf && __donet)
+  break;
+
+       if (!__donet)
+  __testt = __c == __lc->_M_truename[__n];
+
+       if (!__testt && __donef)
+  break;
+
+       if (!__testt && !__testf)
+  break;
+
+       ++__n;
+       ++__beg;
+
+       __donef = !__testf || __n >= __lc->_M_falsename_size;
+       __donet = !__testt || __n >= __lc->_M_truename_size;
+     }
+   if (__testf && __n == __lc->_M_falsename_size && __n)
+     {
+       __v = false;
+       if (__testt && __n == __lc->_M_truename_size)
+  __err = ios_base::failbit;
+       else
+  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else if (__testt && __n == __lc->_M_truename_size && __n)
+     {
+       __v = true;
+       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else
+     {
+
+
+       __v = false;
+       __err = ios_base::failbit;
+       if (__testeof)
+  __err |= ios_base::eofbit;
+     }
+ }
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, float& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+# 735 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, long double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, void*& __v) const
+    {
+
+      typedef ios_base::fmtflags fmtflags;
+      const fmtflags __fmt = __io.flags();
+      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+
+      _UIntPtrType __ul;
+      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
+
+
+      __io.flags(__fmt);
+
+      __v = reinterpret_cast<void*>(__ul);
+      return __beg;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
+    _CharT* __new, const _CharT* __cs, int& __len) const
+    {
+
+
+      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
+        __cs, __w, __len);
+      __len = static_cast<int>(__w);
+    }
+
+
+
+  template<typename _CharT, typename _ValueT>
+    int
+    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
+    ios_base::fmtflags __flags, bool __dec)
+    {
+      _CharT* __buf = __bufend;
+      if (__builtin_expect(__dec, true))
+ {
+
+   do
+     {
+       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
+       __v /= 10;
+     }
+   while (__v != 0);
+ }
+      else if ((__flags & ios_base::basefield) == ios_base::oct)
+ {
+
+   do
+     {
+       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
+       __v >>= 3;
+     }
+   while (__v != 0);
+ }
+      else
+ {
+
+   const bool __uppercase = __flags & ios_base::uppercase;
+   const int __case_offset = __uppercase ? __num_base::_S_oudigits
+                                         : __num_base::_S_odigits;
+   do
+     {
+       *--__buf = __lit[(__v & 0xf) + __case_offset];
+       __v >>= 4;
+     }
+   while (__v != 0);
+ }
+      return __bufend - __buf;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
+   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
+    {
+      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
+     __grouping_size, __cs, __cs + __len);
+      __len = __p - __new;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
+      _ValueT __v) const
+      {
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_out;
+ const ios_base::fmtflags __flags = __io.flags();
+
+
+ const int __ilen = 5 * sizeof(_ValueT);
+ _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __ilen));
+
+
+
+ const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
+ const bool __dec = (__basefield != ios_base::oct
+       && __basefield != ios_base::hex);
+ const __unsigned_type __u = ((__v > 0 || !__dec)
+         ? __unsigned_type(__v)
+         : -__unsigned_type(__v));
+  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
+ __cs += __ilen - __len;
+
+
+ if (__lc->_M_use_grouping)
+   {
+
+
+     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * (__len + 1)
+          * 2));
+     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
+    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
+     __cs = __cs2 + 2;
+   }
+
+
+ if (__builtin_expect(__dec, true))
+   {
+
+     if (__v >= 0)
+       {
+  if (bool(__flags & ios_base::showpos)
+      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+    *--__cs = __lit[__num_base::_S_oplus], ++__len;
+       }
+     else
+       *--__cs = __lit[__num_base::_S_ominus], ++__len;
+   }
+ else if (bool(__flags & ios_base::showbase) && __v)
+   {
+     if (__basefield == ios_base::oct)
+       *--__cs = __lit[__num_base::_S_odigits], ++__len;
+     else
+       {
+
+  const bool __uppercase = __flags & ios_base::uppercase;
+  *--__cs = __lit[__num_base::_S_ox + __uppercase];
+
+  *--__cs = __lit[__num_base::_S_odigits];
+  __len += 2;
+       }
+   }
+
+
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
+     __cs = __cs3;
+   }
+ __io.width(0);
+
+
+
+ return std::__write(__s, __cs, __len);
+      }
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_float(const char* __grouping, size_t __grouping_size,
+     _CharT __sep, const _CharT* __p, _CharT* __new,
+     _CharT* __cs, int& __len) const
+    {
+
+
+
+      const int __declen = __p ? __p - __cs : __len;
+      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
+      __grouping_size,
+      __cs, __cs + __declen);
+
+
+      int __newlen = __p2 - __new;
+      if (__p)
+ {
+   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
+   __newlen += __len - __declen;
+ }
+      __len = __newlen;
+    }
+# 971 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
+         _ValueT __v) const
+      {
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+
+
+ const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
+
+ const int __max_digits =
+   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
+
+
+ int __len;
+
+ char __fbuf[16];
+ __num_base::_S_format_float(__io, __fbuf, __mod);
+
+
+
+ const bool __use_prec =
+   (__io.flags() & ios_base::floatfield) != ios_base::floatfield;
+
+
+
+ int __cs_size = __max_digits * 3;
+ char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+ if (__use_prec)
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __prec, __v);
+ else
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     __fbuf, __v);
+
+
+ if (__len >= __cs_size)
+   {
+     __cs_size = __len + 1;
+     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+     if (__use_prec)
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __prec, __v);
+     else
+       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+         __fbuf, __v);
+   }
+# 1044 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __len));
+ __ctype.widen(__cs, __cs + __len, __ws);
+
+
+ _CharT* __wp = 0;
+ const char* __p = char_traits<char>::find(__cs, __len, '.');
+ if (__p)
+   {
+     __wp = __ws + (__p - __cs);
+     *__wp = __lc->_M_decimal_point;
+   }
+
+
+
+
+ if (__lc->_M_use_grouping
+     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
+          && __cs[1] >= '0' && __cs[2] >= '0')))
+   {
+
+
+     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __len * 2));
+
+     streamsize __off = 0;
+     if (__cs[0] == '-' || __cs[0] == '+')
+       {
+  __off = 1;
+  __ws2[0] = __ws[0];
+  __len -= 1;
+       }
+
+     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
+      __lc->_M_thousands_sep, __wp, __ws2 + __off,
+      __ws + __off, __len);
+     __len += __off;
+
+     __ws = __ws2;
+   }
+
+
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
+     __ws = __ws3;
+   }
+ __io.width(0);
+
+
+
+ return std::__write(__s, __ws, __len);
+      }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      if ((__flags & ios_base::boolalpha) == 0)
+        {
+          const long __l = __v;
+          __s = _M_insert_int(__s, __io, __fill, __l);
+        }
+      else
+        {
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+
+   const _CharT* __name = __v ? __lc->_M_truename
+                              : __lc->_M_falsename;
+   int __len = __v ? __lc->_M_truename_size
+                   : __lc->_M_falsename_size;
+
+   const streamsize __w = __io.width();
+   if (__w > static_cast<streamsize>(__len))
+     {
+       const streamsize __plen = __w - __len;
+       _CharT* __ps
+  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+       * __plen));
+
+       char_traits<_CharT>::assign(__ps, __plen, __fill);
+       __io.width(0);
+
+       if ((__flags & ios_base::adjustfield) == ios_base::left)
+  {
+    __s = std::__write(__s, __name, __len);
+    __s = std::__write(__s, __ps, __plen);
+  }
+       else
+  {
+    __s = std::__write(__s, __ps, __plen);
+    __s = std::__write(__s, __name, __len);
+  }
+       return __s;
+     }
+   __io.width(0);
+   __s = std::__write(__s, __name, __len);
+ }
+      return __s;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+    { return _M_insert_float(__s, __io, __fill, char(), __v); }
+# 1169 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+    long double __v) const
+    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+           const void* __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      const ios_base::fmtflags __fmt = ~(ios_base::basefield
+      | ios_base::uppercase);
+      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+
+      __s = _M_insert_int(__s, __io, __fill,
+     reinterpret_cast<_UIntPtrType>(__v));
+      __io.flags(__flags);
+      return __s;
+    }
+
+
+# 1206 "/usr/include/c++/10.2.0/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _Traits>
+    void
+    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
+       _CharT* __news, const _CharT* __olds,
+       streamsize __newlen, streamsize __oldlen)
+    {
+      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
+      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
+
+
+      if (__adjust == ios_base::left)
+ {
+   _Traits::copy(__news, __olds, __oldlen);
+   _Traits::assign(__news + __oldlen, __plen, __fill);
+   return;
+ }
+
+      size_t __mod = 0;
+      if (__adjust == ios_base::internal)
+ {
+
+
+
+          const locale& __loc = __io._M_getloc();
+   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+   if (__ctype.widen('-') == __olds[0]
+       || __ctype.widen('+') == __olds[0])
+     {
+       __news[0] = __olds[0];
+       __mod = 1;
+       ++__news;
+     }
+   else if (__ctype.widen('0') == __olds[0]
+     && __oldlen > 1
+     && (__ctype.widen('x') == __olds[1]
+         || __ctype.widen('X') == __olds[1]))
+     {
+       __news[0] = __olds[0];
+       __news[1] = __olds[1];
+       __mod = 2;
+       __news += 2;
+     }
+
+ }
+      _Traits::assign(__news, __plen, __fill);
+      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
+    }
+
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last)
+    {
+      size_t __idx = 0;
+      size_t __ctr = 0;
+
+      while (__last - __first > __gbeg[__idx]
+      && static_cast<signed char>(__gbeg[__idx]) > 0
+      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
+ {
+   __last -= __gbeg[__idx];
+   __idx < __gsize - 1 ? ++__idx : ++__ctr;
+ }
+
+      while (__first != __last)
+ *__s++ = *__first++;
+
+      while (__ctr--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+
+      while (__idx--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+
+      return __s;
+    }
+
+
+
+
+  extern template class __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&);
+
+
+
+
+}
+# 2656 "/usr/include/c++/10.2.0/bits/locale_facets.h" 2 3
+# 38 "/usr/include/c++/10.2.0/bits/basic_ios.h" 2 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _Facet>
+    inline const _Facet&
+    __check_facet(const _Facet* __f)
+    {
+      if (!__f)
+ __throw_bad_cast();
+      return *__f;
+    }
+# 66 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ios : public ios_base
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+
+
+
+
+      typedef ctype<_CharT> __ctype_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+           __num_put_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+           __num_get_type;
+
+
+
+    protected:
+      basic_ostream<_CharT, _Traits>* _M_tie;
+      mutable char_type _M_fill;
+      mutable bool _M_fill_init;
+      basic_streambuf<_CharT, _Traits>* _M_streambuf;
+
+
+      const __ctype_type* _M_ctype;
+
+      const __num_put_type* _M_num_put;
+
+      const __num_get_type* _M_num_get;
+
+    public:
+# 117 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      explicit operator bool() const
+      { return !this->fail(); }
+
+
+
+
+
+      bool
+      operator!() const
+      { return this->fail(); }
+# 136 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      iostate
+      rdstate() const
+      { return _M_streambuf_state; }
+# 147 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      void
+      clear(iostate __state = goodbit);
+
+
+
+
+
+
+
+      void
+      setstate(iostate __state)
+      { this->clear(this->rdstate() | __state); }
+
+
+
+
+      void
+      _M_setstate(iostate __state)
+      {
+
+
+ _M_streambuf_state |= __state;
+ if (this->exceptions() & __state)
+   throw;
+      }
+
+
+
+
+
+
+
+      bool
+      good() const
+      { return this->rdstate() == 0; }
+
+
+
+
+
+
+
+      bool
+      eof() const
+      { return (this->rdstate() & eofbit) != 0; }
+# 200 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      bool
+      fail() const
+      { return (this->rdstate() & (badbit | failbit)) != 0; }
+
+
+
+
+
+
+
+      bool
+      bad() const
+      { return (this->rdstate() & badbit) != 0; }
+# 221 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      iostate
+      exceptions() const
+      { return _M_exception; }
+# 256 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      void
+      exceptions(iostate __except)
+      {
+        _M_exception = __except;
+        this->clear(_M_streambuf_state);
+      }
+
+
+
+
+
+
+
+      explicit
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
+      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
+ _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { this->init(__sb); }
+
+
+
+
+
+
+
+      virtual
+      ~basic_ios() { }
+# 294 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie() const
+      { return _M_tie; }
+# 306 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie(basic_ostream<_CharT, _Traits>* __tiestr)
+      {
+        basic_ostream<_CharT, _Traits>* __old = _M_tie;
+        _M_tie = __tiestr;
+        return __old;
+      }
+
+
+
+
+
+
+
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf() const
+      { return _M_streambuf; }
+# 346 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+# 360 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      basic_ios&
+      copyfmt(const basic_ios& __rhs);
+
+
+
+
+
+
+
+      char_type
+      fill() const
+      {
+ if (!_M_fill_init)
+   {
+     _M_fill = this->widen(' ');
+     _M_fill_init = true;
+   }
+ return _M_fill;
+      }
+# 389 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      char_type
+      fill(char_type __ch)
+      {
+ char_type __old = this->fill();
+ _M_fill = __ch;
+ return __old;
+      }
+# 409 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      locale
+      imbue(const locale& __loc);
+# 429 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
+# 448 "/usr/include/c++/10.2.0/bits/basic_ios.h" 3
+      char_type
+      widen(char __c) const
+      { return __check_facet(_M_ctype).widen(__c); }
+
+    protected:
+
+
+
+
+
+
+
+      basic_ios()
+      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
+ _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { }
+
+
+
+
+
+
+
+      void
+      init(basic_streambuf<_CharT, _Traits>* __sb);
+
+
+      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 "/usr/include/c++/10.2.0/bits/basic_ios.tcc" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/basic_ios.tcc" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/basic_ios.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::clear(iostate __state)
+    {
+      if (this->rdbuf())
+ _M_streambuf_state = __state;
+      else
+   _M_streambuf_state = __state | badbit;
+      if (this->exceptions() & this->rdstate())
+ __throw_ios_failure(("basic_ios::clear"));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_streambuf<_CharT, _Traits>*
+    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
+      _M_streambuf = __sb;
+      this->clear();
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ios<_CharT, _Traits>&
+    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
+    {
+
+
+      if (this != &__rhs)
+ {
+
+
+
+
+   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
+                      _M_local_word : new _Words[__rhs._M_word_size];
+
+
+   _Callback_list* __cb = __rhs._M_callbacks;
+   if (__cb)
+     __cb->_M_add_reference();
+   _M_call_callbacks(erase_event);
+   if (_M_word != _M_local_word)
+     {
+       delete [] _M_word;
+       _M_word = 0;
+     }
+   _M_dispose_callbacks();
+
+
+   _M_callbacks = __cb;
+   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
+     __words[__i] = __rhs._M_word[__i];
+   _M_word = __words;
+   _M_word_size = __rhs._M_word_size;
+
+   this->flags(__rhs.flags());
+   this->width(__rhs.width());
+   this->precision(__rhs.precision());
+   this->tie(__rhs.tie());
+   this->fill(__rhs.fill());
+   _M_ios_locale = __rhs.getloc();
+   _M_cache_locale(_M_ios_locale);
+
+   _M_call_callbacks(copyfmt_event);
+
+
+   this->exceptions(__rhs.exceptions());
+ }
+      return *this;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    locale
+    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
+    {
+      locale __old(this->getloc());
+      ios_base::imbue(__loc);
+      _M_cache_locale(__loc);
+      if (this->rdbuf() != 0)
+ this->rdbuf()->pubimbue(__loc);
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+
+      ios_base::_M_init();
+
+
+      _M_cache_locale(_M_ios_locale);
+# 146 "/usr/include/c++/10.2.0/bits/basic_ios.tcc" 3
+      _M_fill = _CharT();
+      _M_fill_init = false;
+
+      _M_tie = 0;
+      _M_exception = goodbit;
+      _M_streambuf = __sb;
+      _M_streambuf_state = __sb ? goodbit : badbit;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
+    {
+      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
+ _M_ctype = std::__addressof(use_facet<__ctype_type>(__loc));
+      else
+ _M_ctype = 0;
+
+      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
+ _M_num_put = std::__addressof(use_facet<__num_put_type>(__loc));
+      else
+ _M_num_put = 0;
+
+      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
+ _M_num_get = std::__addressof(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 "/usr/include/c++/10.2.0/bits/basic_ios.h" 2 3
+# 45 "/usr/include/c++/10.2.0/ios" 2 3
+# 39 "/usr/include/c++/10.2.0/istream" 2 3
+# 1 "/usr/include/c++/10.2.0/ostream" 1 3
+# 36 "/usr/include/c++/10.2.0/ostream" 3
+       
+# 37 "/usr/include/c++/10.2.0/ostream" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 57 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+             __num_put_type;
+      typedef ctype<_CharT> __ctype_type;
+# 83 "/usr/include/c++/10.2.0/ostream" 3
+      explicit
+      basic_ostream(__streambuf_type* __sb)
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_ostream() { }
+
+
+      class sentry;
+      friend class sentry;
+# 107 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(__ostream_type& (*__pf)(__ostream_type&))
+      {
+
+
+
+ return __pf(*this);
+      }
+
+      __ostream_type&
+      operator<<(__ios_type& (*__pf)(__ios_type&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+
+      __ostream_type&
+      operator<<(ios_base& (*__pf) (ios_base&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+# 165 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(bool __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(short __n);
+
+      __ostream_type&
+      operator<<(unsigned short __n)
+      {
+
+
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+      __ostream_type&
+      operator<<(int __n);
+
+      __ostream_type&
+      operator<<(unsigned int __n)
+      {
+
+
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+
+      __ostream_type&
+      operator<<(long long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long long __n)
+      { return _M_insert(__n); }
+# 219 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(double __f)
+      { return _M_insert(__f); }
+
+      __ostream_type&
+      operator<<(float __f)
+      {
+
+
+ return _M_insert(static_cast<double>(__f));
+      }
+
+      __ostream_type&
+      operator<<(long double __f)
+      { return _M_insert(__f); }
+# 244 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(const void* __p)
+      { return _M_insert(__p); }
+# 275 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      operator<<(__streambuf_type* __sb);
+# 308 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      put(char_type __c);
+
+
+
+
+
+
+      void
+      _M_write(const char_type* __s, streamsize __n)
+      {
+ const streamsize __put = this->rdbuf()->sputn(__s, __n);
+ if (__put != __n)
+   this->setstate(ios_base::badbit);
+      }
+# 340 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      write(const char_type* __s, streamsize __n);
+# 353 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      flush();
+# 363 "/usr/include/c++/10.2.0/ostream" 3
+      pos_type
+      tellp();
+# 374 "/usr/include/c++/10.2.0/ostream" 3
+      __ostream_type&
+      seekp(pos_type);
+# 386 "/usr/include/c++/10.2.0/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);
+    };
+# 431 "/usr/include/c++/10.2.0/ostream" 3
+  template <typename _CharT, typename _Traits>
+    class basic_ostream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+      basic_ostream<_CharT, _Traits>& _M_os;
+
+    public:
+# 450 "/usr/include/c++/10.2.0/ostream" 3
+      explicit
+      sentry(basic_ostream<_CharT, _Traits>& __os);
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+
+
+
+
+
+
+      ~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);
+   }
+      }
+#pragma GCC diagnostic pop
+# 482 "/usr/include/c++/10.2.0/ostream" 3
+      explicit
+
+      operator bool() const
+      { return _M_ok; }
+    };
+# 504 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
+    { return (__out << __out.widen(__c)); }
+
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, char __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
+    { return (__out << static_cast<char>(__c)); }
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
+    { return (__out << static_cast<char>(__c)); }
+# 587 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits> &
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
+
+
+  template<typename _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<typename _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+
+  template<typename _Traits>
+    inline basic_ostream<char, _Traits> &
+    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+# 679 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    endl(basic_ostream<_CharT, _Traits>& __os)
+    { return flush(__os.put(__os.widen('\n'))); }
+# 691 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    ends(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.put(_CharT()); }
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    flush(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.flush(); }
+
+
+  template<typename _Ch, typename _Up>
+    basic_ostream<_Ch, _Up>&
+    __is_convertible_to_basic_ostream_test(basic_ostream<_Ch, _Up>*);
+
+  template<typename _Tp, typename = void>
+    struct __is_convertible_to_basic_ostream_impl
+    {
+      using __ostream_type = void;
+    };
+
+  template<typename _Tp>
+    using __do_is_convertible_to_basic_ostream_impl =
+    decltype(__is_convertible_to_basic_ostream_test
+      (declval<typename remove_reference<_Tp>::type*>()));
+
+  template<typename _Tp>
+    struct __is_convertible_to_basic_ostream_impl
+    <_Tp,
+     __void_t<__do_is_convertible_to_basic_ostream_impl<_Tp>>>
+    {
+      using __ostream_type =
+ __do_is_convertible_to_basic_ostream_impl<_Tp>;
+    };
+
+  template<typename _Tp>
+    struct __is_convertible_to_basic_ostream
+    : __is_convertible_to_basic_ostream_impl<_Tp>
+    {
+    public:
+      using type = __not_<is_void<
+        typename __is_convertible_to_basic_ostream_impl<_Tp>::__ostream_type>>;
+      constexpr static bool value = type::value;
+    };
+
+  template<typename _Ostream, typename _Tp, typename = void>
+    struct __is_insertable : false_type {};
+
+  template<typename _Ostream, typename _Tp>
+    struct __is_insertable<_Ostream, _Tp,
+      __void_t<decltype(declval<_Ostream&>()
+          << declval<const _Tp&>())>>
+        : true_type {};
+
+  template<typename _Ostream>
+    using __rvalue_ostream_type =
+      typename __is_convertible_to_basic_ostream<
+ _Ostream>::__ostream_type;
+# 765 "/usr/include/c++/10.2.0/ostream" 3
+  template<typename _Ostream, typename _Tp>
+    inline
+    typename enable_if<__and_<__not_<is_lvalue_reference<_Ostream>>,
+         __is_convertible_to_basic_ostream<_Ostream>,
+         __is_insertable<
+    __rvalue_ostream_type<_Ostream>,
+    const _Tp&>>::value,
+         __rvalue_ostream_type<_Ostream>>::type
+    operator<<(_Ostream&& __os, const _Tp& __x)
+    {
+      __rvalue_ostream_type<_Ostream> __ret_os = __os;
+      __ret_os << __x;
+      return __ret_os;
+    }
+
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/ostream.tcc" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/ostream.tcc" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/ostream.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>::sentry::
+    sentry(basic_ostream<_CharT, _Traits>& __os)
+    : _M_ok(false), _M_os(__os)
+    {
+
+      if (__os.tie() && __os.good())
+ __os.tie()->flush();
+
+      if (__os.good())
+ _M_ok = true;
+      else
+ __os.setstate(ios_base::failbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_ostream<_CharT, _Traits>&
+      basic_ostream<_CharT, _Traits>::
+      _M_insert(_ValueT __v)
+      {
+ sentry __cerb(*this);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_put_type& __np = __check_facet(this->_M_num_put);
+  if (__np.put(*this, *this, this->fill(), __v).failed())
+    __err |= ios_base::badbit;
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(short __n)
+    {
+
+
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(int __n)
+    {
+
+
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(__streambuf_type* __sbin)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this);
+      if (__cerb && __sbin)
+ {
+   try
+     {
+       if (!__copy_streambufs(__sbin, this->rdbuf()))
+  __err |= ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbin)
+ __err |= ios_base::badbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    put(char_type __c)
+    {
+
+
+
+
+
+
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __put = this->rdbuf()->sputc(__c);
+       if (traits_type::eq_int_type(__put, traits_type::eof()))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    write(const _CharT* __s, streamsize __n)
+    {
+
+
+
+
+
+
+
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   try
+     { _M_write(__s, __n); }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    flush()
+    {
+
+
+
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
+     __err |= ios_base::badbit;
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_ostream<_CharT, _Traits>::pos_type
+    basic_ostream<_CharT, _Traits>::
+    tellp()
+    {
+      pos_type __ret = pos_type(-1);
+      try
+ {
+   if (!this->fail())
+     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(pos_type __pos)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+
+       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+            ios_base::out);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(off_type __off, ios_base::seekdir __dir)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+
+       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+            ios_base::out);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ {
+
+
+   const size_t __clen = char_traits<char>::length(__s);
+   try
+     {
+       struct __ptr_guard
+       {
+  _CharT *__p;
+  __ptr_guard (_CharT *__ip): __p(__ip) { }
+  ~__ptr_guard() { delete[] __p; }
+  _CharT* __get() { return __p; }
+       } __pg (new _CharT[__clen]);
+
+       _CharT *__ws = __pg.__get();
+       for (size_t __i = 0; __i < __clen; ++__i)
+  __ws[__i] = __out.widen(__s[__i]);
+       __ostream_insert(__out, __ws, __clen);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(ios_base::badbit); }
+ }
+      return __out;
+    }
+
+
+
+
+  extern template class basic_ostream<char>;
+  extern template ostream& endl(ostream&);
+  extern template ostream& ends(ostream&);
+  extern template ostream& flush(ostream&);
+  extern template ostream& operator<<(ostream&, char);
+  extern template ostream& operator<<(ostream&, unsigned char);
+  extern template ostream& operator<<(ostream&, signed char);
+  extern template ostream& operator<<(ostream&, const char*);
+  extern template ostream& operator<<(ostream&, const unsigned char*);
+  extern template ostream& operator<<(ostream&, const signed char*);
+
+  extern template ostream& ostream::_M_insert(long);
+  extern template ostream& ostream::_M_insert(unsigned long);
+  extern template ostream& ostream::_M_insert(bool);
+
+  extern template ostream& ostream::_M_insert(long long);
+  extern template ostream& ostream::_M_insert(unsigned long long);
+
+  extern template ostream& ostream::_M_insert(double);
+  extern template ostream& ostream::_M_insert(long double);
+  extern template ostream& ostream::_M_insert(const void*);
+
+
+  extern template class basic_ostream<wchar_t>;
+  extern template wostream& endl(wostream&);
+  extern template wostream& ends(wostream&);
+  extern template wostream& flush(wostream&);
+  extern template wostream& operator<<(wostream&, wchar_t);
+  extern template wostream& operator<<(wostream&, char);
+  extern template wostream& operator<<(wostream&, const wchar_t*);
+  extern template wostream& operator<<(wostream&, const char*);
+
+  extern template wostream& wostream::_M_insert(long);
+  extern template wostream& wostream::_M_insert(unsigned long);
+  extern template wostream& wostream::_M_insert(bool);
+
+  extern template wostream& wostream::_M_insert(long long);
+  extern template wostream& wostream::_M_insert(unsigned long long);
+
+  extern template wostream& wostream::_M_insert(double);
+  extern template wostream& wostream::_M_insert(long double);
+  extern template wostream& wostream::_M_insert(const void*);
+
+
+
+
+}
+# 785 "/usr/include/c++/10.2.0/ostream" 2 3
+# 40 "/usr/include/c++/10.2.0/istream" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 57 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+        __num_get_type;
+      typedef ctype<_CharT> __ctype_type;
+
+    protected:
+
+
+
+
+
+      streamsize _M_gcount;
+
+    public:
+
+
+
+
+
+
+
+      explicit
+      basic_istream(__streambuf_type* __sb)
+      : _M_gcount(streamsize(0))
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_istream()
+      { _M_gcount = streamsize(0); }
+
+
+      class sentry;
+      friend class sentry;
+# 119 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(__istream_type& (*__pf)(__istream_type&))
+      { return __pf(*this); }
+
+      __istream_type&
+      operator>>(__ios_type& (*__pf)(__ios_type&))
+      {
+ __pf(*this);
+ return *this;
+      }
+
+      __istream_type&
+      operator>>(ios_base& (*__pf)(ios_base&))
+      {
+ __pf(*this);
+ return *this;
+      }
+# 167 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(bool& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(short& __n);
+
+      __istream_type&
+      operator>>(unsigned short& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(int& __n);
+
+      __istream_type&
+      operator>>(unsigned int& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long& __n)
+      { return _M_extract(__n); }
+
+
+      __istream_type&
+      operator>>(long long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long long& __n)
+      { return _M_extract(__n); }
+# 213 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(float& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(double& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(long double& __f)
+      { return _M_extract(__f); }
+# 234 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(void*& __p)
+      { return _M_extract(__p); }
+# 258 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      operator>>(__streambuf_type* __sb);
+# 268 "/usr/include/c++/10.2.0/istream" 3
+      streamsize
+      gcount() const
+      { return _M_gcount; }
+# 301 "/usr/include/c++/10.2.0/istream" 3
+      int_type
+      get();
+# 315 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(char_type& __c);
+# 342 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n, char_type __delim);
+# 353 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n)
+      { return this->get(__s, __n, this->widen('\n')); }
+# 376 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb, char_type __delim);
+# 386 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb)
+      { return this->get(__sb, this->widen('\n')); }
+# 415 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n, char_type __delim);
+# 426 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n)
+      { return this->getline(__s, __n, this->widen('\n')); }
+# 450 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      ignore(streamsize __n, int_type __delim);
+
+      __istream_type&
+      ignore(streamsize __n);
+
+      __istream_type&
+      ignore();
+# 467 "/usr/include/c++/10.2.0/istream" 3
+      int_type
+      peek();
+# 485 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      read(char_type* __s, streamsize __n);
+# 504 "/usr/include/c++/10.2.0/istream" 3
+      streamsize
+      readsome(char_type* __s, streamsize __n);
+# 521 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      putback(char_type __c);
+# 537 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      unget();
+# 555 "/usr/include/c++/10.2.0/istream" 3
+      int
+      sync();
+# 570 "/usr/include/c++/10.2.0/istream" 3
+      pos_type
+      tellg();
+# 585 "/usr/include/c++/10.2.0/istream" 3
+      __istream_type&
+      seekg(pos_type);
+# 601 "/usr/include/c++/10.2.0/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 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+
+    public:
+
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::__ctype_type __ctype_type;
+      typedef typename _Traits::int_type __int_type;
+# 721 "/usr/include/c++/10.2.0/istream" 3
+      explicit
+      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
+# 732 "/usr/include/c++/10.2.0/istream" 3
+      explicit
+
+      operator bool() const
+      { return _M_ok; }
+    };
+# 750 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+# 792 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
+
+
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __in, char* __s);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+# 823 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_iostream
+    : public basic_istream<_CharT, _Traits>,
+      public basic_ostream<_CharT, _Traits>
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+
+
+
+
+
+
+
+      explicit
+      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
+      : __istream_type(__sb), __ostream_type(__sb) { }
+
+
+
+
+      virtual
+      ~basic_iostream() { }
+
+    protected:
+      basic_iostream()
+      : __istream_type(), __ostream_type() { }
+
+
+      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 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __is);
+
+
+  template<typename _Ch, typename _Up>
+    basic_istream<_Ch, _Up>&
+    __is_convertible_to_basic_istream_test(basic_istream<_Ch, _Up>*);
+
+  template<typename _Tp, typename = void>
+    struct __is_convertible_to_basic_istream_impl
+    {
+      using __istream_type = void;
+    };
+
+  template<typename _Tp>
+    using __do_is_convertible_to_basic_istream_impl =
+    decltype(__is_convertible_to_basic_istream_test
+      (declval<typename remove_reference<_Tp>::type*>()));
+
+  template<typename _Tp>
+    struct __is_convertible_to_basic_istream_impl
+    <_Tp,
+     __void_t<__do_is_convertible_to_basic_istream_impl<_Tp>>>
+    {
+      using __istream_type =
+ __do_is_convertible_to_basic_istream_impl<_Tp>;
+    };
+
+  template<typename _Tp>
+    struct __is_convertible_to_basic_istream
+    : __is_convertible_to_basic_istream_impl<_Tp>
+    {
+    public:
+      using type = __not_<is_void<
+        typename __is_convertible_to_basic_istream_impl<_Tp>::__istream_type>>;
+      constexpr static bool value = type::value;
+    };
+
+  template<typename _Istream, typename _Tp, typename = void>
+    struct __is_extractable : false_type {};
+
+  template<typename _Istream, typename _Tp>
+    struct __is_extractable<_Istream, _Tp,
+       __void_t<decltype(declval<_Istream&>()
+           >> declval<_Tp>())>>
+    : true_type {};
+
+  template<typename _Istream>
+    using __rvalue_istream_type =
+      typename __is_convertible_to_basic_istream<
+ _Istream>::__istream_type;
+# 972 "/usr/include/c++/10.2.0/istream" 3
+  template<typename _Istream, typename _Tp>
+    inline
+    typename enable_if<__and_<__not_<is_lvalue_reference<_Istream>>,
+         __is_convertible_to_basic_istream<_Istream>,
+         __is_extractable<
+    __rvalue_istream_type<_Istream>,
+    _Tp&&>>::value,
+         __rvalue_istream_type<_Istream>>::type
+    operator>>(_Istream&& __is, _Tp&& __x)
+    {
+      __rvalue_istream_type<_Istream> __ret_is = __is;
+      __ret_is >> std::forward<_Tp>(__x);
+      return __ret_is;
+    }
+
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/istream.tcc" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/istream.tcc" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/istream.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>::sentry::
+    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      if (__in.good())
+ try
+   {
+     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;
+       }
+   }
+ catch(__cxxabiv1::__forced_unwind&)
+   {
+     __in._M_setstate(ios_base::badbit);
+     throw;
+   }
+ catch(...)
+   { __in._M_setstate(ios_base::badbit); }
+
+      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();
+# 521 "/usr/include/c++/10.2.0/bits/istream.tcc" 3
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+       if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n, int_type __delim)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof)
+    && !traits_type::eq_int_type(__c, __delim))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof)
+        && !traits_type::eq_int_type(__c, __delim))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+       else if (traits_type::eq_int_type(__c, __delim))
+  {
+    if (_M_gcount
+        < __gnu_cxx::__numeric_traits<streamsize>::__max)
+      ++_M_gcount;
+    __sb->sbumpc();
+  }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    peek(void)
+    {
+      int_type __c = traits_type::eof();
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __c = this->rdbuf()->sgetc();
+       if (traits_type::eq_int_type(__c, traits_type::eof()))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __c;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    read(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       _M_gcount = this->rdbuf()->sgetn(__s, __n);
+       if (_M_gcount != __n)
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_istream<_CharT, _Traits>::
+    readsome(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+
+       const streamsize __num = this->rdbuf()->in_avail();
+       if (__num > 0)
+  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
+       else if (__num == -1)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return _M_gcount;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    putback(char_type __c)
+    {
+
+
+      _M_gcount = 0;
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    unget(void)
+    {
+
+
+      _M_gcount = 0;
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sungetc(), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    int
+    basic_istream<_CharT, _Traits>::
+    sync(void)
+    {
+
+
+      int __ret = -1;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __streambuf_type* __sb = this->rdbuf();
+       if (__sb)
+  {
+    if (__sb->pubsync() == -1)
+      __err |= ios_base::badbit;
+    else
+      __ret = 0;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::pos_type
+    basic_istream<_CharT, _Traits>::
+    tellg(void)
+    {
+
+
+      pos_type __ret = pos_type(-1);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       if (!this->fail())
+  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
+        ios_base::in);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(pos_type __pos)
+    {
+
+
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+
+    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+         ios_base::in);
+
+
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(off_type __off, ios_base::seekdir __dir)
+    {
+
+
+
+      this->clear(this->rdstate() & ~ios_base::eofbit);
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       if (!this->fail())
+  {
+
+    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+         ios_base::in);
+
+
+    if (__p == pos_type(off_type(-1)))
+      __err |= ios_base::failbit;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::int_type __int_type;
+
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const __int_type __cb = __in.rdbuf()->sbumpc();
+       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
+  __c = _Traits::to_char_type(__cb);
+       else
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+   if (__err)
+     __in.setstate(__err);
+ }
+      return __in;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename _Traits::int_type int_type;
+      typedef _CharT char_type;
+      typedef ctype<_CharT> __ctype_type;
+
+      streamsize __extracted = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+
+       streamsize __num = __in.width();
+       if (__num <= 0)
+  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+
+       const int_type __eof = _Traits::eof();
+       __streambuf_type* __sb = __in.rdbuf();
+       int_type __c = __sb->sgetc();
+
+       while (__extracted < __num - 1
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    *__s++ = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __sb->snextc();
+  }
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+
+
+
+       *__s = char_type();
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+ }
+      if (!__extracted)
+ __err |= ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __in)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename __istream_type::int_type __int_type;
+      typedef ctype<_CharT> __ctype_type;
+
+      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+      const __int_type __eof = _Traits::eof();
+      __streambuf_type* __sb = __in.rdbuf();
+      __int_type __c = __sb->sgetc();
+
+      while (!_Traits::eq_int_type(__c, __eof)
+      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
+ __c = __sb->snextc();
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __in.setstate(ios_base::eofbit);
+      return __in;
+    }
+
+
+
+
+  extern template class basic_istream<char>;
+  extern template istream& ws(istream&);
+  extern template istream& operator>>(istream&, char&);
+  extern template istream& operator>>(istream&, char*);
+  extern template istream& operator>>(istream&, unsigned char&);
+  extern template istream& operator>>(istream&, signed char&);
+  extern template istream& operator>>(istream&, unsigned char*);
+  extern template istream& operator>>(istream&, signed char*);
+
+  extern template istream& istream::_M_extract(unsigned short&);
+  extern template istream& istream::_M_extract(unsigned int&);
+  extern template istream& istream::_M_extract(long&);
+  extern template istream& istream::_M_extract(unsigned long&);
+  extern template istream& istream::_M_extract(bool&);
+
+  extern template istream& istream::_M_extract(long long&);
+  extern template istream& istream::_M_extract(unsigned long long&);
+
+  extern template istream& istream::_M_extract(float&);
+  extern template istream& istream::_M_extract(double&);
+  extern template istream& istream::_M_extract(long double&);
+  extern template istream& istream::_M_extract(void*&);
+
+  extern template class basic_iostream<char>;
+
+
+  extern template class basic_istream<wchar_t>;
+  extern template wistream& ws(wistream&);
+  extern template wistream& operator>>(wistream&, wchar_t&);
+  extern template wistream& operator>>(wistream&, wchar_t*);
+
+  extern template wistream& wistream::_M_extract(unsigned short&);
+  extern template wistream& wistream::_M_extract(unsigned int&);
+  extern template wistream& wistream::_M_extract(long&);
+  extern template wistream& wistream::_M_extract(unsigned long&);
+  extern template wistream& wistream::_M_extract(bool&);
+
+  extern template wistream& wistream::_M_extract(long long&);
+  extern template wistream& wistream::_M_extract(unsigned long long&);
+
+  extern template wistream& wistream::_M_extract(float&);
+  extern template wistream& wistream::_M_extract(double&);
+  extern template wistream& wistream::_M_extract(long double&);
+  extern template wistream& wistream::_M_extract(void*&);
+
+  extern template class basic_iostream<wchar_t>;
+
+
+
+
+}
+# 992 "/usr/include/c++/10.2.0/istream" 2 3
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/IStream.hpp" 2
+# 28 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/IStream.hpp"
+
+# 28 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/../core/IStream.hpp"
+namespace OpenRCT2
+{
+    enum
+    {
+        STREAM_SEEK_BEGIN,
+        STREAM_SEEK_CURRENT,
+        STREAM_SEEK_END
+    };
+
+
+
+
+
+    struct IStream
+    {
+
+
+
+        virtual ~IStream()
+        {
+        }
+
+        virtual bool CanRead() const = 0;
+        virtual bool CanWrite() const = 0;
+
+        virtual uint64_t GetLength() const = 0;
+        virtual uint64_t GetPosition() const = 0;
+        virtual void SetPosition(uint64_t position) = 0;
+        virtual void Seek(int64_t offset, int32_t origin) = 0;
+
+        virtual void Read(void* buffer, uint64_t length) = 0;
+        virtual void Write(const void* buffer, uint64_t length) = 0;
+
+        virtual uint64_t TryRead(void* buffer, uint64_t length) = 0;
+
+        virtual const void* GetData() const = 0;
+
+
+
+
+        virtual void Read1(void* buffer)
+        {
+            Read(buffer, 1);
+        }
+        virtual void Read2(void* buffer)
+        {
+            Read(buffer, 2);
+        }
+        virtual void Read4(void* buffer)
+        {
+            Read(buffer, 4);
+        }
+        virtual void Read8(void* buffer)
+        {
+            Read(buffer, 8);
+        }
+        virtual void Read16(void* buffer)
+        {
+            Read(buffer, 16);
+        }
+
+        virtual void Write1(const void* buffer)
+        {
+            Write(buffer, 1);
+        }
+        virtual void Write2(const void* buffer)
+        {
+            Write(buffer, 2);
+        }
+        virtual void Write4(const void* buffer)
+        {
+            Write(buffer, 4);
+        }
+        virtual void Write8(const void* buffer)
+        {
+            Write(buffer, 8);
+        }
+        virtual void Write16(const void* buffer)
+        {
+            Write(buffer, 16);
+        }
+
+
+
+
+
+
+
+        template<typename T> void Read(T* value)
+        {
+
+            if constexpr (sizeof(T) == 1)
+            {
+                Read1(value);
+            }
+            else if constexpr (sizeof(T) == 2)
+            {
+                Read2(value);
+            }
+            else if constexpr (sizeof(T) == 4)
+            {
+                Read4(value);
+            }
+            else if constexpr (sizeof(T) == 8)
+            {
+                Read8(value);
+            }
+            else if constexpr (sizeof(T) == 16)
+            {
+                Read16(value);
+            }
+            else
+            {
+                Read(value, sizeof(T));
+            }
+        }
+
+
+
+
+        template<typename T> void Write(const T* value)
+        {
+
+            if constexpr (sizeof(T) == 1)
+            {
+                Write1(value);
+            }
+            else if constexpr (sizeof(T) == 2)
+            {
+                Write2(value);
+            }
+            else if constexpr (sizeof(T) == 4)
+            {
+                Write4(value);
+            }
+            else if constexpr (sizeof(T) == 8)
+            {
+                Write8(value);
+            }
+            else if constexpr (sizeof(T) == 16)
+            {
+                Write16(value);
+            }
+            else
+            {
+                Write(value, sizeof(T));
+            }
+        }
+
+
+
+
+        template<typename T> T ReadValue()
+        {
+            T buffer;
+            Read(&buffer);
+            return buffer;
+        }
+
+
+
+
+        template<typename T> void WriteValue(const T value)
+        {
+            Write(&value);
+        }
+
+        template<typename T> std::unique_ptr<T[]> ReadArray(size_t count)
+        {
+            auto buffer = std::make_unique<T[]>(count);
+            Read(buffer.get(), sizeof(T) * count);
+            return buffer;
+        }
+
+        template<typename T> void WriteArray(T* buffer, size_t count)
+        {
+            Write(buffer, sizeof(T) * count);
+        }
+
+        utf8* ReadString();
+        std::string ReadStdString();
+        void WriteString(const utf8* str);
+        void WriteString(const std::string& string);
+    };
+
+}
+
+
+
+
+
+class IOException : public std::runtime_error
+{
+public:
+    explicit IOException(const std::string& message)
+        : std::runtime_error(message)
+    {
+    }
+};
+
+template<typename T> class ivstream : public std::istream
+{
+private:
+    class vector_streambuf : public std::basic_streambuf<char, std::char_traits<char>>
+    {
+    public:
+        explicit vector_streambuf(const std::vector<T>& vec)
+        {
+            this->setg(
+                reinterpret_cast<char*>(const_cast<unsigned char*>(vec.data())),
+                reinterpret_cast<char*>(const_cast<unsigned char*>(vec.data())),
+                reinterpret_cast<char*>(const_cast<unsigned char*>(vec.data() + vec.size())));
+        }
+    };
+
+    vector_streambuf _streambuf;
+
+public:
+    ivstream(const std::vector<T>& vec)
+        : std::istream(&_streambuf)
+        , _streambuf(vec)
+    {
+    }
+};
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/AudioMixer.h" 2
+
+
+
+
+
+
+
+namespace OpenRCT2::Audio
+{
+    enum class SoundId : uint8_t;
+
+    enum class MixerGroup : int32_t
+    {
+        Sound,
+        RideMusic,
+        TitleMusic,
+    };
+
+    struct IAudioSource;
+    struct IAudioChannel;
+
+
+
+
+    struct IAudioMixer
+    {
+        virtual ~IAudioMixer() = default;
+
+        virtual void Init(const char* device) = 0;
+        virtual void Close() = 0;
+        virtual void Lock() = 0;
+        virtual void Unlock() = 0;
+        virtual IAudioChannel* Play(IAudioSource* source, int32_t loop, bool deleteondone, bool deletesourceondone) = 0;
+        virtual void Stop(IAudioChannel* channel) = 0;
+        virtual bool LoadMusic(size_t pathid) = 0;
+        virtual void SetVolume(float volume) = 0;
+
+        virtual IAudioSource* GetSoundSource(SoundId id) = 0;
+        virtual IAudioSource* GetMusicSource(int32_t id) = 0;
+    };
+}
+# 63 "/home/ted/dev/openrct2/src/openrct2/object/../ride/../audio/AudioMixer.h"
+void Mixer_Init(const char* device);
+void* Mixer_Play_Effect(
+    OpenRCT2::Audio::SoundId id, int32_t loop, int32_t volume, float pan, double rate, int32_t deleteondone);
+void Mixer_Stop_Channel(void* channel);
+void Mixer_Channel_Volume(void* channel, int32_t volume);
+void Mixer_Channel_Pan(void* channel, float pan);
+void Mixer_Channel_Rate(void* channel, double rate);
+int32_t Mixer_Channel_IsPlaying(void* channel);
+uint64_t Mixer_Channel_GetOffset(void* channel);
+int32_t Mixer_Channel_SetOffset(void* channel, uint64_t offset);
+void Mixer_Channel_SetGroup(void* channel, OpenRCT2::Audio::MixerGroup group);
+void* Mixer_Play_Music(int32_t pathId, int32_t loop, int32_t streaming);
+void* Mixer_Play_Music(const char* path, int32_t loop);
+void* Mixer_Play_Music(std::unique_ptr<OpenRCT2::IStream> stream, int32_t loop);
+void Mixer_SetVolume(float volume);
+
+int32_t DStoMixerVolume(int32_t volume);
+float DStoMixerPan(int32_t pan);
+double DStoMixerRate(int32_t frequency);
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../ride/VehicleEntry.h" 2
+# 25 "/home/ted/dev/openrct2/src/openrct2/object/../ride/VehicleEntry.h"
+struct rct_ride_entry_vehicle
+{
+    uint16_t rotation_frame_mask;
+    uint8_t num_vertical_frames;
+
+    uint8_t num_horizontal_frames;
+
+    uint32_t spacing;
+    uint16_t car_mass;
+    int8_t tab_height;
+    uint8_t num_seats;
+    uint16_t sprite_flags;
+    uint8_t sprite_width;
+    uint8_t sprite_height_negative;
+    uint8_t sprite_height_positive;
+    uint8_t animation;
+    uint32_t flags;
+    uint16_t base_num_frames;
+    uint32_t base_image_id;
+    uint32_t restraint_image_id;
+    uint32_t gentle_slope_image_id;
+    uint32_t steep_slope_image_id;
+    uint32_t vertical_slope_image_id;
+    uint32_t diagonal_slope_image_id;
+    uint32_t banked_image_id;
+    uint32_t inline_twist_image_id;
+    uint32_t flat_to_gentle_bank_image_id;
+    uint32_t diagonal_to_gentle_slope_bank_image_id;
+    uint32_t gentle_slope_to_bank_image_id;
+    uint32_t gentle_slope_bank_turn_image_id;
+    uint32_t flat_bank_to_gentle_slope_image_id;
+    union
+    {
+        uint32_t curved_lift_hill_image_id;
+        uint32_t corkscrew_image_id;
+    };
+    uint32_t no_vehicle_images;
+    uint8_t no_seating_rows;
+    uint8_t spinning_inertia;
+    uint8_t spinning_friction;
+    OpenRCT2::Audio::SoundId friction_sound_id;
+    uint8_t log_flume_reverser_vehicle_type;
+    uint8_t sound_range;
+    uint8_t
+        double_sound_frequency;
+    uint8_t powered_acceleration;
+    uint8_t powered_max_speed;
+    uint8_t car_visual;
+    uint8_t effect_visual;
+    uint8_t draw_order;
+    uint8_t num_vertical_frames_override;
+
+    uint8_t peep_loading_waypoint_segments;
+    uint8_t pad_62[6] = {};
+    std::vector<std::array<CoordsXY, 3>> peep_loading_waypoints = {};
+    std::vector<int8_t> peep_loading_positions = {};
+};
+
+
+
+
+
+
+static_assert(sizeof(rct_ride_entry_vehicle) % 8 == 0, "Invalid struct size");
+# 22 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h" 2
+
+
+
+
+struct IObjectManager;
+class Formatter;
+class StationObject;
+struct Peep;
+struct Ride;
+struct RideTypeDescriptor;
+struct Staff;
+struct Vehicle;
+# 50 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h"
+constexpr uint16_t const MAX_STATION_LOCATIONS = 255 * 2;
+constexpr uint16_t const MAX_INVERSIONS = RCT12_MAX_INVERSIONS;
+constexpr uint16_t const MAX_GOLF_HOLES = RCT12_MAX_GOLF_HOLES;
+constexpr uint16_t const MAX_HELICES = RCT12_MAX_HELICES;
+
+constexpr uint16_t const MAZE_CLEARANCE_HEIGHT = 4 * COORDS_Z_STEP;
+
+constexpr const uint8_t NUM_SHOP_ITEMS_PER_RIDE = 2;
+
+#pragma pack(push, 1)
+struct TrackColour
+{
+    uint8_t main;
+    uint8_t additional;
+    uint8_t supports;
+};
+static_assert(sizeof(TrackColour) == (3), "Improper struct size");
+
+struct vehicle_colour
+{
+    uint8_t main;
+    uint8_t additional_1;
+    uint8_t additional_2;
+};
+static_assert(sizeof(vehicle_colour) == (3), "Improper struct size");
+
+struct track_colour_preset_list
+{
+    uint8_t count;
+    TrackColour list[256];
+};
+static_assert(sizeof(track_colour_preset_list) == ((1 + 256 * 3)), "Improper struct size");
+
+struct vehicle_colour_preset_list
+{
+    uint8_t count;
+    vehicle_colour list[256];
+};
+static_assert(sizeof(vehicle_colour_preset_list) == ((1 + 256 * 3)), "Improper struct size");
+
+struct RideNaming
+{
+    rct_string_id Name;
+    rct_string_id Description;
+};
+static_assert(sizeof(RideNaming) == (4), "Improper struct size");
+
+#pragma pack(pop)
+
+
+
+
+struct rct_ride_entry
+{
+    RideNaming naming;
+
+    uint32_t images_offset;
+    uint32_t flags;
+    uint8_t ride_type[RCT2_MAX_RIDE_TYPES_PER_RIDE_ENTRY];
+    uint8_t min_cars_in_train;
+    uint8_t max_cars_in_train;
+    uint8_t cars_per_flat_ride;
+
+    uint8_t zero_cars;
+
+    uint8_t tab_vehicle;
+    uint8_t default_vehicle;
+
+    uint8_t front_vehicle;
+    uint8_t second_vehicle;
+    uint8_t rear_vehicle;
+    uint8_t third_vehicle;
+    uint8_t BuildMenuPriority;
+    rct_ride_entry_vehicle vehicles[RCT2_MAX_VEHICLES_PER_RIDE_ENTRY];
+    vehicle_colour_preset_list* vehicle_preset_list;
+    int8_t excitement_multiplier;
+    int8_t intensity_multiplier;
+    int8_t nausea_multiplier;
+    uint8_t max_height;
+    ShopItem shop_item[NUM_SHOP_ITEMS_PER_RIDE];
+    rct_string_id capacity;
+    void* obj;
+
+    const rct_ride_entry_vehicle* GetVehicle(size_t id) const
+    {
+        if (id < std::size(vehicles))
+        {
+            return &vehicles[id];
+        }
+        return nullptr;
+    }
+
+    const rct_ride_entry_vehicle* GetDefaultVehicle() const
+    {
+        return GetVehicle(default_vehicle);
+    }
+};
+
+struct RideStation
+{
+    CoordsXY Start;
+    uint8_t Height;
+    uint8_t Length;
+    uint8_t Depart;
+    uint8_t TrainAtStation;
+    TileCoordsXYZD Entrance;
+    TileCoordsXYZD Exit;
+    int32_t SegmentLength;
+    uint16_t SegmentTime;
+    uint8_t QueueTime;
+    uint16_t QueueLength;
+    uint16_t LastPeepInQueue;
+
+    static constexpr uint8_t NO_TRAIN = std::numeric_limits<uint8_t>::max();
+
+    int32_t GetBaseZ() const;
+    void SetBaseZ(int32_t newZ);
+    CoordsXYZ GetStart() const;
+};
+
+struct RideMeasurement
+{
+    static constexpr size_t MAX_ITEMS = 4800;
+
+    uint8_t flags{};
+    uint32_t last_use_tick{};
+    uint16_t num_items{};
+    uint16_t current_item{};
+    uint8_t vehicle_index{};
+    StationIndex current_station{};
+    int8_t vertical[MAX_ITEMS]{};
+    int8_t lateral[MAX_ITEMS]{};
+    uint8_t velocity[MAX_ITEMS]{};
+    uint8_t altitude[MAX_ITEMS]{};
+};
+
+enum class RideClassification
+{
+    Ride,
+    ShopOrStall,
+    KioskOrFacility
+};
+
+struct TrackDesign;
+enum class RideMode : uint8_t;
+
+
+
+
+
+
+
+struct Ride
+{
+    ride_id_t id = RIDE_ID_NULL;
+    uint8_t type = 255;
+
+
+    ObjectEntryIndex subtype;
+    RideMode mode;
+    uint8_t colour_scheme_type;
+    VehicleColour vehicle_colours[255];
+
+    uint8_t status;
+    std::string custom_name;
+    uint16_t default_name_number;
+    CoordsXY overall_view;
+    uint16_t vehicles[31 + 1];
+    uint8_t depart_flags;
+    uint8_t num_stations;
+    uint8_t num_vehicles;
+    uint8_t num_cars_per_train;
+    uint8_t proposed_num_vehicles;
+    uint8_t proposed_num_cars_per_train;
+    uint8_t max_trains;
+
+public:
+    uint8_t min_max_cars_per_train;
+
+public:
+    uint8_t min_waiting_time;
+    uint8_t max_waiting_time;
+    union
+    {
+        uint8_t operation_option;
+        uint8_t time_limit;
+        uint8_t num_laps;
+        uint8_t launch_speed;
+        uint8_t speed;
+        uint8_t rotations;
+    };
+
+    uint8_t boat_hire_return_direction;
+    TileCoordsXY boat_hire_return_position;
+
+
+
+
+    uint8_t special_track_elements;
+
+
+    int32_t max_speed;
+    int32_t average_speed;
+    uint8_t current_test_segment;
+    uint8_t average_speed_test_timeout;
+    fixed16_2dp max_positive_vertical_g;
+    fixed16_2dp max_negative_vertical_g;
+    fixed16_2dp max_lateral_g;
+    fixed16_2dp previous_vertical_g;
+    fixed16_2dp previous_lateral_g;
+    uint32_t testing_flags;
+
+
+    TileCoordsXYZ CurTestTrackLocation;
+
+    uint16_t turn_count_default;
+    uint16_t turn_count_banked;
+    uint16_t turn_count_sloped;
+
+    uint8_t drops;
+    uint8_t start_drop_height;
+    uint8_t highest_drop_height;
+    int32_t sheltered_length;
+
+    uint16_t var_11C;
+    uint8_t num_sheltered_sections;
+
+    uint16_t cur_num_customers;
+
+    uint16_t num_customers_timeout;
+
+    uint16_t num_customers[10];
+    money16 price[NUM_SHOP_ITEMS_PER_RIDE];
+    TileCoordsXYZ ChairliftBullwheelLocation[2];
+    union
+    {
+        RatingTuple ratings;
+        struct
+        {
+            ride_rating excitement;
+            ride_rating intensity;
+            ride_rating nausea;
+        };
+    };
+    uint16_t value;
+    uint16_t chairlift_bullwheel_rotation;
+    uint8_t satisfaction;
+    uint8_t satisfaction_time_out;
+    uint8_t satisfaction_next;
+
+    uint8_t window_invalidate_flags;
+    uint32_t total_customers;
+    money32 total_profit;
+    uint8_t popularity;
+    uint8_t popularity_time_out;
+    uint8_t popularity_next;
+    uint16_t num_riders;
+    uint8_t music_tune_id;
+    uint8_t slide_in_use;
+    union
+    {
+        uint16_t slide_peep;
+        uint16_t maze_tiles;
+    };
+    uint8_t slide_peep_t_shirt_colour;
+    uint8_t spiral_slide_progress;
+    int32_t build_date;
+    money16 upkeep_cost;
+    uint16_t race_winner;
+    uint32_t music_position;
+    uint8_t breakdown_reason_pending;
+    uint8_t mechanic_status;
+    uint16_t mechanic;
+    StationIndex inspection_station;
+    uint8_t broken_vehicle;
+    uint8_t broken_car;
+    uint8_t breakdown_reason;
+    union
+    {
+        struct
+        {
+            uint8_t reliability_subvalue;
+            uint8_t reliability_percentage;
+        };
+        uint16_t reliability;
+    };
+
+
+    uint8_t unreliability_factor;
+
+    uint8_t downtime;
+    uint8_t inspection_interval;
+    uint8_t last_inspection;
+    uint8_t downtime_history[8];
+    uint32_t no_primary_items_sold;
+    uint32_t no_secondary_items_sold;
+    uint8_t breakdown_sound_modifier;
+
+
+    uint8_t not_fixed_timeout;
+    uint8_t last_crash_type;
+    uint8_t connected_message_throttle;
+    money32 income_per_hour;
+    money32 profit;
+    TrackColour track_colour[4];
+    uint8_t music;
+    uint8_t entrance_style;
+    uint16_t vehicle_change_timeout;
+    uint8_t num_block_brakes;
+    uint8_t lift_hill_speed;
+    uint16_t guests_favourite;
+    uint32_t lifecycle_flags;
+    uint16_t total_air_time;
+    StationIndex current_test_station;
+    uint8_t num_circuits;
+    CoordsXYZ CableLiftLoc;
+    uint16_t cable_lift;
+
+
+
+    uint8_t current_issues;
+    uint32_t last_issue_time;
+    RideStation stations[255];
+    uint16_t inversions;
+    uint16_t holes;
+    uint8_t sheltered_eighths;
+
+    std::unique_ptr<RideMeasurement> measurement;
+
+private:
+    void Update();
+    void UpdateChairlift();
+    void UpdateSpiralSlide();
+    void UpdateQueueLength(StationIndex stationIndex);
+    bool CreateVehicles(const CoordsXYE& element, bool isApplying);
+    void MoveTrainsToBlockBrakes(TrackElement* firstBlock);
+    money32 CalculateIncomePerHour() const;
+    void ChainQueues() const;
+    void ConstructMissingEntranceOrExit() const;
+
+public:
+    bool CanBreakDown() const;
+    RideClassification GetClassification() const;
+    bool IsRide() const;
+    void Renew();
+    void Delete();
+    void Crash(uint8_t vehicleIndex);
+    void SetToDefaultInspectionInterval();
+    void SetRideEntry(int32_t rideEntry);
+
+    void SetNumVehicles(int32_t numVehicles);
+    void SetNumCarsPerVehicle(int32_t numCarsPerVehicle);
+    void UpdateMaxVehicles();
+    void UpdateNumberOfCircuits();
+
+    bool HasSpinningTunnel() const;
+    bool HasWaterSplash() const;
+    bool HasRapids() const;
+    bool HasLogReverser() const;
+    bool HasWaterfall() const;
+    bool HasWhirlpool() const;
+
+    bool IsPoweredLaunched() const;
+    bool IsBlockSectioned() const;
+    bool CanHaveMultipleCircuits() const;
+    bool SupportsStatus(int32_t s) const;
+
+    void StopGuestsQueuing();
+
+    bool Open(bool isApplying);
+    bool Test(int32_t newStatus, bool isApplying);
+
+    RideMode GetDefaultMode() const;
+
+    void SetColourPreset(uint8_t index);
+
+    rct_ride_entry* GetRideEntry() const;
+
+    size_t GetNumPrices() const;
+    int32_t GetAge() const;
+    int32_t GetTotalQueueLength() const;
+    int32_t GetMaxQueueTime() const;
+
+    void QueueInsertGuestAtFront(StationIndex stationIndex, Peep* peep);
+    Peep* GetQueueHeadGuest(StationIndex stationIndex) const;
+
+    void SetNameToDefault();
+    std::string GetName() const;
+    void FormatNameTo(Formatter&) const;
+    void FormatStatusTo(Formatter&) const;
+
+    static void UpdateAll();
+    static bool NameExists(std::string_view name, ride_id_t excludeRideId = RIDE_ID_NULL);
+
+    std::unique_ptr<TrackDesign> SaveToTrackDesign() const;
+
+    uint64_t GetAvailableModes() const;
+    const RideTypeDescriptor& GetRideTypeDescriptor() const;
+    TrackElement* GetOriginElement(StationIndex stationIndex) const;
+
+    std::pair<RideMeasurement*, OpenRCT2String> GetMeasurement();
+
+    uint8_t GetMinCarsPerTrain() const;
+    uint8_t GetMaxCarsPerTrain() const;
+    void SetMinCarsPerTrain(uint8_t newValue);
+    void SetMaxCarsPerTrain(uint8_t newValue);
+};
+
+#pragma pack(push, 1)
+
+struct track_begin_end
+{
+    int32_t begin_x;
+    int32_t begin_y;
+    int32_t begin_z;
+    int32_t begin_direction;
+    TileElement* begin_element;
+    int32_t end_x;
+    int32_t end_y;
+    int32_t end_direction;
+    TileElement* end_element;
+};
+
+
+
+
+struct ride_name_args
+{
+    uint16_t type_name;
+    uint16_t number;
+};
+static_assert(sizeof(ride_name_args) == (4), "Improper struct size");
+
+#pragma pack(pop)
+
+
+enum
+{
+    RIDE_LIFECYCLE_ON_TRACK = 1 << 0,
+    RIDE_LIFECYCLE_TESTED = 1 << 1,
+    RIDE_LIFECYCLE_TEST_IN_PROGRESS = 1 << 2,
+    RIDE_LIFECYCLE_NO_RAW_STATS = 1 << 3,
+    RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING = 1 << 4,
+    RIDE_LIFECYCLE_ON_RIDE_PHOTO = 1 << 5,
+    RIDE_LIFECYCLE_BREAKDOWN_PENDING = 1 << 6,
+    RIDE_LIFECYCLE_BROKEN_DOWN = 1 << 7,
+    RIDE_LIFECYCLE_DUE_INSPECTION = 1 << 8,
+    RIDE_LIFECYCLE_QUEUE_FULL = 1 << 9,
+    RIDE_LIFECYCLE_CRASHED = 1 << 10,
+    RIDE_LIFECYCLE_HAS_STALLED_VEHICLE = 1 << 11,
+    RIDE_LIFECYCLE_EVER_BEEN_OPENED = 1 << 12,
+    RIDE_LIFECYCLE_MUSIC = 1 << 13,
+    RIDE_LIFECYCLE_INDESTRUCTIBLE = 1 << 14,
+    RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK = 1 << 15,
+    RIDE_LIFECYCLE_CABLE_LIFT_HILL_COMPONENT_USED = 1 << 16,
+    RIDE_LIFECYCLE_CABLE_LIFT = 1 << 17,
+    RIDE_LIFECYCLE_NOT_CUSTOM_DESIGN = 1 << 18,
+    RIDE_LIFECYCLE_SIX_FLAGS_DEPRECATED = 1 << 19,
+    RIDE_LIFECYCLE_FIXED_RATINGS = 1 << 20,
+};
+
+
+enum
+{
+    RIDE_ENTRY_FLAG_VEHICLE_TAB_SCALE_HALF = 1 << 0,
+    RIDE_ENTRY_FLAG_NO_INVERSIONS = 1 << 1,
+    RIDE_ENTRY_FLAG_NO_BANKED_TRACK = 1 << 2,
+    RIDE_ENTRY_FLAG_PLAY_DEPART_SOUND = 1 << 3,
+    RIDE_ENTRY_FLAG_ALTERNATIVE_SWING_MODE_1 = 1 << 4,
+
+    RIDE_ENTRY_FLAG_ALTERNATIVE_ROTATION_MODE_1 = 1 << 5,
+
+    RIDE_ENTRY_FLAG_ALTERNATIVE_ROTATION_MODE_2 = 1 << 6,
+    RIDE_ENTRY_FLAG_DISABLE_WANDERING_DEPRECATED = 1 << 7,
+    RIDE_ENTRY_FLAG_PLAY_SPLASH_SOUND = 1 << 8,
+    RIDE_ENTRY_FLAG_PLAY_SPLASH_SOUND_SLIDE = 1 << 9,
+    RIDE_ENTRY_FLAG_COVERED_RIDE = 1 << 10,
+    RIDE_ENTRY_FLAG_LIMIT_AIRTIME_BONUS = 1 << 11,
+    RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME_DEPRECATED = 1 << 12,
+    RIDE_ENTRY_FLAG_SEPARATE_RIDE_DEPRECATED = 1 << 13,
+    RIDE_ENTRY_FLAG_CANNOT_BREAK_DOWN = 1 << 14,
+    RIDE_ENTRY_DISABLE_LAST_OPERATING_MODE_DEPRECATED = 1 << 15,
+    RIDE_ENTRY_FLAG_DISABLE_DOOR_CONSTRUCTION_DEPRECATED = 1 << 16,
+    RIDE_ENTRY_DISABLE_FIRST_TWO_OPERATING_MODES_DEPRECATED = 1 << 17,
+    RIDE_ENTRY_FLAG_DISABLE_COLLISION_CRASHES = 1 << 18,
+    RIDE_ENTRY_FLAG_DISABLE_COLOUR_TAB = 1 << 19,
+
+    RIDE_ENTRY_FLAG_ALTERNATIVE_SWING_MODE_2 = 1 << 20,
+};
+
+enum
+{
+    RIDE_TESTING_SHELTERED = (1 << 0),
+    RIDE_TESTING_TURN_LEFT = (1 << 1),
+    RIDE_TESTING_TURN_RIGHT = (1 << 2),
+    RIDE_TESTING_TURN_BANKED = (1 << 3),
+    RIDE_TESTING_TURN_SLOPED = (1 << 4),
+    RIDE_TESTING_DROP_DOWN = (1 << 5),
+    RIDE_TESTING_POWERED_LIFT = (1 << 6),
+    RIDE_TESTING_DROP_UP = (1 << 7),
+};
+
+enum
+{
+    RIDE_TYPE_SPIRAL_ROLLER_COASTER = 0,
+    RIDE_TYPE_STAND_UP_ROLLER_COASTER,
+    RIDE_TYPE_SUSPENDED_SWINGING_COASTER,
+    RIDE_TYPE_INVERTED_ROLLER_COASTER,
+    RIDE_TYPE_JUNIOR_ROLLER_COASTER,
+    RIDE_TYPE_MINIATURE_RAILWAY,
+    RIDE_TYPE_MONORAIL,
+    RIDE_TYPE_MINI_SUSPENDED_COASTER,
+    RIDE_TYPE_BOAT_HIRE,
+    RIDE_TYPE_WOODEN_WILD_MOUSE,
+    RIDE_TYPE_STEEPLECHASE = 10,
+    RIDE_TYPE_CAR_RIDE,
+    RIDE_TYPE_LAUNCHED_FREEFALL,
+    RIDE_TYPE_BOBSLEIGH_COASTER,
+    RIDE_TYPE_OBSERVATION_TOWER,
+    RIDE_TYPE_LOOPING_ROLLER_COASTER,
+    RIDE_TYPE_DINGHY_SLIDE,
+    RIDE_TYPE_MINE_TRAIN_COASTER,
+    RIDE_TYPE_CHAIRLIFT,
+    RIDE_TYPE_CORKSCREW_ROLLER_COASTER,
+    RIDE_TYPE_MAZE = 20,
+    RIDE_TYPE_SPIRAL_SLIDE,
+    RIDE_TYPE_GO_KARTS,
+    RIDE_TYPE_LOG_FLUME,
+    RIDE_TYPE_RIVER_RAPIDS,
+    RIDE_TYPE_DODGEMS,
+    RIDE_TYPE_SWINGING_SHIP,
+    RIDE_TYPE_SWINGING_INVERTER_SHIP,
+    RIDE_TYPE_FOOD_STALL,
+    RIDE_TYPE_1D,
+    RIDE_TYPE_DRINK_STALL = 30,
+    RIDE_TYPE_1F,
+    RIDE_TYPE_SHOP,
+    RIDE_TYPE_MERRY_GO_ROUND,
+    RIDE_TYPE_22,
+    RIDE_TYPE_INFORMATION_KIOSK,
+    RIDE_TYPE_TOILETS,
+    RIDE_TYPE_FERRIS_WHEEL,
+    RIDE_TYPE_MOTION_SIMULATOR,
+    RIDE_TYPE_3D_CINEMA,
+    RIDE_TYPE_TOP_SPIN = 40,
+    RIDE_TYPE_SPACE_RINGS,
+    RIDE_TYPE_REVERSE_FREEFALL_COASTER,
+    RIDE_TYPE_LIFT,
+    RIDE_TYPE_VERTICAL_DROP_ROLLER_COASTER,
+    RIDE_TYPE_CASH_MACHINE,
+    RIDE_TYPE_TWIST,
+    RIDE_TYPE_HAUNTED_HOUSE,
+    RIDE_TYPE_FIRST_AID,
+    RIDE_TYPE_CIRCUS,
+    RIDE_TYPE_GHOST_TRAIN = 50,
+    RIDE_TYPE_TWISTER_ROLLER_COASTER,
+    RIDE_TYPE_WOODEN_ROLLER_COASTER,
+    RIDE_TYPE_SIDE_FRICTION_ROLLER_COASTER,
+    RIDE_TYPE_STEEL_WILD_MOUSE,
+    RIDE_TYPE_MULTI_DIMENSION_ROLLER_COASTER,
+    RIDE_TYPE_MULTI_DIMENSION_ROLLER_COASTER_ALT,
+    RIDE_TYPE_FLYING_ROLLER_COASTER,
+    RIDE_TYPE_FLYING_ROLLER_COASTER_ALT,
+    RIDE_TYPE_VIRGINIA_REEL,
+    RIDE_TYPE_SPLASH_BOATS = 60,
+    RIDE_TYPE_MINI_HELICOPTERS,
+    RIDE_TYPE_LAY_DOWN_ROLLER_COASTER,
+    RIDE_TYPE_SUSPENDED_MONORAIL,
+    RIDE_TYPE_LAY_DOWN_ROLLER_COASTER_ALT,
+    RIDE_TYPE_REVERSER_ROLLER_COASTER,
+    RIDE_TYPE_HEARTLINE_TWISTER_COASTER,
+    RIDE_TYPE_MINI_GOLF,
+    RIDE_TYPE_GIGA_COASTER,
+    RIDE_TYPE_ROTO_DROP,
+    RIDE_TYPE_FLYING_SAUCERS = 70,
+    RIDE_TYPE_CROOKED_HOUSE,
+    RIDE_TYPE_MONORAIL_CYCLES,
+    RIDE_TYPE_COMPACT_INVERTED_COASTER,
+    RIDE_TYPE_WATER_COASTER,
+    RIDE_TYPE_AIR_POWERED_VERTICAL_COASTER,
+    RIDE_TYPE_INVERTED_HAIRPIN_COASTER,
+    RIDE_TYPE_MAGIC_CARPET,
+    RIDE_TYPE_SUBMARINE_RIDE,
+    RIDE_TYPE_RIVER_RAFTS,
+    RIDE_TYPE_50 = 80,
+    RIDE_TYPE_ENTERPRISE,
+    RIDE_TYPE_52,
+    RIDE_TYPE_53,
+    RIDE_TYPE_54,
+    RIDE_TYPE_55,
+    RIDE_TYPE_INVERTED_IMPULSE_COASTER,
+    RIDE_TYPE_MINI_ROLLER_COASTER,
+    RIDE_TYPE_MINE_RIDE,
+    RIDE_TYPE_59,
+    RIDE_TYPE_LIM_LAUNCHED_ROLLER_COASTER = 90,
+    RIDE_TYPE_HYPERCOASTER,
+    RIDE_TYPE_HYPER_TWISTER,
+    RIDE_TYPE_MONSTER_TRUCKS,
+    RIDE_TYPE_SPINNING_WILD_MOUSE,
+    RIDE_TYPE_CLASSIC_MINI_ROLLER_COASTER,
+    RIDE_TYPE_HYBRID_COASTER,
+    RIDE_TYPE_SINGLE_RAIL_ROLLER_COASTER,
+
+    RIDE_TYPE_COUNT
+};
+
+enum
+{
+    RIDE_STATUS_CLOSED,
+    RIDE_STATUS_OPEN,
+    RIDE_STATUS_TESTING,
+    RIDE_STATUS_SIMULATING,
+    RIDE_STATUS_COUNT,
+};
+
+enum class RideMode : uint8_t
+{
+    Normal,
+    ContinuousCircuit,
+    ReverseInclineLaunchedShuttle,
+    PoweredLaunchPasstrough,
+    Shuttle,
+    BoatHire,
+    UpwardLaunch,
+    RotatingLift,
+    StationToStation,
+    SingleRidePerAdmission,
+    UnlimitedRidesPerAdmission = 10,
+    Maze,
+    Race,
+    Dodgems,
+    Swing,
+    ShopStall,
+    Rotation,
+    ForwardRotation,
+    BackwardRotation,
+    FilmAvengingAviators,
+    MouseTails3DFilm = 20,
+    SpaceRings,
+    Beginners,
+    LimPoweredLaunch,
+    FilmThrillRiders,
+    StormChasers3DFilm,
+    SpaceRaiders3DFilm,
+    Intense,
+    Berserk,
+    HauntedHouse,
+    Circus = 30,
+    DownwardLaunch,
+    CrookedHouse,
+    FreefallDrop,
+    ContinuousCircuitBlockSectioned,
+    PoweredLaunch,
+    PoweredLaunchBlockSectioned,
+
+    Count,
+    NullMode = 255,
+};
+
+RideMode& operator++(RideMode& d, int);
+
+enum
+{
+    RIDE_COLOUR_SCHEME_ALL_SAME,
+    RIDE_COLOUR_SCHEME_DIFFERENT_PER_TRAIN,
+    RIDE_COLOUR_SCHEME_DIFFERENT_PER_CAR
+};
+
+enum
+{
+    RIDE_CATEGORY_TRANSPORT,
+    RIDE_CATEGORY_GENTLE,
+    RIDE_CATEGORY_ROLLERCOASTER,
+    RIDE_CATEGORY_THRILL,
+    RIDE_CATEGORY_WATER,
+    RIDE_CATEGORY_SHOP,
+
+    RIDE_CATEGORY_NONE = 255,
+};
+
+enum
+{
+    MUSIC_STYLE_DODGEMS_BEAT,
+    MUSIC_STYLE_FAIRGROUND_ORGAN,
+    MUSIC_STYLE_ROMAN_FANFARE,
+    MUSIC_STYLE_ORIENTAL,
+    MUSIC_STYLE_MARTIAN,
+    MUSIC_STYLE_JUNGLE_DRUMS,
+    MUSIC_STYLE_EGYPTIAN,
+    MUSIC_STYLE_TOYLAND,
+    MUSIC_STYLE_CIRCUS_SHOW,
+    MUSIC_STYLE_SPACE,
+    MUSIC_STYLE_HORROR,
+    MUSIC_STYLE_TECHNO,
+    MUSIC_STYLE_GENTLE,
+    MUSIC_STYLE_SUMMER,
+    MUSIC_STYLE_WATER,
+    MUSIC_STYLE_WILD_WEST,
+    MUSIC_STYLE_JURASSIC,
+    MUSIC_STYLE_ROCK,
+    MUSIC_STYLE_RAGTIME,
+    MUSIC_STYLE_FANTASY,
+    MUSIC_STYLE_ROCK_STYLE_2,
+    MUSIC_STYLE_ICE,
+    MUSIC_STYLE_SNOW,
+    MUSIC_STYLE_CUSTOM_MUSIC_1,
+    MUSIC_STYLE_CUSTOM_MUSIC_2,
+    MUSIC_STYLE_MEDIEVAL,
+    MUSIC_STYLE_URBAN,
+    MUSIC_STYLE_ORGAN,
+    MUSIC_STYLE_MECHANICAL,
+    MUSIC_STYLE_MODERN,
+    MUSIC_STYLE_PIRATES,
+    MUSIC_STYLE_ROCK_STYLE_3,
+    MUSIC_STYLE_CANDY_STYLE,
+    MUSIC_STYLE_COUNT
+};
+
+enum
+{
+    BREAKDOWN_NONE = 255,
+    BREAKDOWN_SAFETY_CUT_OUT = 0,
+    BREAKDOWN_RESTRAINTS_STUCK_CLOSED,
+    BREAKDOWN_RESTRAINTS_STUCK_OPEN,
+    BREAKDOWN_DOORS_STUCK_CLOSED,
+    BREAKDOWN_DOORS_STUCK_OPEN,
+    BREAKDOWN_VEHICLE_MALFUNCTION,
+    BREAKDOWN_BRAKES_FAILURE,
+    BREAKDOWN_CONTROL_FAILURE,
+
+    BREAKDOWN_COUNT
+};
+
+enum
+{
+    RIDE_MECHANIC_STATUS_UNDEFINED,
+    RIDE_MECHANIC_STATUS_CALLING,
+    RIDE_MECHANIC_STATUS_HEADING,
+    RIDE_MECHANIC_STATUS_FIXING,
+    RIDE_MECHANIC_STATUS_HAS_FIXED_STATION_BRAKES
+};
+
+enum
+{
+    RIDE_DEPART_WAIT_FOR_LOAD_MASK = 7,
+    RIDE_DEPART_WAIT_FOR_LOAD = 1 << 3,
+    RIDE_DEPART_LEAVE_WHEN_ANOTHER_ARRIVES = 1 << 4,
+    RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS = 1 << 5,
+    RIDE_DEPART_WAIT_FOR_MINIMUM_LENGTH = 1 << 6,
+    RIDE_DEPART_WAIT_FOR_MAXIMUM_LENGTH = 1 << 7
+};
+
+enum
+{
+    WAIT_FOR_LOAD_QUARTER,
+    WAIT_FOR_LOAD_HALF,
+    WAIT_FOR_LOAD_THREE_QUARTER,
+    WAIT_FOR_LOAD_FULL,
+    WAIT_FOR_LOAD_ANY,
+};
+
+enum
+{
+    RIDE_COLOUR_SCHEME_MAIN,
+    RIDE_COLOUR_SCHEME_ADDITIONAL_1,
+    RIDE_COLOUR_SCHEME_ADDITIONAL_2,
+    RIDE_COLOUR_SCHEME_ADDITIONAL_3
+};
+
+enum
+{
+    VEHICLE_COLOUR_SCHEME_SAME,
+    VEHICLE_COLOUR_SCHEME_PER_TRAIN,
+    VEHICLE_COLOUR_SCHEME_PER_VEHICLE
+};
+
+enum
+{
+    RIDE_INSPECTION_EVERY_10_MINUTES,
+    RIDE_INSPECTION_EVERY_20_MINUTES,
+    RIDE_INSPECTION_EVERY_30_MINUTES,
+    RIDE_INSPECTION_EVERY_45_MINUTES,
+    RIDE_INSPECTION_EVERY_HOUR,
+    RIDE_INSPECTION_EVERY_2_HOURS,
+    RIDE_INSPECTION_NEVER
+};
+
+
+enum
+{
+    RIDE_INVALIDATE_RIDE_CUSTOMER = 1,
+    RIDE_INVALIDATE_RIDE_INCOME = 1 << 1,
+    RIDE_INVALIDATE_RIDE_MAIN = 1 << 2,
+    RIDE_INVALIDATE_RIDE_LIST = 1 << 3,
+    RIDE_INVALIDATE_RIDE_OPERATING = 1 << 4,
+    RIDE_INVALIDATE_RIDE_MAINTENANCE = 1 << 5,
+};
+
+enum
+{
+    RIDE_MEASUREMENT_FLAG_RUNNING = 1 << 0,
+    RIDE_MEASUREMENT_FLAG_UNLOADING = 1 << 1,
+    RIDE_MEASUREMENT_FLAG_G_FORCES = 1 << 2
+};
+
+
+enum
+{
+    RIDE_ELEMENT_TUNNEL_SPLASH_OR_RAPIDS = 1 << 5,
+    RIDE_ELEMENT_REVERSER_OR_WATERFALL = 1 << 6,
+    RIDE_ELEMENT_WHIRLPOOL = 1 << 7
+};
+
+enum
+{
+    RIDE_CRASH_TYPE_NONE = 0,
+    RIDE_CRASH_TYPE_NO_FATALITIES = 2,
+    RIDE_CRASH_TYPE_FATALITIES = 8
+};
+
+enum
+{
+    RIDE_CONSTRUCTION_STATE_0,
+    RIDE_CONSTRUCTION_STATE_FRONT,
+    RIDE_CONSTRUCTION_STATE_BACK,
+    RIDE_CONSTRUCTION_STATE_SELECTED,
+    RIDE_CONSTRUCTION_STATE_PLACE,
+    RIDE_CONSTRUCTION_STATE_ENTRANCE_EXIT,
+    RIDE_CONSTRUCTION_STATE_MAZE_BUILD,
+    RIDE_CONSTRUCTION_STATE_MAZE_MOVE,
+    RIDE_CONSTRUCTION_STATE_MAZE_FILL
+};
+
+enum
+{
+    RIDE_SET_VEHICLES_COMMAND_TYPE_NUM_TRAINS,
+    RIDE_SET_VEHICLES_COMMAND_TYPE_NUM_CARS_PER_TRAIN,
+    RIDE_SET_VEHICLES_COMMAND_TYPE_RIDE_ENTRY
+};
+
+enum
+{
+    RIDE_SETTING_MODE,
+    RIDE_SETTING_DEPARTURE,
+    RIDE_SETTING_MIN_WAITING_TIME,
+    RIDE_SETTING_MAX_WAITING_TIME,
+    RIDE_SETTING_OPERATION_OPTION,
+    RIDE_SETTING_INSPECTION_INTERVAL,
+    RIDE_SETTING_MUSIC,
+    RIDE_SETTING_MUSIC_TYPE,
+    RIDE_SETTING_LIFT_HILL_SPEED,
+    RIDE_SETTING_NUM_CIRCUITS,
+    RIDE_SETTING_RIDE_TYPE,
+};
+
+enum
+{
+    MAZE_WALL_TYPE_BRICK,
+    MAZE_WALL_TYPE_HEDGE,
+    MAZE_WALL_TYPE_ICE,
+    MAZE_WALL_TYPE_WOOD,
+};
+
+enum
+{
+    TRACK_SELECTION_FLAG_ARROW = 1 << 0,
+    TRACK_SELECTION_FLAG_TRACK = 1 << 1,
+    TRACK_SELECTION_FLAG_ENTRANCE_OR_EXIT = 1 << 2,
+    TRACK_SELECTION_FLAG_RECHECK = 1 << 3,
+    TRACK_SELECTION_FLAG_TRACK_PLACE_ACTION_QUEUED = 1 << 4,
+};
+
+enum
+{
+    RIDE_MODIFY_DEMOLISH,
+    RIDE_MODIFY_RENEW,
+};
+
+enum
+{
+    RIDE_ISSUE_NONE = 0,
+    RIDE_ISSUE_GUESTS_STUCK = (1 << 0),
+};
+
+enum
+{
+    TRACK_BLOCK_2 = (1 << 2)
+};
+
+enum
+{
+    TRACK_ELEMENT_SET_HIGHLIGHT_FALSE = (1 << 0),
+    TRACK_ELEMENT_SET_HIGHLIGHT_TRUE = (1 << 1),
+    TRACK_ELEMENT_SET_COLOUR_SCHEME = (1 << 2),
+    TRACK_ELEMENT_SET_HAS_CABLE_LIFT_TRUE = (1 << 3),
+    TRACK_ELEMENT_SET_HAS_CABLE_LIFT_FALSE = (1 << 4),
+    TRACK_ELEMENT_SET_SEAT_ROTATION = (1 << 5)
+};
+
+struct RideOperatingSettings
+{
+    uint8_t MinValue;
+    uint8_t MaxValue;
+    uint8_t MaxBrakesSpeed;
+    uint8_t PoweredLiftAcceleration;
+    uint8_t BoosterAcceleration;
+    int8_t BoosterSpeedFactor;
+};
+# 972 "/home/ted/dev/openrct2/src/openrct2/object/../ride/Ride.h"
+constexpr uint32_t CONSTRUCTION_LIFT_HILL_SELECTED = 1 << 0;
+constexpr uint32_t CONSTRUCTION_INVERTED_TRACK_SELECTED = 1 << 1;
+
+Ride* get_ride(ride_id_t index);
+
+struct RideManager
+{
+    const Ride* operator[](ride_id_t id) const
+    {
+        return get_ride(id);
+    }
+
+    Ride* operator[](ride_id_t id)
+    {
+        return get_ride(id);
+    }
+
+    class Iterator
+    {
+        friend RideManager;
+
+    private:
+        RideManager* _rideManager;
+        size_t _index{};
+        size_t _endIndex{};
+
+    public:
+        using difference_type = intptr_t;
+        using value_type = Ride;
+        using pointer = const Ride*;
+        using reference = const Ride&;
+        using iterator_category = std::forward_iterator_tag;
+
+    private:
+        Iterator(RideManager& rideManager, size_t beginIndex, size_t endIndex)
+            : _rideManager(&rideManager)
+            , _index(beginIndex)
+            , _endIndex(endIndex)
+        {
+            if (_index < _endIndex && (*_rideManager)[static_cast<ride_id_t>(_index)] == nullptr)
+            {
+                ++(*this);
+            }
+        }
+
+    public:
+        Iterator& operator++()
+        {
+            do
+            {
+                _index++;
+            } while (_index < _endIndex && (*_rideManager)[static_cast<ride_id_t>(_index)] == nullptr);
+            return *this;
+        }
+        Iterator operator++(int)
+        {
+            auto result = *this;
+            ++(*this);
+            return result;
+        }
+        bool operator==(Iterator other) const
+        {
+            return _index == other._index;
+        }
+        bool operator!=(Iterator other) const
+        {
+            return !(*this == other);
+        }
+        Ride& operator*()
+        {
+            return *(*_rideManager)[static_cast<ride_id_t>(_index)];
+        }
+    };
+
+    size_t size() const;
+    Iterator begin();
+    Iterator end();
+    Iterator begin() const
+    {
+        return (const_cast<RideManager*>(this))->begin();
+    }
+    Iterator end() const
+    {
+        return (const_cast<RideManager*>(this))->end();
+    }
+};
+
+RideManager GetRideManager();
+ride_id_t GetNextFreeRideId();
+Ride* GetOrAllocateRide(ride_id_t index);
+rct_ride_entry* get_ride_entry(ObjectEntryIndex index);
+std::string_view get_ride_entry_name(ObjectEntryIndex index);
+
+extern money16 gTotalRideValueForMoney;
+
+extern const rct_string_id ColourSchemeNames[4];
+
+extern money32 _currentTrackPrice;
+
+extern uint16_t _numCurrentPossibleRideConfigurations;
+extern uint16_t _numCurrentPossibleSpecialTrackPieces;
+
+extern uint32_t _currentTrackCurve;
+extern uint8_t _rideConstructionState;
+extern ride_id_t _currentRideIndex;
+
+extern CoordsXYZ _currentTrackBegin;
+
+extern uint8_t _currentTrackPieceDirection;
+extern track_type_t _currentTrackPieceType;
+extern uint8_t _currentTrackSelectionFlags;
+extern uint32_t _rideConstructionNextArrowPulse;
+extern uint8_t _currentTrackSlopeEnd;
+extern uint8_t _currentTrackBankEnd;
+extern uint8_t _currentTrackLiftHill;
+extern uint8_t _currentTrackAlternative;
+extern track_type_t _selectedTrackType;
+
+extern uint8_t _previousTrackBankEnd;
+extern uint8_t _previousTrackSlopeEnd;
+
+extern CoordsXYZ _previousTrackPiece;
+
+extern uint8_t _currentBrakeSpeed2;
+extern uint8_t _currentSeatRotationAngle;
+
+extern CoordsXYZD _unkF440C5;
+
+extern uint8_t gRideEntranceExitPlaceType;
+extern ride_id_t gRideEntranceExitPlaceRideIndex;
+extern StationIndex gRideEntranceExitPlaceStationIndex;
+extern uint8_t gRideEntranceExitPlacePreviousRideConstructionState;
+extern uint8_t gRideEntranceExitPlaceDirection;
+
+extern bool gGotoStartPlacementMode;
+
+extern uint8_t gLastEntranceStyle;
+
+int32_t ride_get_count();
+void ride_init_all();
+void reset_all_ride_build_dates();
+void ride_update_favourited_stat();
+void ride_check_all_reachable();
+void ride_update_satisfaction(Ride* ride, uint8_t happiness);
+void ride_update_popularity(Ride* ride, uint8_t pop_amount);
+bool ride_try_get_origin_element(const Ride* ride, CoordsXYE* output);
+int32_t ride_find_track_gap(const Ride* ride, CoordsXYE* input, CoordsXYE* output);
+void ride_construct_new(RideSelection listItem);
+void ride_construct(Ride* ride);
+bool ride_modify(CoordsXYE* input);
+void ride_remove_peeps(Ride* ride);
+void ride_clear_blocked_tiles(Ride* ride);
+Staff* ride_get_mechanic(Ride* ride);
+Staff* ride_get_assigned_mechanic(Ride* ride);
+int32_t ride_get_total_length(const Ride* ride);
+int32_t ride_get_total_time(Ride* ride);
+TrackColour ride_get_track_colour(Ride* ride, int32_t colourScheme);
+vehicle_colour ride_get_vehicle_colour(Ride* ride, int32_t vehicleIndex);
+int32_t ride_get_unused_preset_vehicle_colour(ObjectEntryIndex subType);
+void ride_set_vehicle_colours_to_random_preset(Ride* ride, uint8_t preset_index);
+void ride_measurements_update();
+void ride_breakdown_add_news_item(Ride* ride);
+Peep* ride_find_closest_mechanic(Ride* ride, int32_t forInspection);
+int32_t ride_initialise_construction_window(Ride* ride);
+void ride_construction_invalidate_current_track();
+std::optional<CoordsXYZ> sub_6C683D(
+    const CoordsXYZD& location, track_type_t type, uint16_t extra_params, TileElement** output_element, uint16_t flags);
+void ride_set_map_tooltip(TileElement* tileElement);
+void ride_prepare_breakdown(Ride* ride, int32_t breakdownReason);
+TileElement* ride_get_station_start_track_element(Ride* ride, StationIndex stationIndex);
+TileElement* ride_get_station_exit_element(const CoordsXYZ& elementPos);
+void ride_set_status(Ride* ride, int32_t status);
+void ride_set_name(Ride* ride, const char* name, uint32_t flags);
+int32_t ride_get_refund_price(const Ride* ride);
+int32_t ride_get_random_colour_preset_index(uint8_t ride_type);
+money32 ride_get_common_price(Ride* forRide);
+RideNaming get_ride_naming(const uint8_t rideType, rct_ride_entry* rideEntry);
+
+void ride_clear_for_construction(Ride* ride);
+void ride_entrance_exit_place_provisional_ghost();
+void ride_entrance_exit_remove_ghost();
+void ride_restore_provisional_track_piece();
+void ride_remove_provisional_track_piece();
+void set_vehicle_type_image_max_sizes(rct_ride_entry_vehicle* vehicle_type, int32_t num_images);
+void invalidate_test_results(Ride* ride);
+
+void ride_select_next_section();
+void ride_select_previous_section();
+
+void increment_turn_count_1_element(Ride* ride, uint8_t type);
+void increment_turn_count_2_elements(Ride* ride, uint8_t type);
+void increment_turn_count_3_elements(Ride* ride, uint8_t type);
+void increment_turn_count_4_plus_elements(Ride* ride, uint8_t type);
+int32_t get_turn_count_1_element(Ride* ride, uint8_t type);
+int32_t get_turn_count_2_elements(Ride* ride, uint8_t type);
+int32_t get_turn_count_3_elements(Ride* ride, uint8_t type);
+int32_t get_turn_count_4_plus_elements(Ride* ride, uint8_t type);
+
+uint8_t ride_get_helix_sections(Ride* ride);
+
+bool ride_has_any_track_elements(const Ride* ride);
+
+void ride_construction_set_default_next_piece();
+
+bool track_block_get_next(CoordsXYE* input, CoordsXYE* output, int32_t* z, int32_t* direction);
+bool track_block_get_next_from_zero(
+    const CoordsXYZ& startPos, Ride* ride, uint8_t direction_start, CoordsXYE* output, int32_t* z, int32_t* direction,
+    bool isGhost);
+
+bool track_block_get_previous(const CoordsXYE& trackPos, track_begin_end* outTrackBeginEnd);
+bool track_block_get_previous_from_zero(
+    const CoordsXYZ& startPos, Ride* ride, uint8_t direction, track_begin_end* outTrackBeginEnd);
+
+void ride_get_start_of_track(CoordsXYE* output);
+
+void window_ride_construction_update_active_elements();
+void ride_construction_remove_ghosts();
+money32 ride_entrance_exit_place_ghost(
+    Ride* ride, const CoordsXY& entranceExitCoords, Direction direction, int32_t placeType, StationIndex stationNum);
+CoordsXYZD ride_get_entrance_or_exit_position_from_screen_position(const ScreenCoordsXY& screenCoords);
+
+bool ride_select_backwards_from_front();
+bool ride_select_forwards_from_back();
+
+bool ride_are_all_possible_entrances_and_exits_built(Ride* ride);
+void ride_fix_breakdown(Ride* ride, int32_t reliabilityIncreaseFactor);
+
+void ride_entry_get_train_layout(int32_t rideEntryIndex, int32_t numCarsPerTrain, uint8_t* trainLayout);
+uint8_t ride_entry_get_vehicle_at_position(int32_t rideEntryIndex, int32_t numCarsPerTrain, int32_t position);
+void ride_update_vehicle_colours(Ride* ride);
+uint64_t ride_entry_get_supported_track_pieces(const rct_ride_entry* rideEntry);
+
+enum class RideSetSetting : uint8_t;
+money32 set_operating_setting(ride_id_t rideId, RideSetSetting setting, uint8_t value);
+money32 set_operating_setting_nested(ride_id_t rideId, RideSetSetting setting, uint8_t value, uint8_t flags);
+
+void sub_6CB945(Ride* ride);
+
+void sub_6C94D8();
+
+void ride_reset_all_names();
+
+void window_ride_construction_mouseup_demolish_next_piece(const CoordsXYZD& piecePos, int32_t type);
+
+uint32_t ride_customers_per_hour(const Ride* ride);
+uint32_t ride_customers_in_last_5_minutes(const Ride* ride);
+
+Vehicle* ride_get_broken_vehicle(const Ride* ride);
+
+void window_ride_construction_do_station_check();
+void window_ride_construction_do_entrance_exit_check();
+
+money16 ride_get_price(const Ride* ride);
+
+TileElement* get_station_platform(const CoordsXYRangedZ& coords);
+bool ride_has_adjacent_station(Ride* ride);
+bool ride_has_station_shelter(Ride* ride);
+bool ride_has_ratings(const Ride* ride);
+
+uint8_t ride_entry_get_first_non_null_ride_type(const rct_ride_entry* rideEntry);
+int32_t get_booster_speed(uint8_t rideType, int32_t rawSpeed);
+void fix_invalid_vehicle_sprite_sizes();
+bool ride_entry_has_category(const rct_ride_entry* rideEntry, uint8_t category);
+
+int32_t ride_get_entry_index(int32_t rideType, int32_t rideSubType);
+StationObject* ride_get_station_object(const Ride* ride);
+
+void ride_action_modify(Ride* ride, int32_t modifyType, int32_t flags);
+
+void determine_ride_entrance_and_exit_locations();
+void ride_clear_leftover_entrances(Ride* ride);
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/ObjectList.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../world/Entrance.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/object/../world/Entrance.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../world/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/object/../world/Entrance.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../world/Map.h" 1
+# 16 "/home/ted/dev/openrct2/src/openrct2/object/../world/Entrance.h" 2
+
+
+
+#pragma pack(push, 1)
+struct rct_entrance_type
+{
+    rct_string_id string_idx;
+    uint32_t image_id;
+    uint8_t scrolling_mode;
+    uint8_t text_height;
+};
+static_assert(sizeof(rct_entrance_type) == (8), "Improper struct size");
+#pragma pack(pop)
+
+struct TileElement;
+
+constexpr const uint8_t ParkEntranceHeight = 12 * COORDS_Z_STEP;
+constexpr const uint8_t RideEntranceHeight = 7 * COORDS_Z_STEP;
+constexpr const uint8_t RideExitHeight = 5 * COORDS_Z_STEP;
+
+extern bool gParkEntranceGhostExists;
+extern CoordsXYZD gParkEntranceGhostPosition;
+
+
+
+constexpr int32_t MaxRideEntranceOrExitHeight = 244 * COORDS_Z_STEP;
+
+using ParkEntranceIndex = uint8_t;
+constexpr const ParkEntranceIndex PARK_ENTRANCE_INDEX_NULL = 255;
+
+extern std::vector<CoordsXYZD> gParkEntrances;
+
+extern CoordsXYZD gRideEntranceExitGhostPosition;
+extern StationIndex gRideEntranceExitGhostStationIndex;
+
+void park_entrance_remove_ghost();
+money32 park_entrance_place_ghost(const CoordsXYZD& entranceLoc);
+
+void reset_park_entrance();
+void maze_entrance_hedge_replacement(const CoordsXYE& entrance);
+void maze_entrance_hedge_removal(const CoordsXYE& entrance);
+
+void fix_park_entrance_locations();
+void UpdateParkEntranceLocations();
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/ObjectList.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../world/Scenery.h" 1
+# 23 "/home/ted/dev/openrct2/src/openrct2/object/../world/Scenery.h"
+#pragma pack(push, 1)
+struct rct_small_scenery_entry
+{
+    uint32_t flags;
+    uint8_t height;
+    CursorID tool_id;
+    int16_t price;
+    int16_t removal_price;
+    uint8_t* frame_offsets;
+    uint16_t animation_delay;
+    uint16_t animation_mask;
+    uint16_t num_frames;
+    ObjectEntryIndex scenery_tab_id;
+};
+
+struct rct_large_scenery_tile
+{
+    int16_t x_offset;
+    int16_t y_offset;
+    int16_t z_offset;
+    uint8_t z_clearance;
+
+    uint16_t flags;
+};
+static_assert(sizeof(rct_large_scenery_tile) == (9), "Improper struct size");
+
+enum
+{
+    LARGE_SCENERY_TILE_FLAG_NO_SUPPORTS = 0x20,
+    LARGE_SCENERY_TILE_FLAG_ALLOW_SUPPORTS_ABOVE = 0x40,
+};
+
+struct rct_large_scenery_text_glyph
+{
+    uint8_t image_offset;
+    uint8_t width;
+    uint8_t height;
+    uint8_t pad_3;
+};
+static_assert(sizeof(rct_large_scenery_text_glyph) == (4), "Improper struct size");
+
+struct rct_large_scenery_text
+{
+    LocationXY16 offset[2];
+    uint16_t max_width;
+    uint16_t pad_A;
+    uint8_t flags;
+    uint8_t num_images;
+    rct_large_scenery_text_glyph glyphs[256];
+};
+static_assert(sizeof(rct_large_scenery_text) == (14 + 4 * 256), "Improper struct size");
+
+enum LARGE_SCENERY_TEXT_FLAGS
+{
+    LARGE_SCENERY_TEXT_FLAG_VERTICAL = (1 << 0),
+    LARGE_SCENERY_TEXT_FLAG_TWO_LINE = (1 << 1),
+};
+
+struct rct_large_scenery_entry
+{
+    CursorID tool_id;
+    uint8_t flags;
+    int16_t price;
+    int16_t removal_price;
+    rct_large_scenery_tile* tiles;
+    ObjectEntryIndex scenery_tab_id;
+    uint8_t scrolling_mode;
+    rct_large_scenery_text* text;
+    uint32_t text_image;
+};
+
+enum LARGE_SCENERY_FLAGS
+{
+    LARGE_SCENERY_FLAG_HAS_PRIMARY_COLOUR = (1 << 0),
+    LARGE_SCENERY_FLAG_HAS_SECONDARY_COLOUR = (1 << 1),
+    LARGE_SCENERY_FLAG_3D_TEXT = (1 << 2),
+    LARGE_SCENERY_FLAG_ANIMATED = (1 << 3),
+    LARGE_SCENERY_FLAG_PHOTOGENIC = (1 << 4),
+};
+
+struct rct_wall_scenery_entry
+{
+    CursorID tool_id;
+    uint8_t flags;
+    uint8_t height;
+    uint8_t flags2;
+    int16_t price;
+    ObjectEntryIndex scenery_tab_id;
+    uint8_t scrolling_mode;
+};
+
+enum WALL_SCENERY_FLAGS
+{
+    WALL_SCENERY_HAS_PRIMARY_COLOUR = (1 << 0),
+    WALL_SCENERY_HAS_GLASS = (1 << 1),
+    WALL_SCENERY_CANT_BUILD_ON_SLOPE = (1 << 2),
+    WALL_SCENERY_IS_BANNER = (1 << 3),
+    WALL_SCENERY_IS_DOOR = (1 << 4),
+    WALL_SCENERY_LONG_DOOR_ANIMATION = (1 << 5),
+    WALL_SCENERY_HAS_SECONDARY_COLOUR = (1 << 6),
+    WALL_SCENERY_HAS_TERNARY_COLOUR = (1 << 7),
+};
+
+enum WALL_SCENERY_2_FLAGS
+{
+    WALL_SCENERY_2_NO_SELECT_PRIMARY_COLOUR = (1 << 0),
+    WALL_SCENERY_2_DOOR_SOUND_MASK = 0x6,
+    WALL_SCENERY_2_DOOR_SOUND_SHIFT = 1,
+    WALL_SCENERY_2_IS_OPAQUE = (1 << 3),
+    WALL_SCENERY_2_ANIMATED = (1 << 4),
+};
+
+struct rct_path_bit_scenery_entry
+{
+    uint16_t flags;
+    uint8_t draw_type;
+    CursorID tool_id;
+    int16_t price;
+    ObjectEntryIndex scenery_tab_id;
+};
+
+struct rct_banner_scenery_entry
+{
+    uint8_t scrolling_mode;
+    uint8_t flags;
+    int16_t price;
+    ObjectEntryIndex scenery_tab_id;
+};
+
+struct rct_scenery_entry
+{
+    rct_string_id name;
+    uint32_t image;
+    union
+    {
+        rct_small_scenery_entry small_scenery;
+        rct_large_scenery_entry large_scenery;
+        rct_wall_scenery_entry wall;
+        rct_path_bit_scenery_entry path_bit;
+        rct_banner_scenery_entry banner;
+    };
+};
+
+#pragma pack(pop)
+
+struct rct_scenery_group_entry
+{
+    rct_string_id name;
+    uint32_t image;
+    ScenerySelection scenery_entries[0x80];
+    uint8_t entry_count;
+    uint8_t priority;
+    uint32_t entertainer_costumes;
+};
+
+enum
+{
+    PATH_BIT_FLAG_IS_BIN = 1 << 0,
+    PATH_BIT_FLAG_IS_BENCH = 1 << 1,
+    PATH_BIT_FLAG_BREAKABLE = 1 << 2,
+    PATH_BIT_FLAG_LAMP = 1 << 3,
+    PATH_BIT_FLAG_JUMPING_FOUNTAIN_WATER = 1 << 4,
+    PATH_BIT_FLAG_JUMPING_FOUNTAIN_SNOW = 1 << 5,
+    PATH_BIT_FLAG_DONT_ALLOW_ON_QUEUE = 1 << 6,
+    PATH_BIT_FLAG_DONT_ALLOW_ON_SLOPE = 1 << 7,
+    PATH_BIT_FLAG_IS_QUEUE_SCREEN = 1 << 8
+};
+
+enum
+{
+    PATH_BIT_DRAW_TYPE_LIGHTS,
+    PATH_BIT_DRAW_TYPE_BINS,
+    PATH_BIT_DRAW_TYPE_BENCHES,
+    PATH_BIT_DRAW_TYPE_JUMPING_FOUNTAINS
+};
+
+enum
+{
+    SCENERY_TYPE_SMALL,
+    SCENERY_TYPE_PATH_ITEM,
+    SCENERY_TYPE_WALL,
+    SCENERY_TYPE_LARGE,
+    SCENERY_TYPE_BANNER,
+
+    SCENERY_TYPE_COUNT,
+};
+
+enum
+{
+    SCENERY_GHOST_FLAG_0 = (1 << SCENERY_TYPE_SMALL),
+    SCENERY_GHOST_FLAG_1 = (1 << SCENERY_TYPE_PATH_ITEM),
+    SCENERY_GHOST_FLAG_2 = (1 << SCENERY_TYPE_WALL),
+    SCENERY_GHOST_FLAG_3 = (1 << SCENERY_TYPE_LARGE),
+    SCENERY_GHOST_FLAG_4 = (1 << SCENERY_TYPE_BANNER)
+};
+
+enum
+{
+    BANNER_ENTRY_FLAG_HAS_PRIMARY_COLOUR = (1 << 0),
+};
+
+enum class ScatterToolDensity : uint8_t
+{
+    LowDensity,
+    MediumDensity,
+    HighDensity
+};
+
+extern uint8_t gSceneryQuadrant;
+
+extern money32 gSceneryPlaceCost;
+extern ScenerySelection gSceneryPlaceObject;
+extern uint16_t gSceneryPlaceObjectEntryIndex;
+extern int16_t gSceneryPlaceZ;
+extern uint8_t gSceneryPlaceRotation;
+
+extern uint8_t gSceneryGhostType;
+extern CoordsXYZ gSceneryGhostPosition;
+extern uint8_t gSceneryGhostWallRotation;
+
+extern int16_t gSceneryShiftPressed;
+extern int16_t gSceneryShiftPressX;
+extern int16_t gSceneryShiftPressY;
+extern int16_t gSceneryShiftPressZOffset;
+
+extern int16_t gSceneryCtrlPressed;
+extern int16_t gSceneryCtrlPressZ;
+
+extern const CoordsXY SceneryQuadrantOffsets[];
+
+extern money32 gClearSceneryCost;
+
+void init_scenery();
+void scenery_update_tile(const CoordsXY& sceneryPos);
+void scenery_set_default_placement_configuration();
+void scenery_remove_ghost_tool_placement();
+
+rct_scenery_entry* get_wall_entry(ObjectEntryIndex entryIndex);
+rct_scenery_entry* get_banner_entry(ObjectEntryIndex entryIndex);
+rct_scenery_entry* get_footpath_item_entry(ObjectEntryIndex entryIndex);
+rct_scenery_group_entry* get_scenery_group_entry(ObjectEntryIndex entryIndex);
+
+int32_t wall_entry_get_door_sound(const rct_scenery_entry* wallEntry);
+# 17 "/home/ted/dev/openrct2/src/openrct2/object/ObjectList.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/../world/Water.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/object/../world/Water.h"
+enum
+{
+    WATER_FLAGS_ALLOW_DUCKS = (1 << 0)
+};
+
+#pragma pack(push, 1)
+struct rct_water_type
+{
+    rct_string_id string_idx;
+    uint32_t image_id;
+    uint32_t palette_index_1;
+    uint32_t palette_index_2;
+    uint16_t flags;
+};
+static_assert(sizeof(rct_water_type) == (16), "Improper struct size");
+#pragma pack(pop)
+# 18 "/home/ted/dev/openrct2/src/openrct2/object/ObjectList.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/ObjectLimits.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/ObjectLimits.h"
+       
+
+
+
+constexpr const uint16_t MAX_RIDE_OBJECTS = 1000;
+constexpr const uint16_t MAX_SMALL_SCENERY_OBJECTS = 1000;
+constexpr const uint16_t MAX_LARGE_SCENERY_OBJECTS = 1000;
+constexpr const uint16_t MAX_WALL_SCENERY_OBJECTS = 1000;
+constexpr const uint16_t MAX_BANNER_OBJECTS = 100;
+constexpr const uint16_t MAX_PATH_OBJECTS = 100;
+constexpr const uint16_t MAX_PATH_ADDITION_OBJECTS = 100;
+constexpr const uint16_t MAX_SCENERY_GROUP_OBJECTS = 100;
+constexpr const uint16_t MAX_PARK_ENTRANCE_OBJECTS = 1;
+constexpr const uint16_t MAX_WATER_OBJECTS = 1;
+constexpr const uint16_t MAX_SCENARIO_TEXT_OBJECTS = 0;
+constexpr const uint16_t MAX_TERRAIN_SURFACE_OBJECTS = 100;
+constexpr const uint16_t MAX_TERRAIN_EDGE_OBJECTS = 100;
+constexpr const uint16_t MAX_STATION_OBJECTS = 100;
+constexpr const uint16_t MAX_MUSIC_OBJECTS = 255;
+
+
+constexpr const uint16_t OBJECT_ENTRY_COUNT =
+    MAX_RIDE_OBJECTS +
+    MAX_SMALL_SCENERY_OBJECTS +
+    MAX_LARGE_SCENERY_OBJECTS +
+    MAX_WALL_SCENERY_OBJECTS +
+    MAX_BANNER_OBJECTS +
+    MAX_PATH_OBJECTS +
+    MAX_PATH_ADDITION_OBJECTS +
+    MAX_SCENERY_GROUP_OBJECTS +
+    MAX_PARK_ENTRANCE_OBJECTS +
+    MAX_WATER_OBJECTS +
+    MAX_SCENARIO_TEXT_OBJECTS +
+    MAX_TERRAIN_SURFACE_OBJECTS +
+    MAX_TERRAIN_EDGE_OBJECTS +
+    MAX_STATION_OBJECTS +
+    MAX_MUSIC_OBJECTS;
+
+
+constexpr const uint8_t DAT_NAME_LENGTH = 8;
+# 20 "/home/ted/dev/openrct2/src/openrct2/object/ObjectList.h" 2
+
+
+
+class ObjectList
+{
+private:
+    std::vector<std::vector<ObjectEntryDescriptor>> _subLists;
+
+public:
+    void Add(const ObjectEntryDescriptor& entry);
+    std::vector<ObjectEntryDescriptor>& GetList(ObjectType type);
+    std::vector<ObjectEntryDescriptor>& GetList(ObjectType type) const;
+    const ObjectEntryDescriptor& GetObject(ObjectType type, ObjectEntryIndex index) const;
+    void SetObject(ObjectEntryIndex index, const ObjectEntryDescriptor& entry);
+    void SetObject(ObjectType type, ObjectEntryIndex index, std::string_view identifier);
+
+    struct const_iterator
+    {
+    private:
+        const ObjectList* _parent;
+        size_t _subList;
+        size_t _index;
+
+        void MoveToNextEntry();
+
+    public:
+        const_iterator(const ObjectList* parent, bool end);
+        const ObjectEntryDescriptor& operator*();
+        bool operator==(const_iterator& rhs);
+        bool operator!=(const_iterator& rhs);
+        const_iterator& operator++();
+        const_iterator operator++(int);
+    };
+
+    const_iterator begin() const;
+    const_iterator end() const;
+};
+
+void get_type_entry_index(size_t index, ObjectType* outObjectType, ObjectEntryIndex* outEntryIndex);
+const rct_object_entry* get_loaded_object_entry(size_t index);
+void* get_loaded_object_chunk(size_t index);
+# 16 "/home/ted/dev/openrct2/src/openrct2/ParkImporter.h" 2
+
+
+
+
+
+struct IObjectManager;
+struct IObjectRepository;
+
+namespace OpenRCT2
+{
+    struct IStream;
+}
+
+struct scenario_index_entry;
+
+struct ParkLoadResult final
+{
+public:
+    ObjectList RequiredObjects;
+
+    explicit ParkLoadResult(ObjectList&& requiredObjects)
+        : RequiredObjects(std::move(requiredObjects))
+    {
+    }
+};
+
+
+
+
+struct IParkImporter
+{
+public:
+    virtual ~IParkImporter() = default;
+
+    virtual ParkLoadResult Load(const utf8* path) = 0;
+    virtual ParkLoadResult LoadSavedGame(const utf8* path, bool skipObjectCheck = false) = 0;
+    virtual ParkLoadResult LoadScenario(const utf8* path, bool skipObjectCheck = false) = 0;
+    virtual ParkLoadResult LoadFromStream(
+        OpenRCT2::IStream* stream, bool isScenario, bool skipObjectCheck = false, const utf8* path = String::Empty) = 0;
+
+    virtual void Import() = 0;
+    virtual bool GetDetails(scenario_index_entry* dst) = 0;
+};
+
+namespace ParkImporter
+{
+    std::unique_ptr<IParkImporter> Create(const std::string& hintPath);
+    std::unique_ptr<IParkImporter> CreateS4();
+    std::unique_ptr<IParkImporter> CreateS6(IObjectRepository& objectRepository);
+    std::unique_ptr<IParkImporter> CreateParkFile(IObjectRepository& objectRepository);
+
+    bool ExtensionIsRCT1(const std::string& extension);
+    bool ExtensionIsScenario(const std::string& extension);
+}
+
+class ObjectLoadException : public std::exception
+{
+public:
+    std::vector<ObjectEntryDescriptor> const MissingObjects;
+
+    explicit ObjectLoadException(std::vector<ObjectEntryDescriptor>&& missingObjects)
+        : MissingObjects(std::move(missingObjects))
+    {
+    }
+};
+
+class UnsupportedRCTCFlagException : public std::exception
+{
+public:
+    uint8_t const Flag;
+
+    explicit UnsupportedRCTCFlagException(uint8_t flag)
+        : Flag(flag)
+    {
+    }
+};
+
+class UnsupportedRideTypeException : public std::exception
+{
+public:
+    ObjectEntryIndex const Type;
+
+    explicit UnsupportedRideTypeException(ObjectEntryIndex type)
+        : Type(type)
+    {
+    }
+};
+# 17 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/Version.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/Version.h"
+       
+# 81 "/home/ted/dev/openrct2/src/openrct2/Version.h"
+extern const char gVersionInfoFull[];
+extern const char gVersionInfoTag[];
+struct NewVersionInfo
+{
+    std::string tag;
+    std::string name;
+    std::string changelog;
+    std::string url;
+};
+
+NewVersionInfo get_latest_version();
+# 18 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/Crypt.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/Crypt.h"
+       
+
+
+
+
+
+
+namespace Crypt
+{
+    template<size_t TLength> class HashAlgorithm
+    {
+    public:
+        using Result = std::array<uint8_t, TLength>;
+
+        virtual ~HashAlgorithm() = default;
+        virtual HashAlgorithm* Clear() = 0;
+        virtual HashAlgorithm* Update(const void* data, size_t dataLen) = 0;
+        virtual Result Finish() = 0;
+    };
+
+    class RsaKey
+    {
+    public:
+        virtual ~RsaKey() = default;
+        virtual void Generate() = 0;
+        virtual void SetPrivate(std::string_view pem) = 0;
+        virtual void SetPublic(std::string_view pem) = 0;
+        virtual std::string GetPrivate() = 0;
+        virtual std::string GetPublic() = 0;
+    };
+
+    class RsaAlgorithm
+    {
+    public:
+        virtual ~RsaAlgorithm() = default;
+        virtual std::vector<uint8_t> SignData(const RsaKey& key, const void* data, size_t dataLen) = 0;
+        virtual bool VerifyData(const RsaKey& key, const void* data, size_t dataLen, const void* sig, size_t sigLen) = 0;
+    };
+
+    using Sha1Algorithm = HashAlgorithm<20>;
+    using Sha256Algorithm = HashAlgorithm<32>;
+
+
+    std::unique_ptr<Sha1Algorithm> CreateSHA1();
+    std::unique_ptr<Sha256Algorithm> CreateSHA256();
+    std::unique_ptr<RsaAlgorithm> CreateRSA();
+    std::unique_ptr<RsaKey> CreateRSAKey();
+
+    inline Sha1Algorithm::Result SHA1(const void* data, size_t dataLen)
+    {
+        return CreateSHA1()->Update(data, dataLen)->Finish();
+    }
+
+    inline Sha256Algorithm::Result SHA256(const void* data, size_t dataLen)
+    {
+        return CreateSHA256()->Update(data, dataLen)->Finish();
+    }
+}
+# 19 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiser.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiser.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../Cheats.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../core/MemoryStream.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/../core/MemoryStream.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../core/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../core/MemoryStream.h" 2
+
+
+
+
+
+namespace OpenRCT2
+{
+    namespace MEMORY_ACCESS
+    {
+        constexpr uint8_t READ = 1 << 0;
+        constexpr uint8_t WRITE = 1 << 1;
+        constexpr uint8_t OWNER = 1 << 2;
+    };
+
+
+
+
+    class MemoryStream final : public IStream
+    {
+    private:
+        uint8_t _access = MEMORY_ACCESS::READ | MEMORY_ACCESS::WRITE | MEMORY_ACCESS::OWNER;
+        size_t _dataCapacity = 0;
+        size_t _dataSize = 0;
+        void* _data = nullptr;
+        void* _position = nullptr;
+
+    public:
+        MemoryStream() = default;
+        MemoryStream(const MemoryStream& copy);
+        MemoryStream(MemoryStream&& mv) noexcept;
+        explicit MemoryStream(size_t capacity);
+        MemoryStream(void* data, size_t dataSize, uint8_t access = MEMORY_ACCESS::READ);
+        MemoryStream(const void* data, size_t dataSize);
+        MemoryStream(std::vector<uint8_t>&& v);
+        virtual ~MemoryStream();
+
+        MemoryStream& operator=(MemoryStream&& mv) noexcept;
+
+        const void* GetData() const override;
+        void* GetDataCopy() const;
+        void* TakeData();
+
+
+
+
+        bool CanRead() const override;
+        bool CanWrite() const override;
+
+        uint64_t GetLength() const override;
+        uint64_t GetPosition() const override;
+        void SetPosition(uint64_t position) override;
+        void Seek(int64_t offset, int32_t origin) override;
+
+        void Read(void* buffer, uint64_t length) override;
+        void Read1(void* buffer) override;
+        void Read2(void* buffer) override;
+        void Read4(void* buffer) override;
+        void Read8(void* buffer) override;
+        void Read16(void* buffer) override;
+
+        template<size_t N> void Read(void* buffer)
+        {
+            uint64_t position = GetPosition();
+            if (position + N > _dataSize)
+            {
+                throw IOException("Attempted to read past end of stream.");
+            }
+
+            std::memcpy(buffer, _position, N);
+            _position = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(_position) + N);
+        }
+
+        void Write(const void* buffer, uint64_t length) override;
+        void Write1(const void* buffer) override;
+        void Write2(const void* buffer) override;
+        void Write4(const void* buffer) override;
+        void Write8(const void* buffer) override;
+        void Write16(const void* buffer) override;
+
+        template<size_t N> void Write(const void* buffer)
+        {
+            uint64_t position = GetPosition();
+            uint64_t nextPosition = position + N;
+            if (nextPosition > _dataCapacity)
+            {
+                if (_access & MEMORY_ACCESS::OWNER)
+                {
+                    EnsureCapacity(static_cast<size_t>(nextPosition));
+                }
+                else
+                {
+                    throw IOException("Attempted to write past end of stream.");
+                }
+            }
+
+            std::memcpy(_position, buffer, N);
+            _position = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(_position) + N);
+            _dataSize = std::max<size_t>(_dataSize, static_cast<size_t>(nextPosition));
+        }
+
+        uint64_t TryRead(void* buffer, uint64_t length) override;
+
+        void Clear();
+
+    private:
+        void EnsureCapacity(size_t capacity);
+    };
+
+}
+# 14 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Localisation.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Localisation.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/Marketing.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/Marketing.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../Cheats.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/Marketing.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/Marketing.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/Finance.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/Finance.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/Finance.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/Research.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/Research.h"
+       
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/../ride/Ride.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/Research.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/../util/Util.h" 1
+# 16 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/Research.h" 2
+
+
+
+struct rct_ride_entry;
+
+namespace Research
+{
+    enum class EntryType : uint8_t
+    {
+        Scenery = 0,
+        Ride = 1,
+    };
+}
+
+enum
+{
+    RESEARCH_ENTRY_FLAG_FIRST_OF_TYPE = (1 << 0),
+    RESEARCH_ENTRY_FLAG_SCENERY_SET_ALWAYS_RESEARCHED = (1 << 5),
+    RESEARCH_ENTRY_FLAG_RIDE_ALWAYS_RESEARCHED = (1 << 6),
+};
+
+enum class ResearchCategory : uint8_t
+{
+    Transport = 0,
+    Gentle = 1,
+    Rollercoaster = 2,
+    Thrill = 3,
+    Water = 4,
+    Shop = 5,
+    SceneryGroup = 6,
+};
+
+struct ResearchItem
+{
+    union
+    {
+        uint32_t rawValue;
+        struct
+        {
+            ObjectEntryIndex entryIndex;
+            uint8_t baseRideType;
+            Research::EntryType type;
+        };
+    };
+    uint8_t flags;
+    ResearchCategory category;
+
+    bool IsNull() const;
+    void SetNull();
+    bool Equals(const ResearchItem* otherItem) const;
+    bool Exists() const;
+    bool IsAlwaysResearched() const;
+    rct_string_id GetName() const;
+    rct_string_id GetCategoryInventionString() const;
+    rct_string_id GetCategoryName() const;
+
+    ResearchItem() = default;
+    constexpr ResearchItem(uint32_t _rawValue, ResearchCategory _category, uint8_t _flags)
+        : rawValue(_rawValue)
+        , flags(_flags)
+        , category(_category)
+    {
+    }
+    ResearchItem(
+        Research::EntryType _type, ObjectEntryIndex _entryIndex, uint8_t _baseRideType, ResearchCategory _category,
+        uint8_t _flags)
+        : entryIndex(_entryIndex)
+        , baseRideType(_baseRideType)
+        , type(_type)
+        , flags(_flags)
+        , category(_category)
+    {
+    }
+
+    RCT12ResearchItem ToRCT12ResearchItem() const
+    {
+        RCT12ResearchItem retItem = {};
+        if (IsNull())
+        {
+            retItem.rawValue = RCT12_RESEARCHED_ITEMS_SEPARATOR;
+        }
+        else
+        {
+            retItem.entryIndex = OpenRCT2EntryIndexToRCTEntryIndex(entryIndex);
+            retItem.baseRideType = OpenRCT2RideTypeToRCT2RideType(baseRideType);
+            retItem.type = static_cast<uint8_t>(type);
+            retItem.flags = (flags & ~RESEARCH_ENTRY_FLAG_FIRST_OF_TYPE);
+            retItem.category = EnumValue(category);
+        }
+
+        return retItem;
+    }
+
+    ResearchItem(const RCT12ResearchItem& oldResearchItem)
+    {
+        if (oldResearchItem.IsInventedEndMarker() || oldResearchItem.IsUninventedEndMarker()
+            || oldResearchItem.IsRandomEndMarker())
+        {
+            rawValue = 0;
+            flags = 0;
+            category = ResearchCategory::Transport;
+            SetNull();
+        }
+        else
+        {
+            entryIndex = RCTEntryIndexToOpenRCT2EntryIndex(oldResearchItem.entryIndex);
+            auto* rideEntry = get_ride_entry(entryIndex);
+            baseRideType = rideEntry != nullptr ? RCT2RideTypeToOpenRCT2RideType(oldResearchItem.baseRideType, rideEntry)
+                                                : oldResearchItem.baseRideType;
+            type = Research::EntryType{ oldResearchItem.type };
+            flags = oldResearchItem.flags;
+            category = static_cast<ResearchCategory>(oldResearchItem.category);
+        }
+    }
+};
+
+
+
+
+
+
+enum
+{
+    RESEARCH_FUNDING_NONE,
+    RESEARCH_FUNDING_MINIMUM,
+    RESEARCH_FUNDING_NORMAL,
+    RESEARCH_FUNDING_MAXIMUM,
+
+    RESEARCH_FUNDING_COUNT
+};
+
+enum
+{
+    RESEARCH_STAGE_INITIAL_RESEARCH,
+    RESEARCH_STAGE_DESIGNING,
+    RESEARCH_STAGE_COMPLETING_DESIGN,
+    RESEARCH_STAGE_UNKNOWN,
+    RESEARCH_STAGE_FINISHED_ALL
+};
+
+extern uint8_t gResearchFundingLevel;
+extern uint8_t gResearchPriorities;
+extern uint16_t gResearchProgress;
+extern uint8_t gResearchProgressStage;
+extern uint8_t gResearchExpectedMonth;
+extern uint8_t gResearchExpectedDay;
+extern std::optional<ResearchItem> gResearchLastItem;
+extern std::optional<ResearchItem> gResearchNextItem;
+
+extern std::vector<ResearchItem> gResearchItemsUninvented;
+extern std::vector<ResearchItem> gResearchItemsInvented;
+extern uint8_t gResearchUncompletedCategories;
+extern bool gSilentResearch;
+
+void research_reset_items();
+void research_update_uncompleted_types();
+void research_update();
+void research_reset_current_item();
+void research_populate_list_random();
+
+void research_finish_item(ResearchItem* researchItem);
+void research_insert(ResearchItem&& item, bool researched);
+void research_remove(ResearchItem* researchItem);
+
+bool research_insert_ride_entry(uint8_t rideType, ObjectEntryIndex entryIndex, ResearchCategory category, bool researched);
+void research_insert_ride_entry(ObjectEntryIndex entryIndex, bool researched);
+bool research_insert_scenery_group_entry(ObjectEntryIndex entryIndex, bool researched);
+
+void ride_type_set_invented(uint32_t rideType);
+void ride_entry_set_invented(int32_t rideEntryIndex);
+void scenery_set_invented(const ScenerySelection& sceneryItem);
+void scenery_set_not_invented(const ScenerySelection& sceneryItem);
+bool ride_type_is_invented(uint32_t rideType);
+bool ride_entry_is_invented(int32_t rideEntryIndex);
+bool scenery_group_is_invented(int32_t sgIndex);
+void scenery_group_set_invented(int32_t sgIndex);
+bool scenery_is_invented(const ScenerySelection& sceneryItem);
+void set_all_scenery_items_invented();
+void set_all_scenery_items_not_invented();
+void set_all_scenery_groups_not_invented();
+void set_every_ride_type_invented();
+void set_every_ride_type_not_invented();
+void set_every_ride_entry_invented();
+void set_every_ride_entry_not_invented();
+void research_remove_flags();
+void research_fix();
+
+void research_items_make_all_unresearched();
+void research_items_make_all_researched();
+void research_items_shuffle();
+
+
+
+
+void research_determine_first_of_type();
+# 14 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../management/Finance.h" 2
+
+enum class ExpenditureType : int32_t
+{
+    RideConstruction = 0,
+    RideRunningCosts,
+    LandPurchase,
+    Landscaping,
+    ParkEntranceTickets,
+    ParkRideTickets,
+    ShopSales,
+    ShopStock,
+    FoodDrinkSales,
+    FoodDrinkStock,
+    Wages,
+    Marketing,
+    Research,
+    Interest,
+    Count
+};
+
+
+
+
+extern const money32 research_cost_table[RESEARCH_FUNDING_COUNT];
+
+extern money32 gInitialCash;
+extern money32 gCash;
+extern money32 gBankLoan;
+extern uint8_t gBankLoanInterestRate;
+extern money32 gMaxBankLoan;
+extern money32 gCurrentExpenditure;
+extern money32 gCurrentProfit;
+
+
+
+
+
+extern money32 gHistoricalProfit;
+
+extern money32 gWeeklyProfitAverageDividend;
+extern uint16_t gWeeklyProfitAverageDivisor;
+extern money32 gCashHistory[128];
+extern money32 gWeeklyProfitHistory[128];
+extern money32 gParkValueHistory[128];
+extern money32 gExpenditureTable[16][static_cast<int32_t>(ExpenditureType::Count)];
+
+bool finance_check_money_required(uint32_t flags);
+bool finance_check_affordability(money32 cost, uint32_t flags);
+void finance_payment(money32 amount, ExpenditureType type);
+void finance_pay_wages();
+void finance_pay_research();
+void finance_pay_interest();
+void finance_pay_ride_upkeep();
+void finance_reset_history();
+void finance_init();
+void finance_update_daily_profit();
+void finance_shift_expenditure_table();
+void finance_reset_cash_to_initial();
+
+money32 finance_get_initial_cash();
+money32 finance_get_current_loan();
+money32 finance_get_maximum_loan();
+money32 finance_get_current_cash();
+
+money32 finance_get_last_month_shop_profit();
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../ride/Ride.h" 1
+# 17 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h" 2
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../util/Util.h" 1
+# 20 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../world/SpriteBase.h" 1
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../world/../common.h" 1
+# 4 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/../world/SpriteBase.h" 2
+
+struct CoordsXYZ;
+
+enum class EntityType : uint8_t
+{
+    Vehicle,
+    Guest,
+    Staff,
+    Litter,
+    SteamParticle,
+    MoneyEffect,
+    CrashedVehicleParticle,
+    ExplosionCloud,
+    CrashSplash,
+    ExplosionFlare,
+    JumpingFountain,
+    Balloon,
+    Duck,
+    Count,
+    Null = 255
+};
+
+struct SpriteBase
+{
+    EntityType Type;
+
+    uint8_t sprite_height_negative;
+    uint16_t sprite_index;
+    uint16_t flags;
+    int16_t x;
+    int16_t y;
+    int16_t z;
+
+    uint8_t sprite_width;
+
+    uint8_t sprite_height_positive;
+
+    int16_t sprite_left;
+    int16_t sprite_top;
+    int16_t sprite_right;
+    int16_t sprite_bottom;
+
+    uint8_t sprite_direction;
+
+
+
+
+
+
+
+    void MoveTo(const CoordsXYZ& newLocation);
+
+
+
+
+    void SetLocation(const CoordsXYZ& newLocation);
+
+
+
+
+    CoordsXYZ GetLocation() const;
+
+    void Invalidate();
+    template<typename T> bool Is() const;
+    template<typename T> T* As()
+    {
+        return Is<T>() ? reinterpret_cast<T*>(this) : nullptr;
+    }
+    template<typename T> const T* As() const
+    {
+        return Is<T>() ? reinterpret_cast<const T*>(this) : nullptr;
+    }
+};
+
+struct MiscEntity : SpriteBase
+{
+    uint16_t frame;
+};
+# 22 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h" 2
+
+
+# 1 "/usr/include/c++/10.2.0/bitset" 1 3
+# 45 "/usr/include/c++/10.2.0/bitset" 3
+       
+# 46 "/usr/include/c++/10.2.0/bitset" 3
+# 64 "/usr/include/c++/10.2.0/bitset" 3
+
+# 64 "/usr/include/c++/10.2.0/bitset" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+  template<size_t _Nw>
+    struct _Base_bitset
+    {
+      typedef unsigned long _WordT;
+
+
+      _WordT _M_w[_Nw];
+
+      constexpr _Base_bitset() noexcept
+      : _M_w() { }
+
+
+      constexpr _Base_bitset(unsigned long long __val) noexcept
+      : _M_w{ _WordT(__val)
+
+
+
+       } { }
+
+
+
+
+
+
+      static constexpr size_t
+      _S_whichword(size_t __pos) noexcept
+      { return __pos / (8 * 8); }
+
+      static constexpr size_t
+      _S_whichbyte(size_t __pos) noexcept
+      { return (__pos % (8 * 8)) / 8; }
+
+      static constexpr size_t
+      _S_whichbit(size_t __pos) noexcept
+      { return __pos % (8 * 8); }
+
+      static constexpr _WordT
+      _S_maskbit(size_t __pos) noexcept
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+
+      _WordT&
+      _M_getword(size_t __pos) noexcept
+      { return _M_w[_S_whichword(__pos)]; }
+
+      constexpr _WordT
+      _M_getword(size_t __pos) const noexcept
+      { return _M_w[_S_whichword(__pos)]; }
+
+
+      const _WordT*
+      _M_getdata() const noexcept
+      { return _M_w; }
+
+
+      _WordT&
+      _M_hiword() noexcept
+      { return _M_w[_Nw - 1]; }
+
+      constexpr _WordT
+      _M_hiword() const noexcept
+      { return _M_w[_Nw - 1]; }
+
+      void
+      _M_do_and(const _Base_bitset<_Nw>& __x) noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] &= __x._M_w[__i];
+      }
+
+      void
+      _M_do_or(const _Base_bitset<_Nw>& __x) noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] |= __x._M_w[__i];
+      }
+
+      void
+      _M_do_xor(const _Base_bitset<_Nw>& __x) noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] ^= __x._M_w[__i];
+      }
+
+      void
+      _M_do_left_shift(size_t __shift) noexcept;
+
+      void
+      _M_do_right_shift(size_t __shift) noexcept;
+
+      void
+      _M_do_flip() noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] = ~_M_w[__i];
+      }
+
+      void
+      _M_do_set() noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   _M_w[__i] = ~static_cast<_WordT>(0);
+      }
+
+      void
+      _M_do_reset() noexcept
+      { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); }
+
+      bool
+      _M_is_equal(const _Base_bitset<_Nw>& __x) const noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; ++__i)
+   if (_M_w[__i] != __x._M_w[__i])
+     return false;
+ return true;
+      }
+
+      template<size_t _Nb>
+        bool
+        _M_are_all() const noexcept
+        {
+   for (size_t __i = 0; __i < _Nw - 1; __i++)
+     if (_M_w[__i] != ~static_cast<_WordT>(0))
+       return false;
+   return _M_hiword() == (~static_cast<_WordT>(0)
+     >> (_Nw * (8 * 8)
+         - _Nb));
+ }
+
+      bool
+      _M_is_any() const noexcept
+      {
+ for (size_t __i = 0; __i < _Nw; __i++)
+   if (_M_w[__i] != static_cast<_WordT>(0))
+     return true;
+ return false;
+      }
+
+      size_t
+      _M_do_count() const noexcept
+      {
+ size_t __result = 0;
+ for (size_t __i = 0; __i < _Nw; __i++)
+   __result += __builtin_popcountl(_M_w[__i]);
+ return __result;
+      }
+
+      unsigned long
+      _M_do_to_ulong() const;
+
+
+      unsigned long long
+      _M_do_to_ullong() const;
+
+
+
+      size_t
+      _M_do_find_first(size_t) const noexcept;
+
+
+      size_t
+      _M_do_find_next(size_t, size_t) const noexcept;
+    };
+
+
+  template<size_t _Nw>
+    void
+    _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) noexcept
+    {
+      if (__builtin_expect(__shift != 0, 1))
+ {
+   const size_t __wshift = __shift / (8 * 8);
+   const size_t __offset = __shift % (8 * 8);
+
+   if (__offset == 0)
+     for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
+       _M_w[__n] = _M_w[__n - __wshift];
+   else
+     {
+       const size_t __sub_offset = ((8 * 8)
+        - __offset);
+       for (size_t __n = _Nw - 1; __n > __wshift; --__n)
+  _M_w[__n] = ((_M_w[__n - __wshift] << __offset)
+        | (_M_w[__n - __wshift - 1] >> __sub_offset));
+       _M_w[__wshift] = _M_w[0] << __offset;
+     }
+
+   std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
+ }
+    }
+
+  template<size_t _Nw>
+    void
+    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) noexcept
+    {
+      if (__builtin_expect(__shift != 0, 1))
+ {
+   const size_t __wshift = __shift / (8 * 8);
+   const size_t __offset = __shift % (8 * 8);
+   const size_t __limit = _Nw - __wshift - 1;
+
+   if (__offset == 0)
+     for (size_t __n = 0; __n <= __limit; ++__n)
+       _M_w[__n] = _M_w[__n + __wshift];
+   else
+     {
+       const size_t __sub_offset = ((8 * 8)
+        - __offset);
+       for (size_t __n = 0; __n < __limit; ++__n)
+  _M_w[__n] = ((_M_w[__n + __wshift] >> __offset)
+        | (_M_w[__n + __wshift + 1] << __sub_offset));
+       _M_w[__limit] = _M_w[_Nw-1] >> __offset;
+     }
+
+   std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
+ }
+    }
+
+  template<size_t _Nw>
+    unsigned long
+    _Base_bitset<_Nw>::_M_do_to_ulong() const
+    {
+      for (size_t __i = 1; __i < _Nw; ++__i)
+ if (_M_w[__i])
+   __throw_overflow_error(("_Base_bitset::_M_do_to_ulong"));
+      return _M_w[0];
+    }
+
+
+  template<size_t _Nw>
+    unsigned long long
+    _Base_bitset<_Nw>::_M_do_to_ullong() const
+    {
+      const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long);
+      for (size_t __i = 1 + __dw; __i < _Nw; ++__i)
+ if (_M_w[__i])
+   __throw_overflow_error(("_Base_bitset::_M_do_to_ullong"));
+
+      if (__dw)
+ return _M_w[0] + (static_cast<unsigned long long>(_M_w[1])
+     << (8 * 8));
+      return _M_w[0];
+    }
+
+
+  template<size_t _Nw>
+    size_t
+    _Base_bitset<_Nw>::
+    _M_do_find_first(size_t __not_found) const noexcept
+    {
+      for (size_t __i = 0; __i < _Nw; __i++)
+ {
+   _WordT __thisword = _M_w[__i];
+   if (__thisword != static_cast<_WordT>(0))
+     return (__i * (8 * 8)
+      + __builtin_ctzl(__thisword));
+ }
+
+      return __not_found;
+    }
+
+  template<size_t _Nw>
+    size_t
+    _Base_bitset<_Nw>::
+    _M_do_find_next(size_t __prev, size_t __not_found) const noexcept
+    {
+
+      ++__prev;
+
+
+      if (__prev >= _Nw * (8 * 8))
+ return __not_found;
+
+
+      size_t __i = _S_whichword(__prev);
+      _WordT __thisword = _M_w[__i];
+
+
+      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
+
+      if (__thisword != static_cast<_WordT>(0))
+ return (__i * (8 * 8)
+  + __builtin_ctzl(__thisword));
+
+
+      __i++;
+      for (; __i < _Nw; __i++)
+ {
+   __thisword = _M_w[__i];
+   if (__thisword != static_cast<_WordT>(0))
+     return (__i * (8 * 8)
+      + __builtin_ctzl(__thisword));
+ }
+
+      return __not_found;
+    }
+
+
+
+
+
+
+  template<>
+    struct _Base_bitset<1>
+    {
+      typedef unsigned long _WordT;
+      _WordT _M_w;
+
+      constexpr _Base_bitset() noexcept
+      : _M_w(0)
+      { }
+
+
+      constexpr _Base_bitset(unsigned long long __val) noexcept
+
+
+
+      : _M_w(__val)
+      { }
+
+      static constexpr size_t
+      _S_whichword(size_t __pos) noexcept
+      { return __pos / (8 * 8); }
+
+      static constexpr size_t
+      _S_whichbyte(size_t __pos) noexcept
+      { return (__pos % (8 * 8)) / 8; }
+
+      static constexpr size_t
+      _S_whichbit(size_t __pos) noexcept
+      { return __pos % (8 * 8); }
+
+      static constexpr _WordT
+      _S_maskbit(size_t __pos) noexcept
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+
+      _WordT&
+      _M_getword(size_t) noexcept
+      { return _M_w; }
+
+      constexpr _WordT
+      _M_getword(size_t) const noexcept
+      { return _M_w; }
+
+
+      const _WordT*
+      _M_getdata() const noexcept
+      { return &_M_w; }
+
+
+      _WordT&
+      _M_hiword() noexcept
+      { return _M_w; }
+
+      constexpr _WordT
+      _M_hiword() const noexcept
+      { return _M_w; }
+
+      void
+      _M_do_and(const _Base_bitset<1>& __x) noexcept
+      { _M_w &= __x._M_w; }
+
+      void
+      _M_do_or(const _Base_bitset<1>& __x) noexcept
+      { _M_w |= __x._M_w; }
+
+      void
+      _M_do_xor(const _Base_bitset<1>& __x) noexcept
+      { _M_w ^= __x._M_w; }
+
+      void
+      _M_do_left_shift(size_t __shift) noexcept
+      { _M_w <<= __shift; }
+
+      void
+      _M_do_right_shift(size_t __shift) noexcept
+      { _M_w >>= __shift; }
+
+      void
+      _M_do_flip() noexcept
+      { _M_w = ~_M_w; }
+
+      void
+      _M_do_set() noexcept
+      { _M_w = ~static_cast<_WordT>(0); }
+
+      void
+      _M_do_reset() noexcept
+      { _M_w = 0; }
+
+      bool
+      _M_is_equal(const _Base_bitset<1>& __x) const noexcept
+      { return _M_w == __x._M_w; }
+
+      template<size_t _Nb>
+        bool
+        _M_are_all() const noexcept
+        { return _M_w == (~static_cast<_WordT>(0)
+     >> ((8 * 8) - _Nb)); }
+
+      bool
+      _M_is_any() const noexcept
+      { return _M_w != 0; }
+
+      size_t
+      _M_do_count() const noexcept
+      { return __builtin_popcountl(_M_w); }
+
+      unsigned long
+      _M_do_to_ulong() const noexcept
+      { return _M_w; }
+
+
+      unsigned long long
+      _M_do_to_ullong() const noexcept
+      { return _M_w; }
+
+
+      size_t
+      _M_do_find_first(size_t __not_found) const noexcept
+      {
+        if (_M_w != 0)
+          return __builtin_ctzl(_M_w);
+        else
+          return __not_found;
+      }
+
+
+      size_t
+      _M_do_find_next(size_t __prev, size_t __not_found) const
+ noexcept
+      {
+ ++__prev;
+ if (__prev >= ((size_t) (8 * 8)))
+   return __not_found;
+
+ _WordT __x = _M_w >> __prev;
+ if (__x != 0)
+   return __builtin_ctzl(__x) + __prev;
+ else
+   return __not_found;
+      }
+    };
+
+
+
+
+
+
+  template<>
+    struct _Base_bitset<0>
+    {
+      typedef unsigned long _WordT;
+
+      constexpr _Base_bitset() noexcept
+      { }
+
+
+      constexpr _Base_bitset(unsigned long long) noexcept
+
+
+
+      { }
+
+      static constexpr size_t
+      _S_whichword(size_t __pos) noexcept
+      { return __pos / (8 * 8); }
+
+      static constexpr size_t
+      _S_whichbyte(size_t __pos) noexcept
+      { return (__pos % (8 * 8)) / 8; }
+
+      static constexpr size_t
+      _S_whichbit(size_t __pos) noexcept
+      { return __pos % (8 * 8); }
+
+      static constexpr _WordT
+      _S_maskbit(size_t __pos) noexcept
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+# 560 "/usr/include/c++/10.2.0/bitset" 3
+      _WordT&
+      _M_getword(size_t) noexcept
+      {
+ __throw_out_of_range(("_Base_bitset::_M_getword"));
+ return *new _WordT;
+      }
+
+      constexpr _WordT
+      _M_getword(size_t) const noexcept
+      { return 0; }
+
+      constexpr _WordT
+      _M_hiword() const noexcept
+      { return 0; }
+
+      void
+      _M_do_and(const _Base_bitset<0>&) noexcept
+      { }
+
+      void
+      _M_do_or(const _Base_bitset<0>&) noexcept
+      { }
+
+      void
+      _M_do_xor(const _Base_bitset<0>&) noexcept
+      { }
+
+      void
+      _M_do_left_shift(size_t) noexcept
+      { }
+
+      void
+      _M_do_right_shift(size_t) noexcept
+      { }
+
+      void
+      _M_do_flip() noexcept
+      { }
+
+      void
+      _M_do_set() noexcept
+      { }
+
+      void
+      _M_do_reset() noexcept
+      { }
+
+
+
+
+      bool
+      _M_is_equal(const _Base_bitset<0>&) const noexcept
+      { return true; }
+
+      template<size_t _Nb>
+        bool
+        _M_are_all() const noexcept
+        { return true; }
+
+      bool
+      _M_is_any() const noexcept
+      { return false; }
+
+      size_t
+      _M_do_count() const noexcept
+      { return 0; }
+
+      unsigned long
+      _M_do_to_ulong() const noexcept
+      { return 0; }
+
+
+      unsigned long long
+      _M_do_to_ullong() const noexcept
+      { return 0; }
+
+
+
+
+      size_t
+      _M_do_find_first(size_t) const noexcept
+      { return 0; }
+
+      size_t
+      _M_do_find_next(size_t, size_t) const noexcept
+      { return 0; }
+    };
+
+
+
+  template<size_t _Extrabits>
+    struct _Sanitize
+    {
+      typedef unsigned long _WordT;
+
+      static void
+      _S_do_sanitize(_WordT& __val) noexcept
+      { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
+    };
+
+  template<>
+    struct _Sanitize<0>
+    {
+      typedef unsigned long _WordT;
+
+      static void
+      _S_do_sanitize(_WordT) noexcept { }
+    };
+
+
+  template<size_t _Nb, bool = (_Nb < (8 * 8))>
+    struct _Sanitize_val
+    {
+      static constexpr unsigned long long
+      _S_do_sanitize_val(unsigned long long __val)
+      { return __val; }
+    };
+
+  template<size_t _Nb>
+    struct _Sanitize_val<_Nb, true>
+    {
+      static constexpr unsigned long long
+      _S_do_sanitize_val(unsigned long long __val)
+      { return __val & ~((~static_cast<unsigned long long>(0)) << _Nb); }
+    };
+# 750 "/usr/include/c++/10.2.0/bitset" 3
+  template<size_t _Nb>
+    class bitset
+    : private _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))>
+    {
+    private:
+      typedef _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))> _Base;
+      typedef unsigned long _WordT;
+
+      template<class _CharT, class _Traits, class _Alloc>
+      void
+      _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+    size_t __position) const
+      {
+ if (__position > __s.size())
+   __throw_out_of_range_fmt(("bitset::bitset: __position " "(which is %zu) > __s.size() " "(which is %zu)")
+
+                            ,
+       __position, __s.size());
+      }
+
+      void _M_check(size_t __position, const char *__s) const
+      {
+ if (__position >= _Nb)
+   __throw_out_of_range_fmt(("%s: __position (which is %zu) " ">= _Nb (which is %zu)")
+                                   ,
+       __s, __position, _Nb);
+      }
+
+      void
+      _M_do_sanitize() noexcept
+      {
+ typedef _Sanitize<_Nb % (8 * 8)> __sanitize_type;
+ __sanitize_type::_S_do_sanitize(this->_M_hiword());
+      }
+
+
+      friend struct std::hash<bitset>;
+
+
+    public:
+# 802 "/usr/include/c++/10.2.0/bitset" 3
+      class reference
+      {
+ friend class bitset;
+
+ _WordT* _M_wp;
+ size_t _M_bpos;
+
+
+ reference();
+
+      public:
+ reference(bitset& __b, size_t __pos) noexcept
+ {
+   _M_wp = &__b._M_getword(__pos);
+   _M_bpos = _Base::_S_whichbit(__pos);
+ }
+
+
+ reference(const reference&) = default;
+
+
+ ~reference() noexcept
+ { }
+
+
+ reference&
+ operator=(bool __x) noexcept
+ {
+   if (__x)
+     *_M_wp |= _Base::_S_maskbit(_M_bpos);
+   else
+     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
+   return *this;
+ }
+
+
+ reference&
+ operator=(const reference& __j) noexcept
+ {
+   if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))
+     *_M_wp |= _Base::_S_maskbit(_M_bpos);
+   else
+     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
+   return *this;
+ }
+
+
+ bool
+ operator~() const noexcept
+ { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
+
+
+ operator bool() const noexcept
+ { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
+
+
+ reference&
+ flip() noexcept
+ {
+   *_M_wp ^= _Base::_S_maskbit(_M_bpos);
+   return *this;
+ }
+      };
+      friend class reference;
+
+
+
+      constexpr bitset() noexcept
+      { }
+
+
+
+      constexpr bitset(unsigned long long __val) noexcept
+      : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { }
+# 891 "/usr/include/c++/10.2.0/bitset" 3
+      template<class _CharT, class _Traits, class _Alloc>
+ explicit
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+        size_t __position = 0)
+ : _Base()
+ {
+   _M_check_initial_position(__s, __position);
+   _M_copy_from_string(__s, __position,
+         std::basic_string<_CharT, _Traits, _Alloc>::npos,
+         _CharT('0'), _CharT('1'));
+ }
+# 913 "/usr/include/c++/10.2.0/bitset" 3
+      template<class _CharT, class _Traits, class _Alloc>
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+        size_t __position, size_t __n)
+ : _Base()
+ {
+   _M_check_initial_position(__s, __position);
+   _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1'));
+ }
+
+
+
+      template<class _CharT, class _Traits, class _Alloc>
+ bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,
+        size_t __position, size_t __n,
+        _CharT __zero, _CharT __one = _CharT('1'))
+ : _Base()
+ {
+   _M_check_initial_position(__s, __position);
+   _M_copy_from_string(__s, __position, __n, __zero, __one);
+ }
+# 944 "/usr/include/c++/10.2.0/bitset" 3
+      template<typename _CharT>
+        explicit
+        bitset(const _CharT* __str,
+        typename std::basic_string<_CharT>::size_type __n
+        = std::basic_string<_CharT>::npos,
+        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
+        : _Base()
+        {
+   if (!__str)
+     __throw_logic_error(("bitset::bitset(const _CharT*, ...)"));
+
+   if (__n == std::basic_string<_CharT>::npos)
+     __n = std::char_traits<_CharT>::length(__str);
+   _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0,
+            __n, __zero,
+            __one);
+ }
+# 971 "/usr/include/c++/10.2.0/bitset" 3
+      bitset<_Nb>&
+      operator&=(const bitset<_Nb>& __rhs) noexcept
+      {
+ this->_M_do_and(__rhs);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      operator|=(const bitset<_Nb>& __rhs) noexcept
+      {
+ this->_M_do_or(__rhs);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      operator^=(const bitset<_Nb>& __rhs) noexcept
+      {
+ this->_M_do_xor(__rhs);
+ return *this;
+      }
+# 1000 "/usr/include/c++/10.2.0/bitset" 3
+      bitset<_Nb>&
+      operator<<=(size_t __position) noexcept
+      {
+ if (__builtin_expect(__position < _Nb, 1))
+   {
+     this->_M_do_left_shift(__position);
+     this->_M_do_sanitize();
+   }
+ else
+   this->_M_do_reset();
+ return *this;
+      }
+
+      bitset<_Nb>&
+      operator>>=(size_t __position) noexcept
+      {
+ if (__builtin_expect(__position < _Nb, 1))
+   {
+     this->_M_do_right_shift(__position);
+     this->_M_do_sanitize();
+   }
+ else
+   this->_M_do_reset();
+ return *this;
+      }
+# 1033 "/usr/include/c++/10.2.0/bitset" 3
+      bitset<_Nb>&
+      _Unchecked_set(size_t __pos) noexcept
+      {
+ this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      _Unchecked_set(size_t __pos, int __val) noexcept
+      {
+ if (__val)
+   this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+ else
+   this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      _Unchecked_reset(size_t __pos) noexcept
+      {
+ this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+ return *this;
+      }
+
+      bitset<_Nb>&
+      _Unchecked_flip(size_t __pos) noexcept
+      {
+ this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
+ return *this;
+      }
+
+      constexpr bool
+      _Unchecked_test(size_t __pos) const noexcept
+      { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
+  != static_cast<_WordT>(0)); }
+
+
+
+
+
+
+      bitset<_Nb>&
+      set() noexcept
+      {
+ this->_M_do_set();
+ this->_M_do_sanitize();
+ return *this;
+      }
+
+
+
+
+
+
+
+      bitset<_Nb>&
+      set(size_t __position, bool __val = true)
+      {
+ this->_M_check(__position, ("bitset::set"));
+ return _Unchecked_set(__position, __val);
+      }
+
+
+
+
+      bitset<_Nb>&
+      reset() noexcept
+      {
+ this->_M_do_reset();
+ return *this;
+      }
+# 1112 "/usr/include/c++/10.2.0/bitset" 3
+      bitset<_Nb>&
+      reset(size_t __position)
+      {
+ this->_M_check(__position, ("bitset::reset"));
+ return _Unchecked_reset(__position);
+      }
+
+
+
+
+      bitset<_Nb>&
+      flip() noexcept
+      {
+ this->_M_do_flip();
+ this->_M_do_sanitize();
+ return *this;
+      }
+
+
+
+
+
+
+      bitset<_Nb>&
+      flip(size_t __position)
+      {
+ this->_M_check(__position, ("bitset::flip"));
+ return _Unchecked_flip(__position);
+      }
+
+
+      bitset<_Nb>
+      operator~() const noexcept
+      { return bitset<_Nb>(*this).flip(); }
+# 1162 "/usr/include/c++/10.2.0/bitset" 3
+      reference
+      operator[](size_t __position)
+      { return reference(*this, __position); }
+
+      constexpr bool
+      operator[](size_t __position) const
+      { return _Unchecked_test(__position); }
+# 1177 "/usr/include/c++/10.2.0/bitset" 3
+      unsigned long
+      to_ulong() const
+      { return this->_M_do_to_ulong(); }
+
+
+      unsigned long long
+      to_ullong() const
+      { return this->_M_do_to_ullong(); }
+# 1195 "/usr/include/c++/10.2.0/bitset" 3
+      template<class _CharT, class _Traits, class _Alloc>
+ std::basic_string<_CharT, _Traits, _Alloc>
+ to_string() const
+ {
+   std::basic_string<_CharT, _Traits, _Alloc> __result;
+   _M_copy_to_string(__result, _CharT('0'), _CharT('1'));
+   return __result;
+ }
+
+
+
+      template<class _CharT, class _Traits, class _Alloc>
+ std::basic_string<_CharT, _Traits, _Alloc>
+ to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+ {
+   std::basic_string<_CharT, _Traits, _Alloc> __result;
+   _M_copy_to_string(__result, __zero, __one);
+   return __result;
+ }
+
+
+
+      template<class _CharT, class _Traits>
+ std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+ to_string() const
+ { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
+
+
+
+      template<class _CharT, class _Traits>
+ std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
+ to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+ { return to_string<_CharT, _Traits,
+                    std::allocator<_CharT> >(__zero, __one); }
+
+      template<class _CharT>
+ std::basic_string<_CharT, std::char_traits<_CharT>,
+                   std::allocator<_CharT> >
+ to_string() const
+ {
+   return to_string<_CharT, std::char_traits<_CharT>,
+                    std::allocator<_CharT> >();
+ }
+
+      template<class _CharT>
+ std::basic_string<_CharT, std::char_traits<_CharT>,
+                   std::allocator<_CharT> >
+ to_string(_CharT __zero, _CharT __one = _CharT('1')) const
+ {
+   return to_string<_CharT, std::char_traits<_CharT>,
+                    std::allocator<_CharT> >(__zero, __one);
+ }
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string() const
+      {
+ return to_string<char, std::char_traits<char>,
+                  std::allocator<char> >();
+      }
+
+      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+      to_string(char __zero, char __one = '1') const
+      {
+ return to_string<char, std::char_traits<char>,
+                  std::allocator<char> >(__zero, __one);
+      }
+
+
+      template<class _CharT, class _Traits>
+        void
+        _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t,
+    _CharT, _CharT);
+
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+ _M_copy_from_string(const std::basic_string<_CharT,
+       _Traits, _Alloc>& __s, size_t __pos, size_t __n,
+       _CharT __zero, _CharT __one)
+ { _M_copy_from_ptr<_CharT, _Traits>(__s.data(), __s.size(), __pos, __n,
+         __zero, __one); }
+
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+        _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&,
+     _CharT, _CharT) const;
+
+
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+ _M_copy_from_string(const std::basic_string<_CharT,
+       _Traits, _Alloc>& __s, size_t __pos, size_t __n)
+ { _M_copy_from_string(__s, __pos, __n, _CharT('0'), _CharT('1')); }
+
+      template<class _CharT, class _Traits, class _Alloc>
+ void
+        _M_copy_to_string(std::basic_string<_CharT, _Traits,_Alloc>& __s) const
+ { _M_copy_to_string(__s, _CharT('0'), _CharT('1')); }
+
+
+      size_t
+      count() const noexcept
+      { return this->_M_do_count(); }
+
+
+      constexpr size_t
+      size() const noexcept
+      { return _Nb; }
+
+
+
+      bool
+      operator==(const bitset<_Nb>& __rhs) const noexcept
+      { return this->_M_is_equal(__rhs); }
+
+
+      bool
+      operator!=(const bitset<_Nb>& __rhs) const noexcept
+      { return !this->_M_is_equal(__rhs); }
+# 1322 "/usr/include/c++/10.2.0/bitset" 3
+      bool
+      test(size_t __position) const
+      {
+ this->_M_check(__position, ("bitset::test"));
+ return _Unchecked_test(__position);
+      }
+
+
+
+
+
+
+
+      bool
+      all() const noexcept
+      { return this->template _M_are_all<_Nb>(); }
+
+
+
+
+
+      bool
+      any() const noexcept
+      { return this->_M_is_any(); }
+
+
+
+
+
+      bool
+      none() const noexcept
+      { return !this->_M_is_any(); }
+
+
+
+      bitset<_Nb>
+      operator<<(size_t __position) const noexcept
+      { return bitset<_Nb>(*this) <<= __position; }
+
+      bitset<_Nb>
+      operator>>(size_t __position) const noexcept
+      { return bitset<_Nb>(*this) >>= __position; }
+# 1372 "/usr/include/c++/10.2.0/bitset" 3
+      size_t
+      _Find_first() const noexcept
+      { return this->_M_do_find_first(_Nb); }
+# 1383 "/usr/include/c++/10.2.0/bitset" 3
+      size_t
+      _Find_next(size_t __prev) const noexcept
+      { return this->_M_do_find_next(__prev, _Nb); }
+    };
+
+
+  template<size_t _Nb>
+    template<class _CharT, class _Traits>
+      void
+      bitset<_Nb>::
+      _M_copy_from_ptr(const _CharT* __s, size_t __len,
+         size_t __pos, size_t __n, _CharT __zero, _CharT __one)
+      {
+ reset();
+ const size_t __nbits = std::min(_Nb, std::min(__n, size_t(__len - __pos)));
+ for (size_t __i = __nbits; __i > 0; --__i)
+   {
+     const _CharT __c = __s[__pos + __nbits - __i];
+     if (_Traits::eq(__c, __zero))
+       ;
+     else if (_Traits::eq(__c, __one))
+       _Unchecked_set(__i - 1);
+     else
+       __throw_invalid_argument(("bitset::_M_copy_from_ptr"));
+   }
+      }
+
+  template<size_t _Nb>
+    template<class _CharT, class _Traits, class _Alloc>
+      void
+      bitset<_Nb>::
+      _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s,
+   _CharT __zero, _CharT __one) const
+      {
+ __s.assign(_Nb, __zero);
+ for (size_t __i = _Nb; __i > 0; --__i)
+   if (_Unchecked_test(__i - 1))
+     _Traits::assign(__s[_Nb - __i], __one);
+      }
+# 1433 "/usr/include/c++/10.2.0/bitset" 3
+  template<size_t _Nb>
+    inline bitset<_Nb>
+    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
+    {
+      bitset<_Nb> __result(__x);
+      __result &= __y;
+      return __result;
+    }
+
+  template<size_t _Nb>
+    inline bitset<_Nb>
+    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
+    {
+      bitset<_Nb> __result(__x);
+      __result |= __y;
+      return __result;
+    }
+
+  template <size_t _Nb>
+    inline bitset<_Nb>
+    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
+    {
+      bitset<_Nb> __result(__x);
+      __result ^= __y;
+      return __result;
+    }
+# 1470 "/usr/include/c++/10.2.0/bitset" 3
+  template<class _CharT, class _Traits, size_t _Nb>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
+    {
+      typedef typename _Traits::char_type char_type;
+      typedef std::basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::ios_base __ios_base;
+
+      std::basic_string<_CharT, _Traits> __tmp;
+      __tmp.reserve(_Nb);
+
+
+
+      const char_type __zero = __is.widen('0');
+      const char_type __one = __is.widen('1');
+
+      typename __ios_base::iostate __state = __ios_base::goodbit;
+      typename __istream_type::sentry __sentry(__is);
+      if (__sentry)
+ {
+   try
+     {
+       for (size_t __i = _Nb; __i > 0; --__i)
+  {
+    static typename _Traits::int_type __eof = _Traits::eof();
+
+    typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
+    if (_Traits::eq_int_type(__c1, __eof))
+      {
+        __state |= __ios_base::eofbit;
+        break;
+      }
+    else
+      {
+        const char_type __c2 = _Traits::to_char_type(__c1);
+        if (_Traits::eq(__c2, __zero))
+   __tmp.push_back(__zero);
+        else if (_Traits::eq(__c2, __one))
+   __tmp.push_back(__one);
+        else if (_Traits::
+          eq_int_type(__is.rdbuf()->sputbackc(__c2),
+        __eof))
+   {
+     __state |= __ios_base::failbit;
+     break;
+   }
+      }
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __is._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __is._M_setstate(__ios_base::badbit); }
+ }
+
+      if (__tmp.empty() && _Nb)
+ __state |= __ios_base::failbit;
+      else
+ __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb,
+    __zero, __one);
+      if (__state)
+ __is.setstate(__state);
+      return __is;
+    }
+
+  template <class _CharT, class _Traits, size_t _Nb>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const bitset<_Nb>& __x)
+    {
+      std::basic_string<_CharT, _Traits> __tmp;
+
+
+
+      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc());
+      __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1'));
+      return __os << __tmp;
+    }
+
+
+
+}
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template<size_t _Nb>
+    struct hash<std::bitset<_Nb>>
+    : public __hash_base<size_t, std::bitset<_Nb>>
+    {
+      size_t
+      operator()(const std::bitset<_Nb>& __b) const noexcept
+      {
+ const size_t __clength = (_Nb + 8 - 1) / 8;
+ return std::_Hash_impl::hash(__b._M_getdata(), __clength);
+      }
+    };
+
+  template<>
+    struct hash<std::bitset<0>>
+    : public __hash_base<size_t, std::bitset<0>>
+    {
+      size_t
+      operator()(const std::bitset<0>&) const noexcept
+      { return 0; }
+    };
+
+
+}
+# 25 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h" 2
+# 48 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h"
+
+# 48 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/../peep/Peep.h"
+constexpr auto PEEP_CLEARANCE_HEIGHT = 4 * COORDS_Z_STEP;
+
+class Formatter;
+struct TileElement;
+struct Ride;
+namespace GameActions
+{
+    class Result;
+}
+using ParkEntranceIndex = uint8_t;
+
+enum class StaffType : uint8_t
+{
+    Handyman,
+    Mechanic,
+    Security,
+    Entertainer,
+
+    Count
+};
+
+enum class PeepThoughtType : uint8_t
+{
+    CantAffordRide = 0,
+    SpentMoney = 1,
+    Sick = 2,
+    VerySick = 3,
+    MoreThrilling = 4,
+    Intense = 5,
+    HaventFinished = 6,
+    Sickening = 7,
+    BadValue = 8,
+    GoHome = 9,
+    GoodValue = 10,
+    AlreadyGot = 11,
+    CantAffordItem = 12,
+    NotHungry = 13,
+    NotThirsty = 14,
+    Drowning = 15,
+    Lost = 16,
+    WasGreat = 17,
+    QueuingAges = 18,
+    Tired = 19,
+    Hungry = 20,
+    Thirsty = 21,
+    Toilet = 22,
+    CantFind = 23,
+    NotPaying = 24,
+    NotWhileRaining = 25,
+    BadLitter = 26,
+    CantFindExit = 27,
+    GetOff = 28,
+    GetOut = 29,
+    NotSafe = 30,
+    PathDisgusting = 31,
+    Crowded = 32,
+    Vandalism = 33,
+    Scenery = 34,
+    VeryClean = 35,
+    Fountains = 36,
+    Music = 37,
+    Balloon = 38,
+    Toy = 39,
+    Map = 40,
+    Photo = 41,
+    Umbrella = 42,
+    Drink = 43,
+    Burger = 44,
+    Chips = 45,
+    IceCream = 46,
+    Candyfloss = 47,
+
+    Pizza = 51,
+
+    Popcorn = 53,
+    HotDog = 54,
+    Tentacle = 55,
+    Hat = 56,
+    ToffeeApple = 57,
+    Tshirt = 58,
+    Doughnut = 59,
+    Coffee = 60,
+
+    Chicken = 62,
+    Lemonade = 63,
+
+    Wow = 67,
+
+    Wow2 = 70,
+    Watched = 71,
+    BalloonMuch = 72,
+    ToyMuch = 73,
+    MapMuch = 74,
+    PhotoMuch = 75,
+    UmbrellaMuch = 76,
+    DrinkMuch = 77,
+    BurgerMuch = 78,
+    ChipsMuch = 79,
+    IceCreamMuch = 80,
+    CandyflossMuch = 81,
+
+    PizzaMuch = 85,
+
+    PopcornMuch = 87,
+    HotDogMuch = 88,
+    TentacleMuch = 89,
+    HatMuch = 90,
+    ToffeeAppleMuch = 91,
+    TshirtMuch = 92,
+    DoughnutMuch = 93,
+    CoffeeMuch = 94,
+
+    ChickenMuch = 96,
+    LemonadeMuch = 97,
+
+    Photo2 = 104,
+    Photo3 = 105,
+    Photo4 = 106,
+    Pretzel = 107,
+    HotChocolate = 108,
+    IcedTea = 109,
+    FunnelCake = 110,
+    Sunglasses = 111,
+    BeefNoodles = 112,
+    FriedRiceNoodles = 113,
+    WontonSoup = 114,
+    MeatballSoup = 115,
+    FruitJuice = 116,
+    SoybeanMilk = 117,
+    Sujongkwa = 118,
+    SubSandwich = 119,
+    Cookie = 120,
+
+    RoastSausage = 124,
+
+    Photo2Much = 136,
+    Photo3Much = 137,
+    Photo4Much = 138,
+    PretzelMuch = 139,
+    HotChocolateMuch = 140,
+    IcedTeaMuch = 141,
+    FunnelCakeMuch = 142,
+    SunglassesMuch = 143,
+    BeefNoodlesMuch = 144,
+    FriedRiceNoodlesMuch = 145,
+    WontonSoupMuch = 146,
+    MeatballSoupMuch = 147,
+    FruitJuiceMuch = 148,
+    SoybeanMilkMuch = 149,
+    SujongkwaMuch = 150,
+    SubSandwichMuch = 151,
+    CookieMuch = 152,
+
+    RoastSausageMuch = 156,
+
+    Help = 168,
+    RunningOut = 169,
+    NewRide = 170,
+    NiceRideDeprecated = 171,
+    ExcitedDeprecated = 172,
+    HereWeAre = 173,
+
+    None = 255
+};
+
+enum class PeepState : uint8_t
+{
+    Falling = 0,
+    One = 1,
+    QueuingFront = 2,
+    OnRide = 3,
+    LeavingRide = 4,
+    Walking = 5,
+    Queuing = 6,
+    EnteringRide = 7,
+    Sitting = 8,
+    Picked = 9,
+    Patrolling = 10,
+    Mowing = 11,
+    Sweeping = 12,
+    EnteringPark = 13,
+    LeavingPark = 14,
+    Answering = 15,
+    Fixing = 16,
+    Buying = 17,
+    Watching = 18,
+    EmptyingBin = 19,
+    UsingBin = 20,
+    Watering = 21,
+    HeadingToInspection = 22,
+    Inspecting = 23
+};
+
+enum class PeepSittingSubState : uint8_t
+{
+    TryingToSit,
+    SatDown
+};
+
+enum class PeepRideSubState : uint8_t
+{
+    AtEntrance = 0,
+    InEntrance = 1,
+    FreeVehicleCheck = 2,
+    LeaveEntrance = 3,
+    ApproachVehicle = 4,
+    EnterVehicle = 5,
+    OnRide = 6,
+    LeaveVehicle = 7,
+    ApproachExit = 8,
+    InExit = 9,
+    InQueue = 10,
+    AtQueueFront = 11,
+    ApproachVehicleWaypoints = 12,
+    ApproachExitWaypoints = 13,
+    ApproachSpiralSlide = 14,
+    OnSpiralSlide = 15,
+    LeaveSpiralSlide = 16,
+    MazePathfinding = 17,
+    LeaveExit = 18,
+    ApproachShop = 19,
+    InteractShop = 20,
+    LeaveShop = 21
+};
+
+enum class PeepUsingBinSubState : uint8_t
+{
+    WalkingToBin = 0,
+    GoingBack,
+};
+
+enum class PeepActionType : uint8_t
+{
+    CheckTime = 0,
+
+    EatFood = 1,
+    ShakeHead = 2,
+    EmptyPockets = 3,
+    SittingEatFood = 4,
+    SittingCheckWatch = 4,
+    SittingLookAroundLeft = 5,
+    SittingLookAroundRight = 6,
+    Wow = 7,
+    ThrowUp = 8,
+    Jump = 9,
+    StaffSweep = 10,
+    Drowning = 11,
+    StaffAnswerCall = 12,
+    StaffAnswerCall2 = 13,
+    StaffCheckboard = 14,
+    StaffFix = 15,
+    StaffFix2 = 16,
+    StaffFixGround = 17,
+    StaffFix3 = 18,
+    StaffWatering = 19,
+    Joy = 20,
+    ReadMap = 21,
+    Wave = 22,
+    StaffEmptyBin = 23,
+    Wave2 = 24,
+    TakePhoto = 25,
+    Clap = 26,
+    Disgust = 27,
+    DrawPicture = 28,
+    BeingWatched = 29,
+    WithdrawMoney = 30,
+
+    None1 = 254,
+    None2 = 255,
+};
+
+enum class PeepActionSpriteType : uint8_t
+{
+    None = 0,
+    CheckTime = 1,
+    WatchRide = 2,
+    EatFood = 3,
+    ShakeHead = 4,
+    EmptyPockets = 5,
+    HoldMat = 6,
+    SittingIdle = 7,
+    SittingEatFood = 8,
+    SittingLookAroundLeft = 9,
+    SittingLookAroundRight = 10,
+    Ui = 11,
+    StaffMower = 12,
+    Wow = 13,
+    ThrowUp = 14,
+    Jump = 15,
+    StaffSweep = 16,
+    Drowning = 17,
+    StaffAnswerCall = 18,
+    StaffAnswerCall2 = 19,
+    StaffCheckboard = 20,
+    StaffFix = 21,
+    StaffFix2 = 22,
+    StaffFixGround = 23,
+    StaffFix3 = 24,
+    StaffWatering = 25,
+    Joy = 26,
+    ReadMap = 27,
+    Wave = 28,
+    StaffEmptyBin = 29,
+    Wave2 = 30,
+    TakePhoto = 31,
+    Clap = 32,
+    Disgust = 33,
+    DrawPicture = 34,
+    BeingWatched = 35,
+    WithdrawMoney = 36,
+
+    Invalid = 255
+};
+
+enum PeepFlags : uint32_t
+{
+    PEEP_FLAGS_LEAVING_PARK = (1 << 0),
+    PEEP_FLAGS_SLOW_WALK = (1 << 1),
+    PEEP_FLAGS_2 = (1 << 2),
+    PEEP_FLAGS_TRACKING = (1 << 3),
+    PEEP_FLAGS_WAVING = (1 << 4),
+    PEEP_FLAGS_HAS_PAID_FOR_PARK_ENTRY = (1 << 5),
+    PEEP_FLAGS_PHOTO = (1 << 6),
+    PEEP_FLAGS_PAINTING = (1 << 7),
+    PEEP_FLAGS_WOW = (1 << 8),
+    PEEP_FLAGS_LITTER = (1 << 9),
+    PEEP_FLAGS_LOST = (1 << 10),
+    PEEP_FLAGS_HUNGER = (1 << 11),
+    PEEP_FLAGS_TOILET = (1 << 12),
+    PEEP_FLAGS_CROWDED = (1 << 13),
+    PEEP_FLAGS_HAPPINESS = (1 << 14),
+    PEEP_FLAGS_NAUSEA = (1 << 15),
+    PEEP_FLAGS_PURPLE = (1 << 16),
+    PEEP_FLAGS_PIZZA = (1 << 17),
+    PEEP_FLAGS_EXPLODE = (1 << 18),
+    PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE = (1 << 19),
+    PEEP_FLAGS_PARK_ENTRANCE_CHOSEN = (1 << 20),
+    PEEP_FLAGS_21 = (1 << 21),
+    PEEP_FLAGS_CONTAGIOUS = (1 << 22),
+    PEEP_FLAGS_JOY = (1 << 23),
+    PEEP_FLAGS_ANGRY = (1 << 24),
+    PEEP_FLAGS_ICE_CREAM = (1 << 25),
+    PEEP_FLAGS_NICE_RIDE_DEPRECATED = (1 << 26),
+
+    PEEP_FLAGS_INTAMIN_DEPRECATED = (1 << 27),
+
+    PEEP_FLAGS_HERE_WE_ARE = (1 << 28),
+    PEEP_FLAGS_TWITCH_DEPRECATED = (1u << 31),
+};
+
+enum PeepNextFlags
+{
+    PEEP_NEXT_FLAG_DIRECTION_MASK = 0x3,
+    PEEP_NEXT_FLAG_IS_SLOPED = (1 << 2),
+    PEEP_NEXT_FLAG_IS_SURFACE = (1 << 3),
+    PEEP_NEXT_FLAG_UNUSED = (1 << 4),
+};
+
+enum class PeepNauseaTolerance : uint8_t
+{
+    None,
+    Low,
+    Average,
+    High
+};
+
+enum class PeepSpriteType : uint8_t
+{
+    Normal = 0,
+    Handyman = 1,
+    Mechanic = 2,
+    Security = 3,
+    EntertainerPanda = 4,
+    EntertainerTiger = 5,
+    EntertainerElephant = 6,
+    EntertainerRoman = 7,
+    EntertainerGorilla = 8,
+    EntertainerSnowman = 9,
+    EntertainerKnight = 10,
+    EntertainerAstronaut = 11,
+    EntertainerBandit = 12,
+    EntertainerSheriff = 13,
+    EntertainerPirate = 14,
+    IceCream = 15,
+    Chips = 16,
+    Burger = 17,
+    Drink = 18,
+    Balloon = 19,
+    Candyfloss = 20,
+    Umbrella = 21,
+    Pizza = 22,
+    SecurityAlt = 23,
+    Popcorn = 24,
+    ArmsCrossed = 25,
+    HeadDown = 26,
+    Nauseous = 27,
+    VeryNauseous = 28,
+    RequireToilet = 29,
+    Hat = 30,
+    HotDog = 31,
+    Tentacle = 32,
+    ToffeeApple = 33,
+    Doughnut = 34,
+    Coffee = 35,
+    Chicken = 36,
+    Lemonade = 37,
+    Watching = 38,
+    Pretzel = 39,
+    Sunglasses = 40,
+    SuJongkwa = 41,
+    Juice = 42,
+    FunnelCake = 43,
+    Noodles = 44,
+    Sausage = 45,
+    Soup = 46,
+    Sandwich = 47,
+    Count = 48,
+
+    Invalid = 255
+};
+
+
+enum PeepInvalidate
+{
+    PEEP_INVALIDATE_PEEP_THOUGHTS = 1,
+    PEEP_INVALIDATE_PEEP_STATS = 1 << 1,
+    PEEP_INVALIDATE_PEEP_2 = 1 << 2,
+    PEEP_INVALIDATE_PEEP_INVENTORY = 1 << 3,
+    PEEP_INVALIDATE_STAFF_STATS = 1 << 4,
+    PEEP_INVALIDATE_PEEP_ACTION = 1 << 5,
+};
+
+
+enum PeepRideDecision
+{
+    PEEP_RIDE_DECISION_AT_QUEUE = 1,
+    PEEP_RIDE_DECISION_THINKING = 1 << 2,
+};
+
+struct rct_peep_thought
+{
+    PeepThoughtType type;
+    uint8_t item;
+    uint8_t freshness;
+    uint8_t fresh_timeout;
+};
+
+struct Guest;
+struct Staff;
+
+struct IntensityRange
+{
+private:
+    uint8_t _value{};
+
+public:
+    explicit IntensityRange(uint8_t value)
+        : _value(value)
+    {
+    }
+
+    IntensityRange(uint8_t min, uint8_t max)
+        : _value(std::min<uint8_t>(min, 15) | (std::min<uint8_t>(max, 15) << 4))
+    {
+    }
+
+    uint8_t GetMinimum() const
+    {
+        return _value & 0x0F;
+    }
+
+    uint8_t GetMaximum() const
+    {
+        return _value >> 4;
+    }
+
+    IntensityRange WithMinimum(uint8_t value) const
+    {
+        return IntensityRange(value, GetMaximum());
+    }
+
+    IntensityRange WithMaximum(uint8_t value) const
+    {
+        return IntensityRange(GetMinimum(), value);
+    }
+
+    explicit operator uint8_t() const
+    {
+        return _value;
+    }
+
+    friend bool operator==(const IntensityRange& lhs, const IntensityRange& rhs)
+    {
+        return lhs._value == rhs._value;
+    }
+
+    friend bool operator!=(const IntensityRange& lhs, const IntensityRange& rhs)
+    {
+        return lhs._value != rhs._value;
+    }
+};
+
+struct Peep : SpriteBase
+{
+    char* Name;
+    CoordsXYZ NextLoc;
+    uint8_t NextFlags;
+    bool OutsideOfPark;
+    PeepState State;
+    union
+    {
+        uint8_t SubState;
+        PeepSittingSubState SittingSubState;
+        PeepRideSubState RideSubState;
+        PeepUsingBinSubState UsingBinSubState;
+    };
+    PeepSpriteType SpriteType;
+    union
+    {
+        StaffType AssignedStaffType;
+        uint8_t GuestNumRides;
+    };
+    uint8_t TshirtColour;
+    uint8_t TrousersColour;
+    uint16_t DestinationX;
+    uint16_t DestinationY;
+    uint8_t DestinationTolerance;
+    uint8_t Var37;
+    uint8_t Energy;
+    uint8_t EnergyTarget;
+    uint8_t Happiness;
+    uint8_t HappinessTarget;
+    uint8_t Nausea;
+    uint8_t NauseaTarget;
+    uint8_t Hunger;
+    uint8_t Thirst;
+    uint8_t Toilet;
+    uint8_t Mass;
+    uint8_t TimeToConsume;
+    IntensityRange Intensity{ 0 };
+    PeepNauseaTolerance NauseaTolerance;
+    uint8_t WindowInvalidateFlags;
+    money16 PaidOnDrink;
+    uint8_t RideTypesBeenOn[16];
+    ride_id_t Photo2RideRef;
+    ride_id_t Photo3RideRef;
+    ride_id_t Photo4RideRef;
+    union
+    {
+        ride_id_t CurrentRide;
+        ParkEntranceIndex ChosenParkEntrance;
+    };
+    StationIndex CurrentRideStation;
+    uint8_t CurrentTrain;
+    union
+    {
+        struct
+        {
+            uint8_t CurrentCar;
+            uint8_t CurrentSeat;
+        };
+        uint16_t TimeToSitdown;
+        struct
+        {
+            uint8_t TimeToStand;
+            uint8_t StandingFlags;
+        };
+    };
+
+    uint8_t SpecialSprite;
+    PeepActionSpriteType ActionSpriteType;
+
+
+    PeepActionSpriteType NextActionSpriteType;
+    uint8_t ActionSpriteImageOffset;
+    PeepActionType Action;
+    uint8_t ActionFrame;
+    uint8_t StepProgress;
+    union
+    {
+        uint16_t MechanicTimeSinceCall;
+        uint16_t GuestNextInQueue;
+    };
+    union
+    {
+        uint8_t MazeLastEdge;
+        Direction PeepDirection;
+    };
+    ride_id_t InteractionRideIndex;
+    uint16_t TimeInQueue;
+    ride_id_t RidesBeenOn[32];
+
+
+    uint32_t Id;
+    money32 CashInPocket;
+    money32 CashSpent;
+    union
+    {
+        int32_t ParkEntryTime;
+        int32_t HireDate;
+    };
+    int8_t RejoinQueueTimeout;
+    ride_id_t PreviousRide;
+    uint16_t PreviousRideTimeOut;
+    rct_peep_thought Thoughts[5];
+    uint8_t PathCheckOptimisation;
+    union
+    {
+        uint8_t StaffId;
+        ride_id_t GuestHeadingToRideId;
+    };
+    union
+    {
+        uint8_t StaffOrders;
+        uint8_t GuestIsLostCountdown;
+    };
+    ride_id_t Photo1RideRef;
+    uint32_t PeepFlags;
+    rct12_xyzd8 PathfindGoal;
+    rct12_xyzd8 PathfindHistory[4];
+    uint8_t WalkingFrameNum;
+
+    uint8_t LitterCount;
+    union
+    {
+        uint8_t GuestTimeOnRide;
+        uint8_t StaffMowingTimeout;
+    };
+
+    uint8_t DisgustingCount;
+    union
+    {
+        money16 PaidToEnter;
+        uint16_t StaffLawnsMown;
+        uint16_t StaffRidesFixed;
+    };
+    union
+    {
+        money16 PaidOnRides;
+        uint16_t StaffGardensWatered;
+        uint16_t StaffRidesInspected;
+    };
+    union
+    {
+        money16 PaidOnFood;
+        uint16_t StaffLitterSwept;
+        uint16_t StaffVandalsStopped;
+    };
+    union
+    {
+        money16 PaidOnSouvenirs;
+        uint16_t StaffBinsEmptied;
+    };
+    uint8_t AmountOfFood;
+    uint8_t AmountOfDrinks;
+    uint8_t AmountOfSouvenirs;
+    uint8_t VandalismSeen;
+    uint8_t VoucherType;
+    union
+    {
+        ride_id_t VoucherRideId;
+        ShopItemIndex VoucherShopItem;
+    };
+    uint8_t SurroundingsThoughtTimeout;
+    uint8_t Angriness;
+    uint8_t TimeLost;
+    uint8_t DaysInQueue;
+    uint8_t BalloonColour;
+    uint8_t UmbrellaColour;
+    uint8_t HatColour;
+    ride_id_t FavouriteRide;
+    uint8_t FavouriteRideRating;
+    uint64_t ItemFlags;
+
+public:
+    void Update();
+    std::optional<CoordsXY> UpdateAction(int16_t& xy_distance);
+    std::optional<CoordsXY> UpdateAction();
+    void SetState(PeepState new_state);
+    void Remove();
+    void UpdateCurrentActionSpriteType();
+    void SwitchToSpecialSprite(uint8_t special_sprite_id);
+    void StateReset();
+    uint8_t GetNextDirection() const;
+    bool GetNextIsSloped() const;
+    bool GetNextIsSurface() const;
+    void SetNextFlags(uint8_t next_direction, bool is_sloped, bool is_surface);
+    bool CanBePickedUp() const;
+    void Pickup();
+    void PickupAbort(int32_t old_x);
+    std::unique_ptr<GameActions::Result> Place(const TileCoordsXYZ& location, bool apply);
+    static Peep* Generate(const CoordsXYZ& coords);
+    void RemoveFromQueue();
+    void RemoveFromRide();
+    void InsertNewThought(PeepThoughtType thought_type, uint8_t thought_arguments);
+    void FormatActionTo(Formatter&) const;
+    void FormatNameTo(Formatter&) const;
+    std::string GetName() const;
+    bool SetName(std::string_view value);
+
+
+
+    void ResetPathfindGoal();
+    uint64_t GetItemFlags() const;
+    void SetItemFlags(uint64_t itemFlags);
+    void RemoveAllItems();
+    void RemoveItem(ShopItem item);
+    void GiveItem(ShopItem item);
+    bool HasItem(ShopItem peepItem) const;
+
+    void SetDestination(const CoordsXY& coords);
+    void SetDestination(const CoordsXY& coords, int32_t tolerance);
+    CoordsXY GetDestination() const;
+
+
+public:
+    bool CheckForPath();
+    void PerformNextAction(uint8_t& pathing_result);
+    void PerformNextAction(uint8_t& pathing_result, TileElement*& tile_result);
+    int32_t GetZOnSlope(int32_t tile_x, int32_t tile_y);
+    void SwitchNextActionSpriteType();
+    PeepActionSpriteType GetActionSpriteType();
+
+private:
+    void UpdateFalling();
+    void Update1();
+    void UpdatePicked();
+};
+
+struct Guest : Peep
+{
+    static constexpr auto cEntityType = EntityType::Guest;
+
+public:
+    void UpdateGuest();
+    void Tick128UpdateGuest(int32_t index);
+    int64_t GetFoodOrDrinkFlags() const;
+    int64_t GetEmptyContainerFlags() const;
+    bool HasDrink() const;
+    bool HasFoodOrDrink() const;
+    bool HasEmptyContainer() const;
+    void OnEnterRide(ride_id_t rideIndex);
+    void OnExitRide(ride_id_t rideIndex);
+    void UpdateSpriteType();
+    bool HeadingForRideOrParkExit() const;
+    void StopPurchaseThought(uint8_t ride_type);
+    void TryGetUpFromSitting();
+    void ChoseNotToGoOnRide(Ride* ride, bool peepAtRide, bool updateLastRide);
+    void PickRideToGoOn();
+    void ReadMap();
+    bool ShouldGoOnRide(Ride* ride, int32_t entranceNum, bool atQueue, bool thinking);
+    bool ShouldGoToShop(Ride* ride, bool peepAtShop);
+    bool ShouldFindBench();
+    bool UpdateWalkingFindBench();
+    bool UpdateWalkingFindBin();
+    void SpendMoney(money16& peep_expend_type, money32 amount, ExpenditureType type);
+    void SpendMoney(money32 amount, ExpenditureType type);
+    void SetHasRidden(const Ride* ride);
+    bool HasRidden(const Ride* ride) const;
+    void SetHasRiddenRideType(int32_t rideType);
+    bool HasRiddenRideType(int32_t rideType) const;
+    void SetParkEntryTime(int32_t entryTime);
+    int32_t GetParkEntryTime() const;
+    void CheckIfLost();
+    void CheckCantFindRide();
+    void CheckCantFindExit();
+    bool DecideAndBuyItem(Ride* ride, ShopItem shopItem, money32 price);
+    void SetSpriteType(PeepSpriteType new_sprite_type);
+    void HandleEasterEggName();
+    int32_t GetEasterEggNameId() const;
+    void UpdateEasterEggInteractions();
+
+private:
+    void UpdateRide();
+    void UpdateOnRide(){};
+    void UpdateWalking();
+    void UpdateQueuing();
+    void UpdateSitting();
+    void UpdateEnteringPark();
+    void UpdateLeavingPark();
+    void UpdateBuying();
+    void UpdateWatching();
+    void UpdateUsingBin();
+    void UpdateRideAtEntrance();
+    void UpdateRideAdvanceThroughEntrance();
+    void UpdateRideFreeVehicleCheck();
+    void UpdateRideFreeVehicleEnterRide(Ride* ride);
+    void UpdateRideApproachVehicle();
+    void UpdateRideEnterVehicle();
+    void UpdateRideLeaveVehicle();
+    void UpdateRideApproachExit();
+    void UpdateRideInExit();
+    void UpdateRideApproachVehicleWaypoints();
+    void UpdateRideApproachExitWaypoints();
+    void UpdateRideApproachSpiralSlide();
+    void UpdateRideOnSpiralSlide();
+    void UpdateRideLeaveSpiralSlide();
+    void UpdateRideMazePathfinding();
+    void UpdateRideLeaveExit();
+    void UpdateRideShopApproach();
+    void UpdateRideShopInteract();
+    void UpdateRideShopLeave();
+    void loc_68F9F3();
+    void loc_68FA89();
+    using easter_egg_function = void (Guest::*)(Guest* otherGuest);
+    int32_t CheckEasterEggName(int32_t index) const;
+    void ApplyEasterEggToNearbyGuests(easter_egg_function easter_egg);
+    bool GuestHasValidXY() const;
+    void GivePassingPeepsPurpleClothes(Guest* passingPeep);
+    void GivePassingPeepsPizza(Guest* passingPeep);
+    void MakePassingPeepsSick(Guest* passingPeep);
+    void GivePassingPeepsIceCream(Guest* passingPeep);
+    Ride* FindBestRideToGoOn();
+    std::bitset<255> FindRidesToGoOn();
+    bool FindVehicleToEnter(Ride* ride, std::vector<uint8_t>& car_array);
+    void GoToRideEntrance(Ride* ride);
+};
+
+struct Staff : Peep
+{
+    static constexpr auto cEntityType = EntityType::Staff;
+
+public:
+    void UpdateStaff(uint32_t stepsToTake);
+    void Tick128UpdateStaff();
+    bool IsMechanic() const;
+    bool IsPatrolAreaSet(const CoordsXY& coords) const;
+    bool IsLocationInPatrol(const CoordsXY& loc) const;
+    bool IsLocationOnPatrolEdge(const CoordsXY& loc) const;
+    bool DoPathFinding();
+    uint8_t GetCostume() const;
+    void SetCostume(uint8_t value);
+    void SetHireDate(int32_t hireDate);
+    int32_t GetHireDate() const;
+
+    bool CanIgnoreWideFlag(const CoordsXYZ& staffPos, TileElement* path) const;
+
+    static void ResetStats();
+
+private:
+    void UpdatePatrolling();
+    void UpdateMowing();
+    void UpdateSweeping();
+    void UpdateEmptyingBin();
+    void UpdateWatering();
+    void UpdateAnswering();
+    void UpdateFixing(int32_t steps);
+    bool UpdateFixingEnterStation(Ride* ride) const;
+    bool UpdateFixingMoveToBrokenDownVehicle(bool firstRun, const Ride* ride);
+    bool UpdateFixingFixVehicle(bool firstRun, const Ride* ride);
+    bool UpdateFixingFixVehicleMalfunction(bool firstRun, const Ride* ride);
+    bool UpdateFixingMoveToStationEnd(bool firstRun, const Ride* ride);
+    bool UpdateFixingFixStationEnd(bool firstRun);
+    bool UpdateFixingMoveToStationStart(bool firstRun, const Ride* ride);
+    bool UpdateFixingFixStationStart(bool firstRun, const Ride* ride);
+    bool UpdateFixingFixStationBrakes(bool firstRun, Ride* ride);
+    bool UpdateFixingMoveToStationExit(bool firstRun, const Ride* ride);
+    bool UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride* ride);
+    bool UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride* ride);
+    void UpdateRideInspected(ride_id_t rideIndex);
+    void UpdateHeadingToInspect();
+
+    bool DoHandymanPathFinding();
+    bool DoMechanicPathFinding();
+    bool DoEntertainerPathFinding();
+    bool DoMiscPathFinding();
+
+    Direction HandymanDirectionRandSurface(uint8_t validDirections) const;
+
+    void EntertainerUpdateNearbyPeeps() const;
+
+    uint8_t GetValidPatrolDirections(const CoordsXY& loc) const;
+    Direction HandymanDirectionToNearestLitter() const;
+    uint8_t HandymanDirectionToUncutGrass(uint8_t valid_directions) const;
+    Direction DirectionSurface(Direction initialDirection) const;
+    Direction DirectionPath(uint8_t validDirections, PathElement* pathElement) const;
+    Direction MechanicDirectionSurface() const;
+    Direction MechanicDirectionPathRand(uint8_t pathDirections) const;
+    Direction MechanicDirectionPath(uint8_t validDirections, PathElement* pathElement);
+    bool UpdatePatrollingFindWatering();
+    bool UpdatePatrollingFindBin();
+    bool UpdatePatrollingFindSweeping();
+    bool UpdatePatrollingFindGrass();
+};
+
+static_assert(sizeof(Peep) <= 512);
+
+struct rct_sprite_bounds
+{
+    uint8_t sprite_width;
+    uint8_t sprite_height_negative;
+    uint8_t sprite_height_positive;
+};
+
+struct rct_peep_animation
+{
+    uint32_t base_image;
+    size_t num_frames;
+    const uint8_t* frame_offsets;
+};
+
+struct rct_peep_animation_entry
+{
+    const rct_peep_animation* sprite_animation;
+    const rct_sprite_bounds* sprite_bounds;
+};
+
+enum
+{
+    EASTEREGG_PEEP_NAME_MICHAEL_SCHUMACHER,
+    EASTEREGG_PEEP_NAME_JACQUES_VILLENEUVE,
+    EASTEREGG_PEEP_NAME_DAMON_HILL,
+    EASTEREGG_PEEP_NAME_MR_BEAN,
+    EASTEREGG_PEEP_NAME_CHRIS_SAWYER,
+    EASTEREGG_PEEP_NAME_KATIE_BRAYSHAW,
+    EASTEREGG_PEEP_NAME_MELANIE_WARN,
+    EASTEREGG_PEEP_NAME_SIMON_FOSTER,
+    EASTEREGG_PEEP_NAME_JOHN_WARDLEY,
+    EASTEREGG_PEEP_NAME_LISA_STIRLING,
+    EASTEREGG_PEEP_NAME_DONALD_MACRAE,
+    EASTEREGG_PEEP_NAME_KATHERINE_MCGOWAN,
+    EASTEREGG_PEEP_NAME_FRANCES_MCGOWAN,
+    EASTEREGG_PEEP_NAME_CORINA_MASSOURA,
+    EASTEREGG_PEEP_NAME_CAROL_YOUNG,
+    EASTEREGG_PEEP_NAME_MIA_SHERIDAN,
+    EASTEREGG_PEEP_NAME_KATIE_RODGER,
+    EASTEREGG_PEEP_NAME_EMMA_GARRELL,
+    EASTEREGG_PEEP_NAME_JOANNE_BARTON,
+    EASTEREGG_PEEP_NAME_FELICITY_ANDERSON,
+    EASTEREGG_PEEP_NAME_KATIE_SMITH,
+    EASTEREGG_PEEP_NAME_EILIDH_BELL,
+    EASTEREGG_PEEP_NAME_NANCY_STILLWAGON,
+    EASTEREGG_PEEP_NAME_DAVID_ELLIS
+};
+
+enum
+{
+    PATHING_DESTINATION_REACHED = 1 << 0,
+    PATHING_OUTSIDE_PARK = 1 << 1,
+    PATHING_RIDE_EXIT = 1 << 2,
+    PATHING_RIDE_ENTRANCE = 1 << 3,
+};
+
+
+extern const rct_peep_animation_entry g_peep_animation_entries[EnumValue(PeepSpriteType::Count)];
+extern const bool gSpriteTypeToSlowWalkMap[48];
+
+extern uint8_t gGuestChangeModifier;
+extern uint32_t gNumGuestsInPark;
+extern uint32_t gNumGuestsInParkLastWeek;
+extern uint32_t gNumGuestsHeadingForPark;
+
+extern money16 gGuestInitialCash;
+extern uint8_t gGuestInitialHappiness;
+extern uint8_t gGuestInitialHunger;
+extern uint8_t gGuestInitialThirst;
+
+extern uint32_t gNextGuestNumber;
+
+extern uint8_t gPeepWarningThrottle[16];
+
+Peep* try_get_guest(uint16_t spriteIndex);
+int32_t peep_get_staff_count();
+void peep_update_all();
+void peep_problem_warnings_update();
+void peep_stop_crowd_noise();
+void peep_update_crowd_noise();
+void peep_update_days_in_queue();
+void peep_applause();
+void peep_thought_set_format_args(const rct_peep_thought* thought, Formatter& ft);
+int32_t get_peep_face_sprite_small(Peep* peep);
+int32_t get_peep_face_sprite_large(Peep* peep);
+void peep_sprite_remove(Peep* peep);
+
+void peep_window_state_update(Peep* peep);
+void peep_decrement_num_riders(Peep* peep);
+
+void peep_set_map_tooltip(Peep* peep);
+int32_t peep_compare(const uint16_t sprite_index_a, const uint16_t sprite_index_b);
+
+void peep_update_names(bool realNames);
+
+void guest_set_name(uint16_t spriteIndex, const char* name);
+
+void increment_guests_in_park();
+void increment_guests_heading_for_park();
+void decrement_guests_in_park();
+void decrement_guests_heading_for_park();
+
+rct_string_id get_real_name_string_id_from_id(uint32_t id);
+
+inline const rct_peep_animation& GetPeepAnimation(
+    PeepSpriteType spriteType, PeepActionSpriteType actionSpriteType = PeepActionSpriteType::None)
+{
+    return g_peep_animation_entries[EnumValue(spriteType)].sprite_animation[EnumValue(actionSpriteType)];
+};
+
+inline const rct_sprite_bounds& GetSpriteBounds(
+    PeepSpriteType spriteType, PeepActionSpriteType actionSpriteType = PeepActionSpriteType::None)
+{
+    return g_peep_animation_entries[EnumValue(spriteType)].sprite_bounds[EnumValue(actionSpriteType)];
+};
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../management/Marketing.h" 2
+
+
+
+
+enum
+{
+    ADVERTISING_CAMPAIGN_PARK_ENTRY_FREE,
+    ADVERTISING_CAMPAIGN_RIDE_FREE,
+    ADVERTISING_CAMPAIGN_PARK_ENTRY_HALF_PRICE,
+    ADVERTISING_CAMPAIGN_FOOD_OR_DRINK_FREE,
+    ADVERTISING_CAMPAIGN_PARK,
+    ADVERTISING_CAMPAIGN_RIDE,
+    ADVERTISING_CAMPAIGN_COUNT
+};
+
+enum
+{
+    VOUCHER_TYPE_PARK_ENTRY_FREE,
+    VOUCHER_TYPE_RIDE_FREE,
+    VOUCHER_TYPE_PARK_ENTRY_HALF_PRICE,
+    VOUCHER_TYPE_FOOD_OR_DRINK_FREE,
+};
+
+enum
+{
+    CAMPAIGN_FIRST_WEEK_FLAG = (1 << 6),
+    CAMPAIGN_ACTIVE_FLAG = (1 << 7)
+};
+
+struct MarketingCampaign
+{
+    uint8_t Type{};
+    uint8_t WeeksLeft{};
+    uint8_t Flags{};
+    union
+    {
+        ride_id_t RideId{};
+        ShopItemIndex ShopItemType;
+    };
+};
+
+namespace MarketingCampaignFlags
+{
+    constexpr uint8_t FIRST_WEEK = 1 << 0;
+}
+
+extern const money16 AdvertisingCampaignPricePerWeek[ADVERTISING_CAMPAIGN_COUNT];
+extern std::vector<MarketingCampaign> gMarketingCampaigns;
+
+uint16_t marketing_get_campaign_guest_generation_probability(int32_t campaign);
+void marketing_update();
+void marketing_set_guest_campaign(Peep* peep, int32_t campaign);
+bool marketing_is_campaign_type_applicable(int32_t campaignType);
+MarketingCampaign* marketing_get_campaign(int32_t campaignType);
+void marketing_new_campaign(const MarketingCampaign& campaign);
+void MarketingCancelCampaignsForRide(const ride_id_t rideId);
+# 14 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Localisation.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Currency.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Currency.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Currency.h" 2
+
+
+enum class CurrencyType : uint8_t
+{
+    Pounds,
+    Dollars,
+    Franc,
+    DeutscheMark,
+    Yen,
+    Peseta,
+    Lira,
+    Guilders,
+    Krona,
+    Euros,
+    Won,
+    Rouble,
+    CzechKoruna,
+    HKD,
+    TWD,
+    Yuan,
+    Forint,
+
+    Custom,
+
+    Count
+};
+
+enum class CurrencyAffix
+{
+    Prefix,
+    Suffix
+};
+
+
+
+
+
+struct currency_descriptor
+{
+    char isoCode[4];
+
+    int32_t rate;
+    CurrencyAffix affix_unicode;
+    utf8 symbol_unicode[8];
+    CurrencyAffix affix_ascii;
+    char symbol_ascii[8];
+    rct_string_id stringId;
+};
+
+
+extern currency_descriptor CurrencyDescriptors[static_cast<uint8_t>(CurrencyType::Count)];
+
+
+
+
+
+void currency_load_custom_currency_config();
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Localisation.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Date.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Date.h"
+constexpr int32_t MAX_YEAR = 8192;
+constexpr int32_t TICKS_PER_MONTH = 0x10000;
+
+enum
+{
+    MONTH_MARCH,
+    MONTH_APRIL,
+    MONTH_MAY,
+    MONTH_JUNE,
+    MONTH_JULY,
+    MONTH_AUGUST,
+    MONTH_SEPTEMBER,
+    MONTH_OCTOBER,
+
+    MONTH_COUNT
+};
+
+enum
+{
+    DATE_FORMAT_DAY_MONTH_YEAR,
+    DATE_FORMAT_MONTH_DAY_YEAR,
+    DATE_FORMAT_YEAR_MONTH_DAY,
+    DATE_FORMAT_YEAR_DAY_MONTH
+};
+
+struct openrct2_timeofday
+{
+    uint8_t second;
+    uint8_t minute;
+    uint8_t hour;
+};
+
+extern const int16_t days_in_month[MONTH_COUNT];
+extern const rct_string_id DateFormatStringIds[];
+extern const rct_string_id DateFormatStringFormatIds[];
+
+extern uint16_t gDateMonthTicks;
+extern int32_t gDateMonthsElapsed;
+
+extern openrct2_timeofday gRealTimeOfDay;
+
+int32_t date_get_month(int32_t months);
+int32_t date_get_year(int32_t months);
+int32_t date_get_total_months(int32_t month, int32_t year);
+void date_reset();
+void date_update();
+void date_set(int32_t year, int32_t month, int32_t day);
+void date_update_real_time_of_day();
+bool date_is_day_start(int32_t monthTicks);
+bool date_is_week_start(int32_t monthTicks);
+bool date_is_fortnight_start(int32_t monthTicks);
+bool date_is_month_start(int32_t monthTicks);
+# 16 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Localisation.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/FormatCodes.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/FormatCodes.h"
+       
+
+
+
+
+
+enum class FormatToken
+{
+    Unknown,
+    Literal,
+    Escaped,
+
+    Newline,
+    NewlineSmall,
+
+
+    Move,
+    InlineSprite,
+
+
+    Comma32,
+    Int32,
+    Comma1dp16,
+    Comma2dp32,
+    Comma16,
+    UInt16,
+    Currency2dp,
+    Currency,
+    StringId,
+    String,
+    MonthYear,
+    Month,
+    Velocity,
+    DurationShort,
+    DurationLong,
+    Length,
+    Sprite,
+    Pop16,
+    Push16,
+
+
+    ColourWindow1,
+    ColourWindow2,
+    ColourWindow3,
+    ColourBlack,
+    ColourGrey,
+    ColourWhite,
+    ColourRed,
+    ColourGreen,
+    ColourYellow,
+    ColourTopaz,
+    ColourCeladon,
+    ColourBabyBlue,
+    ColourPaleLavender,
+    ColourPaleGold,
+    ColourLightPink,
+    ColourPearlAqua,
+    ColourPaleSilver,
+
+
+    FontTiny,
+    FontSmall,
+    FontMedium,
+
+    OutlineEnable,
+    OutlineDisable,
+};
+
+std::string_view GetFormatTokenStringWithBraces(FormatToken token);
+FormatToken FormatTokenFromString(std::string_view token);
+std::string_view FormatTokenToString(FormatToken token, bool withBraces = false);
+bool FormatTokenTakesArgument(FormatToken token);
+bool FormatTokenIsColour(FormatToken token);
+size_t FormatTokenGetTextColourIndex(FormatToken token);
+FormatToken FormatTokenFromTextColour(size_t textColour);
+
+constexpr uint8_t CS_SPRITE_FONT_OFFSET = 32;
+
+namespace CSChar
+{
+    constexpr char32_t quote_close = 0x22;
+
+    constexpr char32_t a_ogonek_uc = 0x9F;
+    constexpr char32_t up = 0xA0;
+
+    constexpr char32_t c_acute_uc = 0xA2;
+    constexpr char32_t e_ogonek_uc = 0xA6;
+    constexpr char32_t l_stroke_uc = 0xA7;
+
+    constexpr char32_t down = 0xAA;
+    constexpr char32_t tick = 0xAC;
+    constexpr char32_t cross = 0xAD;
+    constexpr char32_t right = 0xAF;
+    constexpr char32_t railway = 0xB1;
+    constexpr char32_t quote_open = 0xB4;
+    constexpr char32_t euro = 0xB5;
+    constexpr char32_t road = 0xB6;
+    constexpr char32_t air = 0xB7;
+    constexpr char32_t water = 0xB8;
+    constexpr char32_t superscript_minus_one = 0xB9;
+    constexpr char32_t bullet = 0xBA;
+    constexpr char32_t small_up = 0xBC;
+    constexpr char32_t small_down = 0xBD;
+    constexpr char32_t left = 0xBE;
+
+    constexpr char32_t n_acute_uc = 0xC6;
+    constexpr char32_t s_acute_uc = 0xD0;
+    constexpr char32_t z_acute_uc = 0xD7;
+    constexpr char32_t z_dot_uc = 0xD8;
+    constexpr char32_t a_ogonek = 0xDD;
+    constexpr char32_t c_acute = 0xDE;
+    constexpr char32_t e_ogonek = 0xE6;
+    constexpr char32_t n_acute = 0xF0;
+    constexpr char32_t o_circumflex = 0xF4;
+    constexpr char32_t l_stroke = 0xF7;
+    constexpr char32_t s_acute = 0xF8;
+    constexpr char32_t z_acute = 0xFE;
+
+    constexpr char32_t z_dot = 0xFD;
+}
+
+namespace UnicodeChar
+{
+
+    constexpr char32_t j = 0x6A;
+    constexpr char32_t l = 0x6C;
+    constexpr char32_t ae_uc = 0xC6;
+    constexpr char32_t o_stroke_uc = 0xD8;
+    constexpr char32_t y_acute_uc = 0xDD;
+    constexpr char32_t ae = 0xE6;
+    constexpr char32_t o_stroke = 0xF8;
+    constexpr char32_t y_acute = 0xFD;
+    constexpr char32_t a_breve_uc = 0x102;
+    constexpr char32_t a_breve = 0x103;
+    constexpr char32_t a_ogonek_uc = 0x104;
+    constexpr char32_t a_ogonek = 0x105;
+    constexpr char32_t c_acute_uc = 0x106;
+    constexpr char32_t c_acute = 0x107;
+    constexpr char32_t c_circumflex_uc = 0x108;
+    constexpr char32_t c_circumflex = 0x109;
+    constexpr char32_t c_caron_uc = 0x10C;
+    constexpr char32_t c_caron = 0x10D;
+    constexpr char32_t d_caron_uc = 0x10E;
+    constexpr char32_t d_caron = 0x10F;
+    constexpr char32_t e_ogonek_uc = 0x118;
+    constexpr char32_t e_ogonek = 0x119;
+    constexpr char32_t e_caron_uc = 0x11A;
+    constexpr char32_t e_caron = 0x11B;
+    constexpr char32_t g_circumflex_uc = 0x11C;
+    constexpr char32_t g_circumflex = 0x11D;
+    constexpr char32_t g_breve_uc = 0x11E;
+    constexpr char32_t g_breve = 0x11F;
+    constexpr char32_t h_circumflex_uc = 0x124;
+    constexpr char32_t h_circumflex = 0x125;
+    constexpr char32_t i_with_dot_uc = 0x130;
+    constexpr char32_t i_without_dot = 0x131;
+    constexpr char32_t j_circumflex_uc = 0x134;
+    constexpr char32_t j_circumflex = 0x135;
+    constexpr char32_t l_stroke_uc = 0x141;
+    constexpr char32_t l_stroke = 0x142;
+    constexpr char32_t n_acute_uc = 0x143;
+    constexpr char32_t n_acute = 0x144;
+    constexpr char32_t n_caron_uc = 0x147;
+    constexpr char32_t n_caron = 0x148;
+    constexpr char32_t o_macron = 0x14D;
+    constexpr char32_t o_double_acute_uc = 0x150;
+    constexpr char32_t o_double_acute = 0x151;
+    constexpr char32_t r_caron_uc = 0x158;
+    constexpr char32_t r_caron = 0x159;
+    constexpr char32_t s_acute_uc = 0x15A;
+    constexpr char32_t s_acute = 0x15B;
+    constexpr char32_t s_circumflex_uc = 0x15C;
+    constexpr char32_t s_circumflex = 0x15D;
+    constexpr char32_t s_cedilla_uc = 0x15E;
+    constexpr char32_t s_cedilla = 0x15F;
+    constexpr char32_t s_caron_uc = 0x160;
+    constexpr char32_t s_caron = 0x161;
+    constexpr char32_t t_caron_uc = 0x164;
+    constexpr char32_t t_caron = 0x165;
+    constexpr char32_t u_breve_uc = 0x16C;
+    constexpr char32_t u_breve = 0x16D;
+    constexpr char32_t u_ring_uc = 0x16E;
+    constexpr char32_t u_ring = 0x16F;
+    constexpr char32_t u_double_acute_uc = 0x170;
+    constexpr char32_t u_double_acute = 0x171;
+    constexpr char32_t z_acute_uc = 0x179;
+    constexpr char32_t z_acute = 0x17A;
+    constexpr char32_t z_dot_uc = 0x17B;
+    constexpr char32_t z_dot = 0x17C;
+    constexpr char32_t z_caron_uc = 0x17D;
+    constexpr char32_t z_caron = 0x17E;
+    constexpr char32_t f_with_hook_uc = 0x191;
+    constexpr char32_t s_comma_uc = 0x218;
+    constexpr char32_t s_comma = 0x219;
+    constexpr char32_t t_comma_uc = 0x21A;
+    constexpr char32_t t_comma = 0x21B;
+    constexpr char32_t sharp_s_uc = 0x1E9E;
+
+
+    constexpr char32_t cyrillic_io_uc = 0x401;
+    constexpr char32_t cyrillic_a_uc = 0x410;
+    constexpr char32_t cyrillic_be_uc = 0x411;
+    constexpr char32_t cyrillic_ve_uc = 0x412;
+    constexpr char32_t cyrillic_ghe_uc = 0x413;
+    constexpr char32_t cyrillic_de_uc = 0x414;
+    constexpr char32_t cyrillic_ie_uc = 0x415;
+    constexpr char32_t cyrillic_zhe_uc = 0x416;
+    constexpr char32_t cyrillic_ze_uc = 0x417;
+    constexpr char32_t cyrillic_i_uc = 0x418;
+    constexpr char32_t cyrillic_short_i_uc = 0x419;
+    constexpr char32_t cyrillic_ka_uc = 0x41A;
+    constexpr char32_t cyrillic_el_uc = 0x41B;
+    constexpr char32_t cyrillic_em_uc = 0x41C;
+    constexpr char32_t cyrillic_en_uc = 0x41D;
+    constexpr char32_t cyrillic_o_uc = 0x41E;
+    constexpr char32_t cyrillic_pe_uc = 0x41F;
+    constexpr char32_t cyrillic_er_uc = 0x420;
+    constexpr char32_t cyrillic_es_uc = 0x421;
+    constexpr char32_t cyrillic_te_uc = 0x422;
+    constexpr char32_t cyrillic_u_uc = 0x423;
+    constexpr char32_t cyrillic_ef_uc = 0x424;
+    constexpr char32_t cyrillic_ha_uc = 0x425;
+    constexpr char32_t cyrillic_tse_uc = 0x426;
+    constexpr char32_t cyrillic_che_uc = 0x427;
+    constexpr char32_t cyrillic_sha_uc = 0x428;
+    constexpr char32_t cyrillic_shcha_uc = 0x429;
+    constexpr char32_t cyrillic_hard_sign_uc = 0x42A;
+    constexpr char32_t cyrillic_yeru_uc = 0x42B;
+    constexpr char32_t cyrillic_soft_sign_uc = 0x42C;
+    constexpr char32_t cyrillic_e_uc = 0x42D;
+    constexpr char32_t cyrillic_yu_uc = 0x42E;
+    constexpr char32_t cyrillic_ya_uc = 0x42F;
+
+    constexpr char32_t cyrillic_a = 0x430;
+    constexpr char32_t cyrillic_be = 0x431;
+    constexpr char32_t cyrillic_ve = 0x432;
+    constexpr char32_t cyrillic_ghe = 0x433;
+    constexpr char32_t cyrillic_de = 0x434;
+    constexpr char32_t cyrillic_ie = 0x435;
+    constexpr char32_t cyrillic_zhe = 0x436;
+    constexpr char32_t cyrillic_ze = 0x437;
+    constexpr char32_t cyrillic_i = 0x438;
+    constexpr char32_t cyrillic_short_i = 0x439;
+    constexpr char32_t cyrillic_ka = 0x43A;
+    constexpr char32_t cyrillic_el = 0x43B;
+    constexpr char32_t cyrillic_em = 0x43C;
+    constexpr char32_t cyrillic_en = 0x43D;
+    constexpr char32_t cyrillic_o = 0x43E;
+    constexpr char32_t cyrillic_pe = 0x43F;
+    constexpr char32_t cyrillic_er = 0x440;
+    constexpr char32_t cyrillic_es = 0x441;
+    constexpr char32_t cyrillic_te = 0x442;
+    constexpr char32_t cyrillic_u = 0x443;
+    constexpr char32_t cyrillic_ef = 0x444;
+    constexpr char32_t cyrillic_ha = 0x445;
+    constexpr char32_t cyrillic_tse = 0x446;
+    constexpr char32_t cyrillic_che = 0x447;
+    constexpr char32_t cyrillic_sha = 0x448;
+    constexpr char32_t cyrillic_shcha = 0x449;
+    constexpr char32_t cyrillic_hard_sign = 0x44A;
+    constexpr char32_t cyrillic_yeru = 0x44B;
+    constexpr char32_t cyrillic_soft_sign = 0x44C;
+    constexpr char32_t cyrillic_e = 0x44D;
+    constexpr char32_t cyrillic_yu = 0x44E;
+    constexpr char32_t cyrillic_ya = 0x44F;
+
+    constexpr char32_t cyrillic_io = 0x451;
+
+
+    constexpr char32_t non_breaking_space = 0xA0;
+    constexpr char32_t leftguillemet = 0xAB;
+    constexpr char32_t rightguillemet = 0xBB;
+    constexpr char32_t interpunct = 0xB7;
+    constexpr char32_t multiplication_sign = 0xD7;
+    constexpr char32_t en_dash = 0x2013;
+    constexpr char32_t single_quote_open = 0x2018;
+    constexpr char32_t single_quote_end = 0x2019;
+    constexpr char32_t single_german_quote_open = 0x201A;
+    constexpr char32_t german_quote_open = 0x201E;
+    constexpr char32_t bullet = 0x2022;
+    constexpr char32_t ellipsis = 0x2026;
+    constexpr char32_t narrow_non_breaking_space = 0x202F;
+    constexpr char32_t quote_open = 0x201C;
+    constexpr char32_t quote_close = 0x201D;
+
+
+    constexpr char32_t guilder = 0x192;
+    constexpr char32_t euro = 0x20AC;
+    constexpr char32_t rouble = 0x20BD;
+
+
+    constexpr char32_t up = 0x25B2;
+    constexpr char32_t small_up = 0x25B4;
+    constexpr char32_t right = 0x25B6;
+    constexpr char32_t down = 0x25BC;
+    constexpr char32_t small_down = 0x25BE;
+    constexpr char32_t left = 0x25C0;
+    constexpr char32_t air = 0x2601;
+    constexpr char32_t tick = 0x2713;
+    constexpr char32_t plus = 0x2795;
+    constexpr char32_t minus = 0x2796;
+
+
+    constexpr char32_t cross = 0x274C;
+    constexpr char32_t variation_selector = 0xFE0F;
+    constexpr char32_t water = 0x1F30A;
+    constexpr char32_t road = 0x1F6E3;
+    constexpr char32_t railway = 0x1F6E4;
+
+
+    constexpr char32_t superscript_minus_one = 0x207B;
+
+};
+# 17 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Localisation.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Language.h" 1
+# 18 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Localisation.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/StringIds.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/StringIds.h"
+constexpr const rct_string_id STR_NONE = 0xFFFF;
+constexpr const rct_string_id STR_VIEWPORT = 0xFFFE;
+
+enum
+{
+    STR_EMPTY = 0,
+    STR_RIDE_NAME_DEFAULT = 1,
+    STR_RIDE_NAME_SPIRAL_ROLLER_COASTER = 2,
+    STR_RIDE_NAME_STAND_UP_ROLLER_COASTER = 3,
+    STR_RIDE_NAME_SUSPENDED_SWINGING_COASTER = 4,
+    STR_RIDE_NAME_INVERTED_ROLLER_COASTER = 5,
+    STR_RIDE_NAME_JUNIOR_ROLLER_COASTER = 6,
+    STR_RIDE_NAME_MINIATURE_RAILWAY = 7,
+    STR_RIDE_NAME_MONORAIL = 8,
+    STR_RIDE_NAME_MINI_SUSPENDED_COASTER = 9,
+    STR_RIDE_NAME_BOAT_HIRE = 10,
+    STR_RIDE_NAME_WOODEN_WILD_MOUSE = 11,
+    STR_RIDE_NAME_STEEPLECHASE = 12,
+    STR_RIDE_NAME_CAR_RIDE = 13,
+    STR_RIDE_NAME_LAUNCHED_FREEFALL = 14,
+    STR_RIDE_NAME_BOBSLEIGH_COASTER = 15,
+    STR_RIDE_NAME_OBSERVATION_TOWER = 16,
+    STR_RIDE_NAME_LOOPING_ROLLER_COASTER = 17,
+    STR_RIDE_NAME_DINGHY_SLIDE = 18,
+    STR_RIDE_NAME_MINE_TRAIN_COASTER = 19,
+    STR_RIDE_NAME_CHAIRLIFT = 20,
+    STR_RIDE_NAME_CORKSCREW_ROLLER_COASTER = 21,
+    STR_RIDE_NAME_MAZE = 22,
+    STR_RIDE_NAME_SPIRAL_SLIDE = 23,
+    STR_RIDE_NAME_GO_KARTS = 24,
+    STR_RIDE_NAME_LOG_FLUME = 25,
+    STR_RIDE_NAME_RIVER_RAPIDS = 26,
+    STR_RIDE_NAME_DODGEMS = 27,
+    STR_RIDE_NAME_SWINGING_SHIP = 28,
+    STR_RIDE_NAME_SWINGING_INVERTER_SHIP = 29,
+    STR_RIDE_NAME_FOOD_STALL = 30,
+    STR_RIDE_NAME_1D = 31,
+    STR_RIDE_NAME_DRINK_STALL = 32,
+    STR_RIDE_NAME_1F = 33,
+    STR_RIDE_NAME_SHOP = 34,
+    STR_RIDE_NAME_MERRY_GO_ROUND = 35,
+    STR_RIDE_NAME_22 = 36,
+    STR_RIDE_NAME_INFORMATION_KIOSK = 37,
+    STR_RIDE_NAME_TOILETS = 38,
+    STR_RIDE_NAME_FERRIS_WHEEL = 39,
+    STR_RIDE_NAME_MOTION_SIMULATOR = 40,
+    STR_RIDE_NAME_3D_CINEMA = 41,
+    STR_RIDE_NAME_TOP_SPIN = 42,
+    STR_RIDE_NAME_SPACE_RINGS = 43,
+    STR_RIDE_NAME_REVERSE_FREEFALL_COASTER = 44,
+    STR_RIDE_NAME_LIFT = 45,
+    STR_RIDE_NAME_VERTICAL_DROP_ROLLER_COASTER = 46,
+    STR_RIDE_NAME_CASH_MACHINE = 47,
+    STR_RIDE_NAME_TWIST = 48,
+    STR_RIDE_NAME_HAUNTED_HOUSE = 49,
+    STR_RIDE_NAME_FIRST_AID = 50,
+    STR_RIDE_NAME_CIRCUS = 51,
+    STR_RIDE_NAME_GHOST_TRAIN = 52,
+    STR_RIDE_NAME_TWISTER_ROLLER_COASTER = 53,
+    STR_RIDE_NAME_WOODEN_ROLLER_COASTER = 54,
+    STR_RIDE_NAME_SIDE_FRICTION_ROLLER_COASTER = 55,
+    STR_RIDE_NAME_WILD_MOUSE = 56,
+    STR_RIDE_NAME_MULTI_DIMENSION_ROLLER_COASTER = 57,
+    STR_RIDE_NAME_38 = 58,
+    STR_RIDE_NAME_FLYING_ROLLER_COASTER = 59,
+    STR_RIDE_NAME_3A = 60,
+    STR_RIDE_NAME_VIRGINIA_REEL = 61,
+    STR_RIDE_NAME_SPLASH_BOATS = 62,
+    STR_RIDE_NAME_MINI_HELICOPTERS = 63,
+    STR_RIDE_NAME_LAY_DOWN_ROLLER_COASTER = 64,
+    STR_RIDE_NAME_SUSPENDED_MONORAIL = 65,
+    STR_RIDE_NAME_40 = 66,
+    STR_RIDE_NAME_REVERSER_ROLLER_COASTER = 67,
+    STR_RIDE_NAME_HEARTLINE_TWISTER_COASTER = 68,
+    STR_RIDE_NAME_MINI_GOLF = 69,
+    STR_RIDE_NAME_GIGA_COASTER = 70,
+    STR_RIDE_NAME_ROTO_DROP = 71,
+    STR_RIDE_NAME_FLYING_SAUCERS = 72,
+    STR_RIDE_NAME_CROOKED_HOUSE = 73,
+    STR_RIDE_NAME_MONORAIL_CYCLES = 74,
+    STR_RIDE_NAME_COMPACT_INVERTED_COASTER = 75,
+    STR_RIDE_NAME_WATER_COASTER = 76,
+    STR_RIDE_NAME_AIR_POWERED_VERTICAL_COASTER = 77,
+    STR_RIDE_NAME_INVERTED_HAIRPIN_COASTER = 78,
+    STR_RIDE_NAME_MAGIC_CARPET = 79,
+    STR_RIDE_NAME_SUBMARINE_RIDE = 80,
+    STR_RIDE_NAME_RIVER_RAFTS = 81,
+    STR_RIDE_NAME_50 = 82,
+    STR_RIDE_NAME_ENTERPRISE = 83,
+    STR_RIDE_NAME_52 = 84,
+    STR_RIDE_NAME_53 = 85,
+    STR_RIDE_NAME_54 = 86,
+    STR_RIDE_NAME_55 = 87,
+    STR_RIDE_NAME_INVERTED_IMPULSE_COASTER = 88,
+    STR_RIDE_NAME_MINI_ROLLER_COASTER = 89,
+    STR_RIDE_NAME_MINE_RIDE = 90,
+    STR_RIDE_NAME_59 = 91,
+    STR_RIDE_NAME_LIM_LAUNCHED_ROLLER_COASTER = 92,
+    STR_RIDE_NAME_HYBRID_COASTER = 93,
+    STR_RIDE_NAME_SINGLE_RAIL_ROLLER_COASTER = 94,
+
+    STR_RIDE_DESCRIPTION_SPIRAL_ROLLER_COASTER = 512,
+    STR_RIDE_DESCRIPTION_STAND_UP_ROLLER_COASTER = 513,
+    STR_RIDE_DESCRIPTION_SUSPENDED_SWINGING_COASTER = 514,
+    STR_RIDE_DESCRIPTION_INVERTED_ROLLER_COASTER = 515,
+    STR_RIDE_DESCRIPTION_JUNIOR_ROLLER_COASTER = 516,
+    STR_RIDE_DESCRIPTION_MINIATURE_RAILWAY = 517,
+    STR_RIDE_DESCRIPTION_MONORAIL = 518,
+    STR_RIDE_DESCRIPTION_MINI_SUSPENDED_COASTER = 519,
+    STR_RIDE_DESCRIPTION_BOAT_HIRE = 520,
+    STR_RIDE_DESCRIPTION_WOODEN_WILD_MOUSE = 521,
+    STR_RIDE_DESCRIPTION_STEEPLECHASE = 522,
+    STR_RIDE_DESCRIPTION_CAR_RIDE = 523,
+    STR_RIDE_DESCRIPTION_LAUNCHED_FREEFALL = 524,
+    STR_RIDE_DESCRIPTION_BOBSLEIGH_COASTER = 525,
+    STR_RIDE_DESCRIPTION_OBSERVATION_TOWER = 526,
+    STR_RIDE_DESCRIPTION_LOOPING_ROLLER_COASTER = 527,
+    STR_RIDE_DESCRIPTION_DINGHY_SLIDE = 528,
+    STR_RIDE_DESCRIPTION_MINE_TRAIN_COASTER = 529,
+    STR_RIDE_DESCRIPTION_CHAIRLIFT = 530,
+    STR_RIDE_DESCRIPTION_CORKSCREW_ROLLER_COASTER = 531,
+    STR_RIDE_DESCRIPTION_MAZE = 532,
+    STR_RIDE_DESCRIPTION_SPIRAL_SLIDE = 533,
+    STR_RIDE_DESCRIPTION_GO_KARTS = 534,
+    STR_RIDE_DESCRIPTION_LOG_FLUME = 535,
+    STR_RIDE_DESCRIPTION_RIVER_RAPIDS = 536,
+    STR_RIDE_DESCRIPTION_DODGEMS = 537,
+    STR_RIDE_DESCRIPTION_SWINGING_SHIP = 538,
+    STR_RIDE_DESCRIPTION_SWINGING_INVERTER_SHIP = 539,
+    STR_RIDE_DESCRIPTION_FOOD_STALL = 540,
+
+    STR_RIDE_DESCRIPTION_DRINK_STALL = 542,
+
+    STR_RIDE_DESCRIPTION_SHOP = 544,
+    STR_RIDE_DESCRIPTION_MERRY_GO_ROUND = 545,
+
+    STR_RIDE_DESCRIPTION_INFORMATION_KIOSK = 547,
+    STR_RIDE_DESCRIPTION_TOILETS = 548,
+    STR_RIDE_DESCRIPTION_FERRIS_WHEEL = 549,
+    STR_RIDE_DESCRIPTION_MOTION_SIMULATOR = 550,
+    STR_RIDE_DESCRIPTION_3D_CINEMA = 551,
+    STR_RIDE_DESCRIPTION_TOP_SPIN = 552,
+    STR_RIDE_DESCRIPTION_SPACE_RINGS = 553,
+    STR_RIDE_DESCRIPTION_REVERSE_FREEFALL_COASTER = 554,
+    STR_RIDE_DESCRIPTION_LIFT = 555,
+    STR_RIDE_DESCRIPTION_VERTICAL_DROP_ROLLER_COASTER = 556,
+    STR_RIDE_DESCRIPTION_CASH_MACHINE = 557,
+    STR_RIDE_DESCRIPTION_TWIST = 558,
+    STR_RIDE_DESCRIPTION_HAUNTED_HOUSE = 559,
+    STR_RIDE_DESCRIPTION_FIRST_AID = 560,
+    STR_RIDE_DESCRIPTION_CIRCUS = 561,
+    STR_RIDE_DESCRIPTION_GHOST_TRAIN = 562,
+    STR_RIDE_DESCRIPTION_HYPER_TWISTER = 563,
+    STR_RIDE_DESCRIPTION_WOODEN_ROLLER_COASTER = 564,
+    STR_RIDE_DESCRIPTION_SIDE_FRICTION_ROLLER_COASTER = 565,
+    STR_RIDE_DESCRIPTION_WILD_MOUSE = 566,
+    STR_RIDE_DESCRIPTION_MULTI_DIMENSION_ROLLER_COASTER = 567,
+
+    STR_RIDE_DESCRIPTION_FLYING_ROLLER_COASTER = 569,
+
+    STR_RIDE_DESCRIPTION_VIRGINIA_REEL = 571,
+    STR_RIDE_DESCRIPTION_SPLASH_BOATS = 572,
+    STR_RIDE_DESCRIPTION_MINI_HELICOPTERS = 573,
+    STR_RIDE_DESCRIPTION_LAY_DOWN_ROLLER_COASTER = 574,
+    STR_RIDE_DESCRIPTION_SUSPENDED_MONORAIL = 575,
+
+    STR_RIDE_DESCRIPTION_REVERSER_ROLLER_COASTER = 577,
+    STR_RIDE_DESCRIPTION_HEARTLINE_TWISTER_COASTER = 578,
+    STR_RIDE_DESCRIPTION_MINI_GOLF = 579,
+    STR_RIDE_DESCRIPTION_GIGA_COASTER = 580,
+    STR_RIDE_DESCRIPTION_ROTO_DROP = 581,
+    STR_RIDE_DESCRIPTION_FLYING_SAUCERS = 582,
+    STR_RIDE_DESCRIPTION_CROOKED_HOUSE = 583,
+    STR_RIDE_DESCRIPTION_MONORAIL_CYCLES = 584,
+    STR_RIDE_DESCRIPTION_COMPACT_INVERTED_COASTER = 585,
+    STR_RIDE_DESCRIPTION_WATER_COASTER = 586,
+    STR_RIDE_DESCRIPTION_AIR_POWERED_VERTICAL_COASTER = 587,
+    STR_RIDE_DESCRIPTION_INVERTED_HAIRPIN_COASTER = 588,
+    STR_RIDE_DESCRIPTION_MAGIC_CARPET = 589,
+    STR_RIDE_DESCRIPTION_SUBMARINE_RIDE = 590,
+    STR_RIDE_DESCRIPTION_RIVER_RAFTS = 591,
+
+    STR_RIDE_DESCRIPTION_ENTERPRISE = 593,
+
+    STR_RIDE_DESCRIPTION_INVERTED_IMPULSE_COASTER = 598,
+    STR_RIDE_DESCRIPTION_MINI_ROLLER_COASTER = 599,
+    STR_RIDE_DESCRIPTION_MINE_RIDE = 600,
+
+    STR_RIDE_DESCRIPTION_LIM_LAUNCHED_ROLLER_COASTER = 602,
+    STR_RIDE_DESCRIPTION_HYBRID_COASTER = 603,
+    STR_RIDE_DESCRIPTION_SINGLE_RAIL_ROLLER_COASTER = 604,
+
+    STR_GUEST_X = 767,
+    STR_HANDYMAN_X = 768,
+    STR_MECHANIC_X = 769,
+    STR_SECURITY_GUARD_X = 770,
+    STR_ENTERTAINER_X = 771,
+
+    STR_UNNAMED_PARK = 777,
+    STR_DEFAULT_SIGN = 778,
+    STR_DATE_DAY_1 = 779,
+    STR_DATE_DAY_2 = STR_DATE_DAY_1 + 1,
+    STR_DATE_DAY_3 = STR_DATE_DAY_1 + 2,
+    STR_DATE_DAY_4 = STR_DATE_DAY_1 + 3,
+    STR_DATE_DAY_5 = STR_DATE_DAY_1 + 4,
+    STR_DATE_DAY_6 = STR_DATE_DAY_1 + 5,
+    STR_DATE_DAY_7 = STR_DATE_DAY_1 + 6,
+    STR_DATE_DAY_8 = STR_DATE_DAY_1 + 7,
+    STR_DATE_DAY_9 = STR_DATE_DAY_1 + 8,
+    STR_DATE_DAY_10 = STR_DATE_DAY_1 + 9,
+    STR_DATE_DAY_11 = STR_DATE_DAY_1 + 10,
+    STR_DATE_DAY_12 = STR_DATE_DAY_1 + 11,
+    STR_DATE_DAY_13 = STR_DATE_DAY_1 + 12,
+    STR_DATE_DAY_14 = STR_DATE_DAY_1 + 13,
+    STR_DATE_DAY_15 = STR_DATE_DAY_1 + 14,
+    STR_DATE_DAY_16 = STR_DATE_DAY_1 + 15,
+    STR_DATE_DAY_17 = STR_DATE_DAY_1 + 16,
+    STR_DATE_DAY_18 = STR_DATE_DAY_1 + 17,
+    STR_DATE_DAY_19 = STR_DATE_DAY_1 + 18,
+    STR_DATE_DAY_20 = STR_DATE_DAY_1 + 19,
+    STR_DATE_DAY_21 = STR_DATE_DAY_1 + 20,
+    STR_DATE_DAY_22 = STR_DATE_DAY_1 + 21,
+    STR_DATE_DAY_23 = STR_DATE_DAY_1 + 22,
+    STR_DATE_DAY_24 = STR_DATE_DAY_1 + 23,
+    STR_DATE_DAY_25 = STR_DATE_DAY_1 + 24,
+    STR_DATE_DAY_26 = STR_DATE_DAY_1 + 25,
+    STR_DATE_DAY_27 = STR_DATE_DAY_1 + 26,
+    STR_DATE_DAY_28 = STR_DATE_DAY_1 + 27,
+    STR_DATE_DAY_29 = STR_DATE_DAY_1 + 28,
+    STR_DATE_DAY_30 = STR_DATE_DAY_1 + 29,
+    STR_DATE_DAY_31 = STR_DATE_DAY_1 + 30,
+    STR_MONTH_SHORT_JAN = 810,
+    STR_MONTH_SHORT_FEB = 811,
+    STR_MONTH_SHORT_MAR = 812,
+    STR_MONTH_SHORT_APR = 813,
+    STR_MONTH_SHORT_MAY = 814,
+    STR_MONTH_SHORT_JUN = 815,
+    STR_MONTH_SHORT_JUL = 816,
+    STR_MONTH_SHORT_AUG = 817,
+    STR_MONTH_SHORT_SEP = 818,
+    STR_MONTH_SHORT_OCT = 819,
+    STR_MONTH_SHORT_NOV = 820,
+    STR_MONTH_SHORT_DEC = 821,
+
+    STR_CLOSE_X = 824,
+    STR_CHOSEN_NAME_IN_USE_ALREADY = 825,
+    STR_TOO_MANY_NAMES_DEFINED = 826,
+    STR_NOT_ENOUGH_CASH_REQUIRES = 827,
+    STR_CLOSE_WINDOW_TIP = 828,
+    STR_WINDOW_TITLE_TIP = 829,
+    STR_ZOOM_IN_TIP = 830,
+    STR_ZOOM_OUT_TIP = 831,
+    STR_ROTATE_TIP = 832,
+    STR_PAUSE_GAME_TIP = 833,
+    STR_DISC_AND_GAME_OPTIONS_TIP = 834,
+
+    STR_RESOLUTION_X_BY_Y = 839,
+    STR_ARG_16_RESOLUTION_X_BY_Y = 840,
+
+    STR_ABOUT = 847,
+
+    STR_COPYRIGHT_CS = 850,
+    STR_DESIGNED_AND_PROGRAMMED_BY_CS = 851,
+    STR_GRAPHICS_BY_SF = 852,
+    STR_SOUND_AND_MUSIC_BY_AB = 853,
+    STR_ADDITIONAL_SOUNDS_RECORDED_BY_DE = 854,
+    STR_REPRESENTATION_BY_JL = 855,
+    STR_THANKS_TO = 856,
+    STR_THANKS_TO_PEOPLE = 857,
+
+    STR_STRINGID = 865,
+    STR_ARG_2_STRINGID = 866,
+    STR_ARG_4_STRINGID = 867,
+    STR_ARG_6_STRINGID = 868,
+    STR_ARG_8_STRINGID = 869,
+    STR_ARG_10_STRINGID = 870,
+    STR_ARG_12_STRINGID = 871,
+    STR_ARG_14_STRINGID = 872,
+    STR_ARG_16_STRINGID = 873,
+    STR_ARG_18_STRINGID = 874,
+    STR_ARG_20_STRINGID = 875,
+    STR_DROPDOWN_GLYPH = 876,
+    STR_TOO_LOW = 877,
+    STR_TOO_HIGH = 878,
+    STR_CANT_LOWER_LAND_HERE = 879,
+    STR_CANT_RAISE_LAND_HERE = 880,
+    STR_OBJECT_IN_THE_WAY = 881,
+    STR_LOAD_GAME = 882,
+    STR_SAVE_GAME = 883,
+    STR_LOAD_LANDSCAPE = 884,
+    STR_SAVE_LANDSCAPE = 885,
+
+    STR_QUIT_SCENARIO_EDITOR = 887,
+    STR_QUIT_ROLLERCOASTER_DESIGNER = 888,
+    STR_QUIT_TRACK_DESIGNS_MANAGER = 889,
+
+    STR_SCREENSHOT = 891,
+    STR_SCREENSHOT_SAVED_AS = 892,
+    STR_SCREENSHOT_FAILED = 893,
+    STR_ERR_LANDSCAPE_DATA_AREA_FULL = 894,
+    STR_CANT_BUILD_PARTLY_ABOVE_AND_PARTLY_BELOW_GROUND = 895,
+    STR_RIDE_CONSTRUCTION_WINDOW_TITLE = 896,
+    STR_RIDE_CONSTRUCTION_DIRECTION = 897,
+    STR_RIDE_CONSTRUCTION_LEFT_CURVE_TIP = 898,
+    STR_RIDE_CONSTRUCTION_RIGHT_CURVE_TIP = 899,
+    STR_RIDE_CONSTRUCTION_LEFT_CURVE_SMALL_TIP = 900,
+    STR_RIDE_CONSTRUCTION_RIGHT_CURVE_SMALL_TIP = 901,
+    STR_RIDE_CONSTRUCTION_LEFT_CURVE_VERY_SMALL_TIP = 902,
+    STR_RIDE_CONSTRUCTION_RIGHT_CURVE_VERY_SMALL_TIP = 903,
+    STR_RIDE_CONSTRUCTION_LEFT_CURVE_LARGE_TIP = 904,
+    STR_RIDE_CONSTRUCTION_RIGHT_CURVE_LARGE_TIP = 905,
+    STR_RIDE_CONSTRUCTION_STRAIGHT_TIP = 906,
+    STR_RIDE_CONSTRUCTION_SLOPE = 907,
+    STR_RIDE_CONSTRUCTION_ROLL_BANKING = 908,
+    STR_RIDE_CONSTRUCTION_SEAT_ROT = 909,
+    STR_RIDE_CONSTRUCTION_ROLL_FOR_LEFT_CURVE_TIP = 910,
+    STR_RIDE_CONSTRUCTION_ROLL_FOR_RIGHT_CURVE_TIP = 911,
+    STR_RIDE_CONSTRUCTION_NO_ROLL_TIP = 912,
+    STR_RIDE_CONSTRUCTION_MOVE_TO_PREVIOUS_SECTION_TIP = 913,
+    STR_RIDE_CONSTRUCTION_MOVE_TO_NEXT_SECTION_TIP = 914,
+    STR_RIDE_CONSTRUCTION_CONSTRUCT_SELECTED_SECTION_TIP = 915,
+    STR_RIDE_CONSTRUCTION_REMOVE_HIGHLIGHTED_SECTION_TIP = 916,
+    STR_RIDE_CONSTRUCTION_VERTICAL_DROP_TIP = 917,
+    STR_RIDE_CONSTRUCTION_STEEP_SLOPE_DOWN_TIP = 918,
+    STR_RIDE_CONSTRUCTION_SLOPE_DOWN_TIP = 919,
+    STR_RIDE_CONSTRUCTION_LEVEL_TIP = 920,
+    STR_RIDE_CONSTRUCTION_SLOPE_UP_TIP = 921,
+    STR_RIDE_CONSTRUCTION_STEEP_SLOPE_UP_TIP = 922,
+    STR_RIDE_CONSTRUCTION_VERTICAL_RISE_TIP = 923,
+    STR_RIDE_CONSTRUCTION_HELIX_DOWN_TIP = 924,
+    STR_RIDE_CONSTRUCTION_HELIX_UP_TIP = 925,
+    STR_RIDE_CONSTRUCTION_CANT_REMOVE_THIS = 926,
+    STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE = 927,
+    STR_RIDE_CONSTRUCTION_CHAIN_LIFT_TIP = 928,
+    STR_S_BEND_LEFT = 929,
+    STR_S_BEND_RIGHT = 930,
+    STR_VERTICAL_LOOP_LEFT = 931,
+    STR_VERTICAL_LOOP_RIGHT = 932,
+    STR_RAISE_OR_LOWER_LAND_FIRST = 933,
+    STR_RIDE_ENTRANCE_IN_THE_WAY = 934,
+    STR_RIDE_EXIT_IN_THE_WAY = 935,
+    STR_PARK_ENTRANCE_IN_THE_WAY = 936,
+    STR_VIEW_OPTIONS_TIP = 937,
+    STR_ADJUST_LAND_TIP = 938,
+    STR_UNDERGROUND_VIEW = 939,
+    STR_REMOVE_BASE_LAND = 940,
+    STR_REMOVE_VERTICAL_FACES = 941,
+    STR_SEE_THROUGH_RIDES = 942,
+    STR_SEE_THROUGH_SCENERY = 943,
+    STR_SAVE_PROMPT_SAVE = 944,
+    STR_SAVE_PROMPT_DONT_SAVE = 945,
+    STR_SAVE_PROMPT_CANCEL = 946,
+    STR_SAVE_BEFORE_LOADING = 947,
+    STR_SAVE_BEFORE_QUITTING = 948,
+    STR_SAVE_BEFORE_QUITTING_2 = 949,
+    STR_LOAD_GAME_PROMPT_TITLE = 950,
+    STR_QUIT_GAME_PROMPT_TITLE = 951,
+    STR_QUIT_GAME_2_PROMPT_TITLE = 952,
+    STR_LOAD_LANDSCAPE_PROMPT_TITLE = 953,
+    STR_CONSTRUCTION_ERR_UNKNOWN = 954,
+    STR_RIDE_CONSTRUCTION_SELECT_SEAT_ROTATION_ANGLE_TIP = 955,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_NEG_180 = 956,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_NEG_135 = 957,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_NEG_90 = 958,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_NEG_45 = 959,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_0 = 960,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_45 = 961,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_90 = 962,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_135 = 963,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_180 = 964,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_225 = 965,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_270 = 966,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_315 = 967,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_360 = 968,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_405 = 969,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_450 = 970,
+    STR_RIDE_CONSTRUCTION_SEAT_ROTATION_ANGLE_495 = 971,
+    STR_CANCEL = 972,
+    STR_OK = 973,
+    STR_RIDES = 974,
+    STR_SHOPS_AND_STALLS = 975,
+    STR_RESTROOMS_AND_INFORMATION_KIOSKS = 976,
+    STR_NEW_TRANSPORT_RIDES = 977,
+    STR_NEW_GENTLE_RIDES = 978,
+    STR_NEW_ROLLER_COASTERS = 979,
+    STR_NEW_THRILL_RIDES = 980,
+    STR_NEW_WATER_RIDES = 981,
+    STR_NEW_SHOPS_STALLS = 982,
+    STR_RESEARCH_AND_DEVELOPMENT = 983,
+    STR_RAISE_COST_AMOUNT = 984,
+    STR_LOWER_COST_AMOUNT = 985,
+    STR_COST_AMOUNT = 986,
+    STR_TOO_MANY_RIDES = 987,
+    STR_CANT_CREATE_NEW_RIDE_ATTRACTION = 988,
+    STR_RIDE_WINDOW_TITLE = 989,
+    STR_CONSTRUCTION = 990,
+    STR_STATION_PLATFORM = 991,
+    STR_DEMOLISH_RIDE_TIP = 992,
+    STR_DEMOLISH_RIDE = 993,
+    STR_DEMOLISH = 994,
+    STR_DEMOLISH_RIDE_ID = 995,
+    STR_OVERALL_VIEW = 996,
+    STR_VIEW_SELECTION = 997,
+    STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE = 998,
+    STR_REQUIRES_A_STATION_PLATFORM = 999,
+    STR_TRACK_IS_NOT_A_COMPLETE_CIRCUIT = 1000,
+    STR_TRACK_UNSUITABLE_FOR_TYPE_OF_TRAIN = 1001,
+    STR_CANT_OPEN = 1002,
+    STR_CANT_TEST = 1003,
+    STR_CANT_CLOSE = 1004,
+    STR_CANT_START_CONSTRUCTION_ON = 1005,
+    STR_MUST_BE_CLOSED_FIRST = 1006,
+    STR_UNABLE_TO_CREATE_ENOUGH_VEHICLES = 1007,
+    STR_OPEN_CLOSE_OR_TEST_RIDE = 1008,
+    STR_OPEN_OR_CLOSE_ALL_RIDES = 1009,
+    STR_OPEN_OR_CLOSE_PARK_TIP = 1010,
+    STR_CLOSE_ALL = 1011,
+    STR_OPEN_ALL = 1012,
+    STR_CLOSE_PARK = 1013,
+    STR_OPEN_PARK = 1014,
+    STR_UNABLE_TO_OPERATE_WITH_MORE_THAN_ONE_STATION_IN_THIS_MODE = 1015,
+    STR_UNABLE_TO_OPERATE_WITH_LESS_THAN_TWO_STATIONS_IN_THIS_MODE = 1016,
+    STR_CANT_CHANGE_OPERATING_MODE = 1017,
+    STR_RIDE_SET_VEHICLE_TYPE_FAIL = 1018,
+    STR_RIDE_SET_VEHICLE_SET_NUM_CARS_PER_TRAIN_FAIL = 1019,
+    STR_RIDE_SET_VEHICLE_SET_NUM_TRAINS_FAIL = 1020,
+    STR_RIDE_VEHICLE_COUNT = 1021,
+    STR_1_CAR_PER_TRAIN = 1022,
+    STR_X_CARS_PER_TRAIN = 1023,
+
+
+    STR_STATION_PLATFORM_TOO_LONG = 1026,
+    STR_LOCATE_SUBJECT_TIP = 1027,
+    STR_OFF_EDGE_OF_MAP = 1028,
+    STR_CANNOT_BUILD_PARTLY_ABOVE_AND_PARTLY_BELOW_WATER = 1029,
+    STR_CAN_ONLY_BUILD_THIS_UNDERWATER = 1030,
+    STR_RIDE_CANT_BUILD_THIS_UNDERWATER = 1031,
+    STR_CAN_ONLY_BUILD_THIS_ON_WATER = 1032,
+    STR_CAN_ONLY_BUILD_THIS_ABOVE_GROUND = 1033,
+    STR_CAN_ONLY_BUILD_THIS_ON_LAND = 1034,
+    STR_LOCAL_AUTHORITY_WONT_ALLOW_CONSTRUCTION_ABOVE_TREE_HEIGHT = 1035,
+    STR_FILE_DIALOG_TITLE_LOAD_GAME = 1036,
+    STR_FILE_DIALOG_TITLE_LOAD_LANDSCAPE = 1037,
+    STR_FILE_DIALOG_TITLE_CONVERT_SAVED_GAME_TO_SCENARIO = 1038,
+    STR_FILE_DIALOG_TITLE_INSTALL_NEW_TRACK_DESIGN = 1039,
+    STR_FILE_DIALOG_TITLE_SAVE_GAME = 1040,
+    STR_FILE_DIALOG_TITLE_SAVE_SCENARIO = 1041,
+    STR_FILE_DIALOG_TITLE_SAVE_LANDSCAPE = 1042,
+    STR_OPENRCT2_SAVED_GAME = 1043,
+    STR_OPENRCT2_SCENARIO_FILE = 1044,
+    STR_OPENRCT2_LANDSCAPE_FILE = 1045,
+    STR_OPENRCT2_TRACK_DESIGN_FILE = 1046,
+    STR_GAME_SAVE_FAILED = 1047,
+    STR_SCENARIO_SAVE_FAILED = 1048,
+    STR_LANDSCAPE_SAVE_FAILED = 1049,
+    STR_FAILED_TO_LOAD_FILE_CONTAINS_INVALID_DATA = 1050,
+    STR_INVISIBLE_SUPPORTS = 1051,
+    STR_INVISIBLE_PEOPLE = 1052,
+    STR_RIDES_IN_PARK_TIP = 1053,
+    STR_NAME_RIDE_TIP = 1054,
+    STR_NAME_GUEST_TIP = 1055,
+    STR_NAME_STAFF_TIP = 1056,
+    STR_RIDE_ATTRACTION_NAME = 1057,
+    STR_ENTER_NEW_NAME_FOR_THIS_RIDE_ATTRACTION = 1058,
+    STR_CANT_RENAME_RIDE_ATTRACTION = 1059,
+    STR_INVALID_RIDE_ATTRACTION_NAME = 1060,
+    STR_RIDE_MODE_NORMAL = 1061,
+    STR_RIDE_MODE_CONTINUOUS_CIRCUIT = 1062,
+    STR_RIDE_MODE_REVERSE_INCLINE_LAUNCHED_SHUTTLE = 1063,
+    STR_RIDE_MODE_POWERED_LAUNCH_PASSTROUGH = 1064,
+    STR_RIDE_MODE_SHUTTLE = 1065,
+    STR_RIDE_MODE_BOAT_HIRE = 1066,
+    STR_RIDE_MODE_UPWARD_LAUNCH = 1067,
+    STR_RIDE_MODE_ROTATING_LIFT = 1068,
+    STR_RIDE_MODE_STATION_TO_STATION = 1069,
+    STR_RIDE_MODE_SINGLE_RIDE_PER_ADMISSION = 1070,
+    STR_RIDE_MODE_UNLIMITED_RIDES_PER_ADMISSION = 1071,
+    STR_RIDE_MODE_MAZE = 1072,
+    STR_RIDE_MODE_RACE = 1073,
+    STR_RIDE_MODE_DODGEMS = 1074,
+    STR_RIDE_MODE_SWING = 1075,
+    STR_RIDE_MODE_SHOP_STALL = 1076,
+    STR_RIDE_MODE_ROTATION = 1077,
+    STR_RIDE_MODE_FORWARD_ROTATION = 1078,
+    STR_RIDE_MODE_BACKWARD_ROTATION = 1079,
+    STR_RIDE_MODE_FILM_AVENGING_AVIATORS = 1080,
+    STR_RIDE_MODE_3D_FILM_MOUSE_TAILS = 1081,
+    STR_RIDE_MODE_SPACE_RINGS = 1082,
+    STR_RIDE_MODE_BEGINNERS = 1083,
+    STR_RIDE_MODE_LIM_POWERED_LAUNCH = 1084,
+    STR_RIDE_MODE_FILM_THRILL_RIDERS = 1085,
+    STR_RIDE_MODE_3D_FILM_STORM_CHASERS = 1086,
+    STR_RIDE_MODE_3D_FILM_SPACE_RAIDERS = 1087,
+    STR_RIDE_MODE_INTENSE = 1088,
+    STR_RIDE_MODE_BERSERK = 1089,
+    STR_RIDE_MODE_HAUNTED_HOUSE = 1090,
+    STR_RIDE_MODE_CIRCUS_SHOW = 1091,
+    STR_RIDE_MODE_DOWNWARD_LAUNCH = 1092,
+    STR_RIDE_MODE_CROOKED_HOUSE = 1093,
+    STR_RIDE_MODE_FREEFALL_DROP = 1094,
+    STR_RIDE_MODE_CONTINUOUS_CIRCUIT_BLOCK_SECTIONED = 1095,
+    STR_RIDE_MODE_POWERED_LAUNCH = 1096,
+    STR_RIDE_MODE_POWERED_LAUNCH_BLOCK_SECTIONED_MODE = 1097,
+    STR_MOVING_TO_END_OF = 1098,
+    STR_WAITING_FOR_PASSENGERS_AT = 1099,
+    STR_WAITING_TO_DEPART = 1100,
+    STR_DEPARTING = 1101,
+    STR_TRAVELLING_AT_0 = 1102,
+    STR_ARRIVING_AT = 1103,
+    STR_UNLOADING_PASSENGERS_AT = 1104,
+    STR_TRAVELLING_AT_1 = 1105,
+    STR_CRASHING = 1106,
+    STR_CRASHED_0 = 1107,
+    STR_TRAVELLING_AT_2 = 1108,
+    STR_SWINGING = 1109,
+    STR_ROTATING_0 = 1110,
+    STR_ROTATING_1 = 1111,
+    STR_OPERATING_0 = 1112,
+    STR_SHOWING_FILM = 1113,
+    STR_ROTATING_2 = 1114,
+    STR_OPERATING_1 = 1115,
+    STR_OPERATING_2 = 1116,
+    STR_DOING_CIRCUS_SHOW = 1117,
+    STR_OPERATING_3 = 1118,
+    STR_WAITING_FOR_CABLE_LIFT = 1119,
+    STR_TRAVELLING_AT_3 = 1120,
+    STR_STOPPING_0 = 1121,
+    STR_WAITING_FOR_PASSENGERS = 1122,
+    STR_WAITING_TO_START = 1123,
+    STR_STARTING = 1124,
+    STR_OPERATING = 1125,
+    STR_STOPPING_1 = 1126,
+    STR_UNLOADING_PASSENGERS = 1127,
+    STR_STOPPED_BY_BLOCK_BRAKES = 1128,
+    STR_ALL_VEHICLES_IN_SAME_COLOURS = 1129,
+    STR_DIFFERENT_COLOURS_PER = 1130,
+    STR_DIFFERENT_COLOURS_PER_VEHICLE = 1131,
+    STR_RIDE_COLOUR_VEHICLE_VALUE = 1132,
+    STR_RIDE_COLOUR_VEHICLE_OPTION = 1133,
+    STR_RIDE_COLOUR_TRAIN_VALUE = 1134,
+    STR_RIDE_COLOUR_TRAIN_OPTION = 1135,
+    STR_SELECT_MAIN_COLOUR_TIP = 1136,
+    STR_SELECT_ADDITIONAL_COLOUR_1_TIP = 1137,
+    STR_SELECT_ADDITIONAL_COLOUR_2_TIP = 1138,
+    STR_SELECT_SUPPORT_STRUCTURE_COLOUR_TIP = 1139,
+    STR_SELECT_VEHICLE_COLOUR_SCHEME_TIP = 1140,
+    STR_SELECT_VEHICLE_TO_MODIFY_TIP = 1141,
+    STR_DROPDOWN_MENU_LABEL = 1142,
+    STR_DROPDOWN_MENU_LABEL_SELECTED = 1143,
+    STR_CANT_BUILD_MOVE_ENTRANCE_FOR_THIS_RIDE_ATTRACTION = 1144,
+    STR_CANT_BUILD_MOVE_EXIT_FOR_THIS_RIDE_ATTRACTION = 1145,
+    STR_ENTRANCE_NOT_YET_BUILT = 1146,
+    STR_EXIT_NOT_YET_BUILT = 1147,
+    STR_QUARTER_LOAD = 1148,
+    STR_HALF_LOAD = 1149,
+    STR_THREE_QUARTER_LOAD = 1150,
+    STR_FULL_LOAD = 1151,
+    STR_ANY_LOAD = 1152,
+    STR_HEIGHT_MARKS_ON_RIDE_TRACKS = 1153,
+    STR_HEIGHT_MARKS_ON_LAND = 1154,
+    STR_HEIGHT_MARKS_ON_PATHS = 1155,
+    STR_TOGGLE_OPTION = 1156,
+    STR_TOGGLE_OPTION_CHECKED = 1157,
+    STR_CANT_REMOVE_THIS = 1158,
+    STR_PLACE_SCENERY_TIP = 1159,
+    STR_ADJUST_WATER_TIP = 1160,
+    STR_CANT_POSITION_THIS_HERE = 1161,
+    STR_MAP_TOOLTIP_STRINGID = 1162,
+    STR_MAP_TOOLTIP_STRINGID_CLICK_TO_MODIFY = 1163,
+    STR_MAP_TOOLTIP_STRINGID_CLICK_TO_REMOVE = 1164,
+    STR_MAP_TOOLTIP_STRINGID_STRINGID = 1165,
+    STR_CANT_LOWER_WATER_LEVEL_HERE = 1166,
+    STR_CANT_RAISE_WATER_LEVEL_HERE = 1167,
+    STR_OPTIONS_TITLE = 1168,
+    STR_SOUND_NONE = 1169,
+    STR_STRING = 1170,
+    STR_RIDE_ENTRANCE_CLOSED = 1171,
+    STR_RIDE_ENTRANCE_NAME = 1172,
+    STR_BUILD_FOOTPATH_TIP = 1173,
+    STR_BANNER_SIGN_IN_THE_WAY = 1174,
+    STR_CANT_BUILD_THIS_ON_SLOPED_FOOTPATH = 1175,
+    STR_CANT_BUILD_FOOTPATH_HERE = 1176,
+    STR_CANT_REMOVE_FOOTPATH_FROM_HERE = 1177,
+    STR_LAND_SLOPE_UNSUITABLE = 1178,
+    STR_FOOTPATH_IN_THE_WAY = 1179,
+    STR_CANT_BUILD_THIS_UNDERWATER = 1180,
+    STR_FOOTPATHS = 1181,
+    STR_TYPE = 1182,
+    STR_DIRECTION = 1183,
+    STR_SLOPE = 1184,
+    STR_DIRECTION_TIP = 1185,
+    STR_SLOPE_DOWN_TIP = 1186,
+    STR_LEVEL_TIP = 1187,
+    STR_SLOPE_UP_TIP = 1188,
+    STR_CONSTRUCT_THE_SELECTED_FOOTPATH_SECTION_TIP = 1189,
+    STR_REMOVE_PREVIOUS_FOOTPATH_SECTION_TIP = 1190,
+    STR_BLACK_STRING = 1191,
+    STR_RED_OUTLINED_STRING = 1192,
+    STR_WINDOW_COLOUR_2_STRINGID = 1193,
+    STR_CLOSED = 1194,
+    STR_TEST_RUN = 1195,
+    STR_OPEN = 1196,
+    STR_BROKEN_DOWN = 1197,
+    STR_CRASHED = 1198,
+    STR_PERSON_ON_RIDE = 1199,
+    STR_PEOPLE_ON_RIDE = 1200,
+    STR_QUEUE_EMPTY = 1201,
+    STR_QUEUE_ONE_PERSON = 1202,
+    STR_QUEUE_PEOPLE = 1203,
+    STR_QUEUE_TIME_LABEL = 1204,
+    STR_QUEUE_TIME_PLURAL_LABEL = 1205,
+    STR_WAIT_FOR = 1206,
+    STR_LEAVE_IF_ANOTHER_TRAIN_ARRIVES = 1207,
+    STR_LEAVE_IF_ANOTHER_BOAT_ARRIVES = 1208,
+    STR_WAIT_FOR_PASSENGERS_BEFORE_DEPARTING_TIP = 1209,
+    STR_LEAVE_IF_ANOTHER_VEHICLE_ARRIVES_TIP = 1210,
+    STR_MINIMUM_WAITING_TIME = 1211,
+    STR_MAXIMUM_WAITING_TIME = 1212,
+    STR_MINIMUM_LENGTH_BEFORE_DEPARTING_TIP = 1213,
+    STR_MAXIMUM_LENGTH_BEFORE_DEPARTING_TIP = 1214,
+    STR_SYNCHRONISE_WITH_ADJACENT_STATIONS = 1215,
+    STR_SYNCHRONISE_WITH_ADJACENT_STATIONS_TIP = 1216,
+    STR_FORMAT_SECONDS = 1217,
+    STR_NUMERIC_UP = 1218,
+    STR_NUMERIC_DOWN = 1219,
+    STR_EXIT_ONLY = 1220,
+    STR_NO_ENTRANCE = 1221,
+    STR_NO_EXIT = 1222,
+    STR_TRANSPORT_RIDES_TIP = 1223,
+    STR_GENTLE_RIDES_TIP = 1224,
+    STR_ROLLER_COASTERS_TIP = 1225,
+    STR_THRILL_RIDES_TIP = 1226,
+    STR_WATER_RIDES_TIP = 1227,
+    STR_SHOPS_STALLS_TIP = 1228,
+    STR_RIDE_COMPONENT_TRAIN = 1229,
+    STR_RIDE_COMPONENT_TRAIN_PLURAL = 1230,
+    STR_RIDE_COMPONENT_TRAIN_CAPITALISED = 1231,
+    STR_RIDE_COMPONENT_TRAIN_CAPITALISED_PLURAL = 1232,
+    STR_RIDE_COMPONENT_TRAIN_COUNT = 1233,
+    STR_RIDE_COMPONENT_TRAIN_COUNT_PLURAL = 1234,
+    STR_RIDE_COMPONENT_TRAIN_NO = 1235,
+    STR_RIDE_COMPONENT_BOAT = 1236,
+    STR_RIDE_COMPONENT_BOAT_PLURAL = 1237,
+    STR_RIDE_COMPONENT_BOAT_CAPITALISED = 1238,
+    STR_RIDE_COMPONENT_BOAT_CAPITALISED_PLURAL = 1239,
+    STR_RIDE_COMPONENT_BOAT_COUNT = 1240,
+    STR_RIDE_COMPONENT_BOAT_COUNT_PLURAL = 1241,
+    STR_RIDE_COMPONENT_BOAT_NO = 1242,
+    STR_RIDE_COMPONENT_TRACK = 1243,
+    STR_RIDE_COMPONENT_TRACK_PLURAL = 1244,
+    STR_RIDE_COMPONENT_TRACK_CAPITALISED = 1245,
+    STR_RIDE_COMPONENT_TRACK_CAPITALISED_PLURAL = 1246,
+    STR_RIDE_COMPONENT_TRACK_COUNT = 1247,
+    STR_RIDE_COMPONENT_TRACK_COUNT_PLURAL = 1248,
+    STR_RIDE_COMPONENT_TRACK_NO = 1249,
+    STR_RIDE_COMPONENT_DOCKING_PLATFORM = 1250,
+    STR_RIDE_COMPONENT_DOCKING_PLATFORM_PLURAL = 1251,
+    STR_RIDE_COMPONENT_DOCKING_PLATFORM_CAPITALISED = 1252,
+    STR_RIDE_COMPONENT_DOCKING_PLATFORM_CAPITALISED_PLURAL = 1253,
+    STR_RIDE_COMPONENT_DOCKING_PLATFORM_COUNT = 1254,
+    STR_RIDE_COMPONENT_DOCKING_PLATFORM_COUNT_PLURAL = 1255,
+    STR_RIDE_COMPONENT_DOCKING_PLATFORM_NO = 1256,
+    STR_RIDE_COMPONENT_STATION = 1257,
+    STR_RIDE_COMPONENT_STATION_PLURAL = 1258,
+    STR_RIDE_COMPONENT_STATION_CAPITALISED = 1259,
+    STR_RIDE_COMPONENT_STATION_CAPITALISED_PLURAL = 1260,
+    STR_RIDE_COMPONENT_STATION_COUNT = 1261,
+    STR_RIDE_COMPONENT_STATION_COUNT_PLURAL = 1262,
+    STR_RIDE_COMPONENT_STATION_NO = 1263,
+    STR_RIDE_COMPONENT_CAR = 1264,
+    STR_RIDE_COMPONENT_CAR_PLURAL = 1265,
+    STR_RIDE_COMPONENT_CAR_CAPITALISED = 1266,
+    STR_RIDE_COMPONENT_CAR_CAPITALISED_PLURAL = 1267,
+    STR_RIDE_COMPONENT_CAR_COUNT = 1268,
+    STR_RIDE_COMPONENT_CAR_COUNT_PLURAL = 1269,
+    STR_RIDE_COMPONENT_CAR_NO = 1270,
+    STR_RIDE_COMPONENT_BUILDING = 1271,
+    STR_RIDE_COMPONENT_BUILDING_PLURAL = 1272,
+    STR_RIDE_COMPONENT_BUILDING_CAPITALISED = 1273,
+    STR_RIDE_COMPONENT_BUILDING_CAPITALISED_PLURAL = 1274,
+    STR_RIDE_COMPONENT_BUILDING_COUNT = 1275,
+    STR_RIDE_COMPONENT_BUILDING_COUNT_PLURAL = 1276,
+    STR_RIDE_COMPONENT_BUILDING_NO = 1277,
+    STR_RIDE_COMPONENT_STRUCTURE = 1278,
+    STR_RIDE_COMPONENT_STRUCTURE_PLURAL = 1279,
+    STR_RIDE_COMPONENT_STRUCTURE_CAPITALISED = 1280,
+    STR_RIDE_COMPONENT_STRUCTURE_CAPITALISED_PLURAL = 1281,
+    STR_RIDE_COMPONENT_STRUCTURE_COUNT = 1282,
+    STR_RIDE_COMPONENT_STRUCTURE_COUNT_PLURAL = 1283,
+    STR_RIDE_COMPONENT_STRUCTURE_NO = 1284,
+    STR_RIDE_COMPONENT_SHIP = 1285,
+    STR_RIDE_COMPONENT_SHIP_PLURAL = 1286,
+    STR_RIDE_COMPONENT_SHIP_CAPITALISED = 1287,
+    STR_RIDE_COMPONENT_SHIP_CAPITALISED_PLURAL = 1288,
+    STR_RIDE_COMPONENT_SHIP_COUNT = 1289,
+    STR_RIDE_COMPONENT_SHIP_COUNT_PLURAL = 1290,
+    STR_RIDE_COMPONENT_SHIP_NO = 1291,
+    STR_RIDE_COMPONENT_CABIN = 1292,
+    STR_RIDE_COMPONENT_CABIN_PLURAL = 1293,
+    STR_RIDE_COMPONENT_CABIN_CAPITALISED = 1294,
+    STR_RIDE_COMPONENT_CABIN_CAPITALISED_PLURAL = 1295,
+    STR_RIDE_COMPONENT_CABIN_COUNT = 1296,
+    STR_RIDE_COMPONENT_CABIN_COUNT_PLURAL = 1297,
+    STR_RIDE_COMPONENT_CABIN_NO = 1298,
+    STR_RIDE_COMPONENT_WHEEL = 1299,
+    STR_RIDE_COMPONENT_WHEEL_PLURAL = 1300,
+    STR_RIDE_COMPONENT_WHEEL_CAPITALISED = 1301,
+    STR_RIDE_COMPONENT_WHEEL_CAPITALISED_PLURAL = 1302,
+    STR_RIDE_COMPONENT_WHEEL_COUNT = 1303,
+    STR_RIDE_COMPONENT_WHEEL_COUNT_PLURAL = 1304,
+    STR_RIDE_COMPONENT_WHEEL_NO = 1305,
+    STR_RIDE_COMPONENT_RING = 1306,
+    STR_RIDE_COMPONENT_RING_PLURAL = 1307,
+    STR_RIDE_COMPONENT_RING_CAPITALISED = 1308,
+    STR_RIDE_COMPONENT_RING_CAPITALISED_PLURAL = 1309,
+    STR_RIDE_COMPONENT_RING_COUNT = 1310,
+    STR_RIDE_COMPONENT_RING_COUNT_PLURAL = 1311,
+    STR_RIDE_COMPONENT_RING_NO = 1312,
+    STR_RIDE_COMPONENT_PLAYER = 1313,
+    STR_RIDE_COMPONENT_PLAYER_PLURAL = 1314,
+    STR_RIDE_COMPONENT_PLAYER_CAPITALISED = 1315,
+    STR_RIDE_COMPONENT_PLAYER_CAPITALISED_PLURAL = 1316,
+    STR_RIDE_COMPONENT_PLAYER_COUNT = 1317,
+    STR_RIDE_COMPONENT_PLAYER_COUNT_PLURAL = 1318,
+    STR_RIDE_COMPONENT_PLAYER_NO = 1319,
+    STR_RIDE_COMPONENT_COURSE = 1320,
+    STR_RIDE_COMPONENT_COURSE_PLURAL = 1321,
+    STR_RIDE_COMPONENT_COURSE_CAPITALISED = 1322,
+    STR_RIDE_COMPONENT_COURSE_CAPITALISED_PLURAL = 1323,
+    STR_RIDE_COMPONENT_COURSE_COUNT = 1324,
+    STR_RIDE_COMPONENT_COURSE_COUNT_PLURAL = 1325,
+    STR_RIDE_COMPONENT_COURSE_NO = 1326,
+    STR_ROTATE_OBJECTS_90 = 1327,
+    STR_LEVEL_LAND_REQUIRED = 1328,
+    STR_LAUNCH_SPEED = 1329,
+    STR_LAUNCH_SPEED_TIP = 1330,
+    STR_RIDE_MODE_SPEED_VALUE = 1331,
+
+    STR_RIDE_STATION = 1333,
+    STR_RIDE_STATION_X = 1334,
+    STR_RIDE_ENTRANCE = 1335,
+    STR_RIDE_STATION_X_ENTRANCE = 1336,
+    STR_RIDE_EXIT = 1337,
+    STR_RIDE_STATION_X_EXIT = 1338,
+    STR_NO_TEST_RESULTS_YET = 1339,
+    STR_MAX_SPEED = 1340,
+    STR_RIDE_TIME = 1341,
+    STR_RIDE_TIME_ENTRY = 1342,
+    STR_RIDE_TIME_ENTRY_WITH_SEPARATOR = 1343,
+    STR_RIDE_LENGTH = 1344,
+    STR_RIDE_LENGTH_ENTRY = 1345,
+    STR_RIDE_LENGTH_ENTRY_WITH_SEPARATOR = 1346,
+    STR_AVERAGE_SPEED = 1347,
+    STR_MAX_POSITIVE_VERTICAL_G = 1348,
+    STR_MAX_POSITIVE_VERTICAL_G_RED = 1349,
+    STR_MAX_NEGATIVE_VERTICAL_G = 1350,
+    STR_MAX_NEGATIVE_VERTICAL_G_RED = 1351,
+    STR_MAX_LATERAL_G = 1352,
+    STR_MAX_LATERAL_G_RED = 1353,
+    STR_HIGHEST_DROP_HEIGHT = 1354,
+    STR_DROPS = 1355,
+    STR_INVERSIONS = 1356,
+    STR_HOLES = 1357,
+    STR_TOTAL_AIR_TIME = 1358,
+    STR_QUEUE_TIME_MINUTE = 1359,
+    STR_QUEUE_TIME_MINUTES = 1360,
+    STR_CANT_CHANGE_SPEED = 1361,
+    STR_CANT_CHANGE_LAUNCH_SPEED = 1362,
+    STR_TOO_HIGH_FOR_SUPPORTS = 1363,
+    STR_SUPPORTS_CANT_BE_EXTENDED = 1364,
+    STR_IN_LINE_TWIST_LEFT = 1365,
+    STR_IN_LINE_TWIST_RIGHT = 1366,
+    STR_HALF_LOOP = 1367,
+    STR_HALF_CORKSCREW_LEFT = 1368,
+    STR_HALF_CORKSCREW_RIGHT = 1369,
+    STR_BARREL_ROLL_LEFT = 1370,
+    STR_BARREL_ROLL_RIGHT = 1371,
+    STR_LAUNCHED_LIFT_HILL = 1372,
+    STR_LARGE_HALF_LOOP_LEFT = 1373,
+    STR_LARGE_HALF_LOOP_RIGHT = 1374,
+    STR_UPPER_TRANSFER = 1375,
+    STR_LOWER_TRANSFER = 1376,
+    STR_HEARTLINE_ROLL_LEFT = 1377,
+    STR_HEARTLINE_ROLL_RIGHT = 1378,
+    STR_REVERSER_LEFT = 1379,
+    STR_REVERSER_RIGHT = 1380,
+    STR_CURVED_LIFT_HILL_LEFT = 1381,
+    STR_CURVED_LIFT_HILL_RIGHT = 1382,
+    STR_QUARTER_LOOP = 1383,
+    STR_YELLOW_STRING = 1384,
+    STR_RIDE_CONSTRUCTION_OTHER_TRACK_CONFIGURATIONS_TIP = 1385,
+    STR_RIDE_CONSTRUCTION_SPECIAL = 1386,
+    STR_CANT_CHANGE_LAND_TYPE = 1387,
+    STR_MONEY_EFFECT_RECEIVE = 1388,
+    STR_MONEY_EFFECT_SPEND = 1389,
+    STR_BOTTOM_TOOLBAR_CASH = 1390,
+    STR_BOTTOM_TOOLBAR_CASH_NEGATIVE = 1391,
+    STR_VIEW_OF_RIDE_ATTRACTION_TIP = 1392,
+    STR_VEHICLE_DETAILS_AND_OPTIONS_TIP = 1393,
+    STR_OPERATING_OPTIONS_TIP = 1394,
+    STR_MAINTENANCE_OPTIONS_TIP = 1395,
+    STR_COLOUR_SCHEME_OPTIONS_TIP = 1396,
+    STR_SOUND_AND_MUSIC_OPTIONS_TIP = 1397,
+    STR_MEASUREMENTS_AND_TEST_DATA_TIP = 1398,
+    STR_GRAPHS_TIP = 1399,
+    STR_RIDE_CONSTRUCTION_ENTRANCE = 1400,
+    STR_RIDE_CONSTRUCTION_EXIT = 1401,
+    STR_RIDE_CONSTRUCTION_ENTRANCE_TIP = 1402,
+    STR_RIDE_CONSTRUCTION_EXIT_TIP = 1403,
+    STR_ROTATE_90_TIP = 1404,
+    STR_MIRROR_IMAGE_TIP = 1405,
+    STR_TOGGLE_SCENERY_TIP = 1406,
+    STR_BUILD_THIS = 1407,
+    STR_COST_LABEL = 1408,
+    STR_ENTRY_EXIT_PLATFORM = 1409,
+    STR_VERTICAL_TOWER = 1410,
+    STR_X_IN_THE_WAY = 1411,
+    STR_DATA_LOGGING_NOT_AVAILABLE_FOR_THIS_TYPE_OF_RIDE = 1412,
+    STR_DATA_LOGGING_WILL_START_WHEN_NEXT_LEAVES = 1413,
+    STR_RIDE_STATS_TIME = 1414,
+    STR_RIDE_STATS_VELOCITY = 1415,
+    STR_RIDE_STATS_ALTITUDE = 1416,
+    STR_RIDE_STATS_VERT_G = 1417,
+    STR_RIDE_STATS_LAT_G = 1418,
+    STR_RIDE_STATS_VELOCITY_FORMAT = 1419,
+    STR_RIDE_STATS_ALTITUDE_FORMAT = 1420,
+    STR_RIDE_STATS_G_FORCE_FORMAT = 1421,
+    STR_LOGGING_DATA_FROM_TIP = 1422,
+    STR_QUEUE_LINE_PATH_TIP = 1423,
+    STR_FOOTPATH_TIP = 1424,
+    STR_FOOTPATH_MAP_TIP = 1425,
+    STR_QUEUE_LINE_MAP_TIP = 1426,
+    STR_CUSTOMERS_PER_HOUR = 1427,
+    STR_RIDE_INCOME_ADMISSION_PRICE = 1428,
+    STR_ARG_6_CURRENCY2DP = 1429,
+    STR_FREE = 1430,
+    STR_WALKING = 1431,
+    STR_HEADING_FOR = 1432,
+    STR_QUEUING_FOR = 1433,
+    STR_DROWNING = 1434,
+    STR_ON_RIDE = 1435,
+    STR_IN_RIDE = 1436,
+    STR_AT_RIDE = 1437,
+    STR_SITTING = 1438,
+    STR_SELECT_LOCATION = 1439,
+    STR_MOWING_GRASS = 1440,
+    STR_SWEEPING_FOOTPATH = 1441,
+    STR_EMPTYING_LITTER_BIN = 1442,
+    STR_WATERING_GARDENS = 1443,
+    STR_WATCHING_RIDE = 1444,
+    STR_WATCHING_CONSTRUCTION_OF = 1445,
+    STR_LOOKING_AT_SCENERY = 1446,
+    STR_LEAVING_PARK = 1447,
+    STR_WATCHING_NEW_RIDE_BEING_CONSTRUCTED = 1448,
+    STR_GUEST_MAP_TIP = 1449,
+    STR_TRACKED_GUEST_MAP_TIP = 1450,
+    STR_STAFF_MAP_TIP = 1451,
+    STR_GUEST_RENAME_TITLE = 1452,
+    STR_GUEST_RENAME_PROMPT = 1453,
+    STR_CANT_NAME_GUEST = 1454,
+    STR_ERR_INVALID_NAME_FOR_GUEST = 1455,
+    STR_GUEST_STAT_CASH_SPENT = 1456,
+    STR_GUEST_STAT_CASH_IN_POCKET = 1457,
+    STR_GUEST_STAT_TIME_IN_PARK = 1458,
+    STR_RIDE_CONSTRUCTION_TRACK_STYLE = 1459,
+    STR_RIDE_CONSTRUCTION_U_SHAPED_OPEN_TRACK_TIP = 1460,
+    STR_RIDE_CONSTRUCTION_O_SHAPED_ENCLOSED_TRACK_TIP = 1461,
+    STR_TOO_STEEP_FOR_LIFT_HILL = 1462,
+    STR_GUESTS = 1463,
+    STR_HELIX_UP_SMALL = 1464,
+    STR_HELIX_UP_LARGE = 1465,
+    STR_HELIX_DOWN_SMALL = 1466,
+    STR_HELIX_DOWN_LARGE = 1467,
+    STR_STAFF = 1468,
+    STR_RIDE_MUST_START_AND_END_WITH_STATIONS = 1469,
+    STR_STATION_NOT_LONG_ENOUGH = 1470,
+    STR_SPEED = 1471,
+    STR_SPEED_TIP = 1472,
+    STR_EXCITEMENT_RATING = 1473,
+    STR_EXCITEMENT_RATING_NOT_YET_AVAILABLE = 1474,
+    STR_INTENSITY_RATING = 1475,
+    STR_INTENSITY_RATING_NOT_YET_AVAILABLE = 1476,
+    STR_INTENSITY_RATING_RED = 1477,
+    STR_NAUSEA_RATING = 1478,
+    STR_NAUSEA_RATING_NOT_YET_AVAILABLE = 1479,
+    STR_PEEP_THOUGHT_TYPE_CANT_AFFORD_0 = 1480,
+    STR_PEEP_THOUGHT_TYPE_SPENT_MONEY = 1481,
+    STR_PEEP_THOUGHT_TYPE_SICK = 1482,
+    STR_PEEP_THOUGHT_TYPE_VERY_SICK = 1483,
+    STR_PEEP_THOUGHT_TYPE_MORE_THRILLING = 1484,
+    STR_PEEP_THOUGHT_TYPE_INTENSE = 1485,
+    STR_PEEP_THOUGHT_TYPE_HAVENT_FINISHED = 1486,
+    STR_PEEP_THOUGHT_TYPE_SICKENING = 1487,
+    STR_PEEP_THOUGHT_TYPE_BAD_VALUE = 1488,
+    STR_PEEP_THOUGHT_TYPE_GO_HOME = 1489,
+    STR_PEEP_THOUGHT_TYPE_GOOD_VALUE = 1490,
+    STR_PEEP_THOUGHT_TYPE_ALREADY_GOT = 1491,
+    STR_PEEP_THOUGHT_TYPE_CANT_AFFORD = 1492,
+    STR_PEEP_THOUGHT_TYPE_NOT_HUNGRY = 1493,
+    STR_PEEP_THOUGHT_TYPE_NOT_THIRSTY = 1494,
+    STR_PEEP_THOUGHT_TYPE_DROWNING = 1495,
+    STR_PEEP_THOUGHT_TYPE_LOST = 1496,
+    STR_PEEP_THOUGHT_TYPE_WAS_GREAT = 1497,
+    STR_PEEP_THOUGHT_TYPE_QUEUING_AGES = 1498,
+    STR_PEEP_THOUGHT_TYPE_TIRED = 1499,
+    STR_PEEP_THOUGHT_TYPE_HUNGRY = 1500,
+    STR_PEEP_THOUGHT_TYPE_THIRSTY = 1501,
+    STR_PEEP_THOUGHT_TYPE_TOILET = 1502,
+    STR_PEEP_THOUGHT_TYPE_CANT_FIND = 1503,
+    STR_PEEP_THOUGHT_TYPE_NOT_PAYING = 1504,
+    STR_PEEP_THOUGHT_TYPE_NOT_WHILE_RAINING = 1505,
+    STR_PEEP_THOUGHT_TYPE_BAD_LITTER = 1506,
+    STR_PEEP_THOUGHT_TYPE_CANT_FIND_EXIT = 1507,
+    STR_PEEP_THOUGHT_TYPE_GET_OFF = 1508,
+    STR_PEEP_THOUGHT_TYPE_GET_OUT = 1509,
+    STR_PEEP_THOUGHT_TYPE_NOT_SAFE = 1510,
+    STR_PEEP_THOUGHT_TYPE_PATH_DISGUSTING = 1511,
+    STR_PEEP_THOUGHT_TYPE_CROWDED = 1512,
+    STR_PEEP_THOUGHT_TYPE_VANDALISM = 1513,
+    STR_PEEP_THOUGHT_TYPE_SCENERY = 1514,
+    STR_PEEP_THOUGHT_TYPE_VERY_CLEAN = 1515,
+    STR_PEEP_THOUGHT_TYPE_FOUNTAINS = 1516,
+    STR_PEEP_THOUGHT_TYPE_MUSIC = 1517,
+    STR_PEEP_THOUGHT_TYPE_BALLOON = 1518,
+    STR_PEEP_THOUGHT_TYPE_TOY = 1519,
+    STR_PEEP_THOUGHT_TYPE_MAP = 1520,
+    STR_PEEP_THOUGHT_TYPE_PHOTO = 1521,
+    STR_PEEP_THOUGHT_TYPE_UMBRELLA = 1522,
+    STR_PEEP_THOUGHT_TYPE_DRINK = 1523,
+    STR_PEEP_THOUGHT_TYPE_BURGER = 1524,
+    STR_PEEP_THOUGHT_TYPE_CHIPS = 1525,
+    STR_PEEP_THOUGHT_TYPE_ICE_CREAM = 1526,
+    STR_PEEP_THOUGHT_TYPE_CANDYFLOSS = 1527,
+
+
+
+    STR_PEEP_THOUGHT_TYPE_PIZZA = 1531,
+
+    STR_PEEP_THOUGHT_TYPE_POPCORN = 1533,
+    STR_PEEP_THOUGHT_TYPE_HOT_DOG = 1534,
+    STR_PEEP_THOUGHT_TYPE_TENTACLE = 1535,
+    STR_PEEP_THOUGHT_TYPE_HAT = 1536,
+    STR_PEEP_THOUGHT_TYPE_TOFFEE_APPLE = 1537,
+    STR_PEEP_THOUGHT_TYPE_TSHIRT = 1538,
+    STR_PEEP_THOUGHT_TYPE_DOUGHNUT = 1539,
+    STR_PEEP_THOUGHT_TYPE_COFFEE = 1540,
+
+    STR_PEEP_THOUGHT_TYPE_CHICKEN = 1542,
+    STR_PEEP_THOUGHT_TYPE_LEMONADE = 1543,
+
+
+
+    STR_PEEP_THOUGHT_TYPE_WOW = 1547,
+
+
+    STR_PEEP_THOUGHT_TYPE_WOW2 = 1550,
+    STR_PEEP_THOUGHT_TYPE_WATCHED = 1551,
+    STR_PEEP_THOUGHT_TYPE_BALLOON_MUCH = 1552,
+    STR_PEEP_THOUGHT_TYPE_TOY_MUCH = 1553,
+    STR_PEEP_THOUGHT_TYPE_MAP_MUCH = 1554,
+    STR_PEEP_THOUGHT_TYPE_PHOTO_MUCH = 1555,
+    STR_PEEP_THOUGHT_TYPE_UMBRELLA_MUCH = 1556,
+    STR_PEEP_THOUGHT_TYPE_DRINK_MUCH = 1557,
+    STR_PEEP_THOUGHT_TYPE_BURGER_MUCH = 1558,
+    STR_PEEP_THOUGHT_TYPE_CHIPS_MUCH = 1559,
+    STR_PEEP_THOUGHT_TYPE_ICE_CREAM_MUCH = 1560,
+    STR_PEEP_THOUGHT_TYPE_CANDYFLOSS_MUCH = 1561,
+
+
+
+    STR_PEEP_THOUGHT_TYPE_PIZZA_MUCH = 1565,
+
+    STR_PEEP_THOUGHT_TYPE_POPCORN_MUCH = 1567,
+    STR_PEEP_THOUGHT_TYPE_HOT_DOG_MUCH = 1568,
+    STR_PEEP_THOUGHT_TYPE_TENTACLE_MUCH = 1569,
+    STR_PEEP_THOUGHT_TYPE_HAT_MUCH = 1570,
+    STR_PEEP_THOUGHT_TYPE_TOFFEE_APPLE_MUCH = 1571,
+    STR_PEEP_THOUGHT_TYPE_TSHIRT_MUCH = 1572,
+    STR_PEEP_THOUGHT_TYPE_DOUGHNUT_MUCH = 1573,
+    STR_PEEP_THOUGHT_TYPE_COFFEE_MUCH = 1574,
+
+    STR_PEEP_THOUGHT_TYPE_CHICKEN_MUCH = 1576,
+    STR_PEEP_THOUGHT_TYPE_LEMONADE_MUCH = 1577,
+
+
+
+
+
+
+    STR_PEEP_THOUGHT_TYPE_PHOTO2 = 1584,
+    STR_PEEP_THOUGHT_TYPE_PHOTO3 = 1585,
+    STR_PEEP_THOUGHT_TYPE_PHOTO4 = 1586,
+    STR_PEEP_THOUGHT_TYPE_PRETZEL = 1587,
+    STR_PEEP_THOUGHT_TYPE_HOT_CHOCOLATE = 1588,
+    STR_PEEP_THOUGHT_TYPE_ICED_TEA = 1589,
+    STR_PEEP_THOUGHT_TYPE_FUNNEL_CAKE = 1590,
+    STR_PEEP_THOUGHT_TYPE_SUNGLASSES = 1591,
+    STR_PEEP_THOUGHT_TYPE_BEEF_NOODLES = 1592,
+    STR_PEEP_THOUGHT_TYPE_FRIED_RICE_NOODLES = 1593,
+    STR_PEEP_THOUGHT_TYPE_WONTON_SOUP = 1594,
+    STR_PEEP_THOUGHT_TYPE_MEATBALL_SOUP = 1595,
+    STR_PEEP_THOUGHT_TYPE_FRUIT_JUICE = 1596,
+    STR_PEEP_THOUGHT_TYPE_SOYBEAN_MILK = 1597,
+    STR_PEEP_THOUGHT_TYPE_SU_JONGKWA = 1598,
+    STR_PEEP_THOUGHT_TYPE_SUB_SANDWICH = 1599,
+    STR_PEEP_THOUGHT_TYPE_COOKIE = 1600,
+
+
+
+    STR_PEEP_THOUGHT_TYPE_ROAST_SAUSAGE = 1604,
+# 1036 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/StringIds.h"
+    STR_PEEP_THOUGHT_TYPE_PHOTO2_MUCH = 1616,
+    STR_PEEP_THOUGHT_TYPE_PHOTO3_MUCH = 1617,
+    STR_PEEP_THOUGHT_TYPE_PHOTO4_MUCH = 1618,
+    STR_PEEP_THOUGHT_TYPE_PRETZEL_MUCH = 1619,
+    STR_PEEP_THOUGHT_TYPE_HOT_CHOCOLATE_MUCH = 1620,
+    STR_PEEP_THOUGHT_TYPE_ICED_TEA_MUCH = 1621,
+    STR_PEEP_THOUGHT_TYPE_FUNNEL_CAKE_MUCH = 1622,
+    STR_PEEP_THOUGHT_TYPE_SUNGLASSES_MUCH = 1623,
+    STR_PEEP_THOUGHT_TYPE_BEEF_NOODLES_MUCH = 1624,
+    STR_PEEP_THOUGHT_TYPE_FRIED_RICE_NOODLES_MUCH = 1625,
+    STR_PEEP_THOUGHT_TYPE_WONTON_SOUP_MUCH = 1626,
+    STR_PEEP_THOUGHT_TYPE_MEATBALL_SOUP_MUCH = 1627,
+    STR_PEEP_THOUGHT_TYPE_FRUIT_JUICE_MUCH = 1628,
+    STR_PEEP_THOUGHT_TYPE_SOYBEAN_MILK_MUCH = 1629,
+    STR_PEEP_THOUGHT_TYPE_SU_JONGKWA_MUCH = 1630,
+    STR_PEEP_THOUGHT_TYPE_SUB_SANDWICH_MUCH = 1631,
+    STR_PEEP_THOUGHT_TYPE_COOKIE_MUCH = 1632,
+
+
+
+    STR_PEEP_THOUGHT_TYPE_ROAST_SAUSAGE_MUCH = 1636,
+# 1068 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/StringIds.h"
+    STR_PEEP_THOUGHT_TYPE_HELP = 1648,
+    STR_PEEP_THOUGHT_TYPE_RUNNING_OUT = 1649,
+    STR_PEEP_THOUGHT_TYPE_NEW_RIDE = 1650,
+    STR_PEEP_THOUGHT_TYPE_NICE_RIDE_DEPRECATED = 1651,
+    STR_PEEP_THOUGHT_TYPE_EXCITED_DEPRECATED = 1652,
+    STR_PEEP_THOUGHT_TYPE_HERE_WE_ARE = 1653,
+    STR_GUEST_RECENT_THOUGHTS_LABEL = 1654,
+    STR_CONSTRUCT_FOOTPATH_ON_LAND_TIP = 1655,
+    STR_CONSTRUCT_BRIDGE_OR_TUNNEL_FOOTPATH_TIP = 1656,
+    STR_GUEST_STAT_PREFERRED_RIDE = 1657,
+    STR_GUEST_STAT_PREFERRED_INTESITY_BELOW = 1658,
+    STR_GUEST_STAT_PREFERRED_INTESITY_BETWEEN = 1659,
+    STR_GUEST_STAT_PREFERRED_INTESITY_ABOVE = 1660,
+    STR_GUEST_STAT_NAUSEA_TOLERANCE = 1661,
+    STR_GUEST_STAT_HAPPINESS_LABEL = 1662,
+    STR_GUEST_STAT_NAUSEA_LABEL = 1663,
+    STR_GUEST_STAT_ENERGY_LABEL = 1664,
+    STR_GUEST_STAT_HUNGER_LABEL = 1665,
+    STR_GUEST_STAT_THIRST_LABEL = 1666,
+    STR_GUEST_STAT_TOILET_LABEL = 1667,
+    STR_SATISFACTION_UNKNOWN = 1668,
+    STR_SATISFACTION_PERCENT = 1669,
+    STR_TOTAL_CUSTOMERS = 1670,
+    STR_TOTAL_PROFIT = 1671,
+    STR_BRAKES = 1672,
+    STR_SPINNING_CONTROL_TOGGLE_TRACK = 1673,
+    STR_RIDE_CONSTRUCTION_BRAKE_SPEED = 1674,
+    STR_RIDE_CONSTRUCTION_BRAKE_SPEED_VELOCITY = 1675,
+    STR_RIDE_CONSTRUCTION_BRAKE_SPEED_LIMIT_TIP = 1676,
+    STR_POPULARITY_UNKNOWN = 1677,
+    STR_POPULARITY_PERCENT = 1678,
+    STR_HELIX_UP_LEFT = 1679,
+    STR_HELIX_UP_RIGHT = 1680,
+    STR_HELIX_DOWN_LEFT = 1681,
+    STR_HELIX_DOWN_RIGHT = 1682,
+    STR_BASE_SIZE_2_X_2 = 1683,
+    STR_BASE_SIZE_4_X_4 = 1684,
+    STR_BASE_SIZE_2_X_4 = 1685,
+    STR_BASE_SIZE_5_X_1 = 1686,
+    STR_WATER_SPLASH = 1687,
+    STR_BASE_SIZE_4_X_1 = 1688,
+    STR_BLOCK_BRAKES = 1689,
+    STR_NEW_RIDE_NAME_AND_DESCRIPTION = 1690,
+    STR_NEW_RIDE_COST = 1691,
+    STR_NEW_RIDE_COST_FROM = 1692,
+    STR_GUESTS_TIP = 1693,
+    STR_STAFF_TIP = 1694,
+    STR_INCOME_AND_COSTS_TIP = 1695,
+    STR_CUSTOMER_INFORMATION_TIP = 1696,
+    STR_CANNOT_PLACE_THESE_ON_QUEUE_LINE_AREA = 1697,
+    STR_CAN_ONLY_PLACE_THESE_ON_QUEUE_AREA = 1698,
+    STR_TOO_MANY_PEOPLE_IN_GAME = 1699,
+    STR_HIRE_HANDYMAN = 1700,
+    STR_HIRE_MECHANIC = 1701,
+    STR_HIRE_SECURITY_GUARD = 1702,
+    STR_HIRE_ENTERTAINER = 1703,
+    STR_CANT_HIRE_NEW_STAFF = 1704,
+    STR_FIRE_STAFF_TIP = 1705,
+    STR_PICKUP_TIP = 1706,
+    STR_TOO_MANY_STAFF_IN_GAME = 1707,
+    STR_SET_PATROL_TIP = 1708,
+    STR_SACK_STAFF = 1709,
+    STR_YES = 1710,
+    STR_FIRE_STAFF_ID = 1711,
+    STR_STAFF_OPTION_SWEEP_FOOTPATHS = 1712,
+    STR_STAFF_OPTION_WATER_GARDENS = 1713,
+    STR_STAFF_OPTION_EMPTY_LITTER = 1714,
+    STR_STAFF_OPTION_MOW_GRASS = 1715,
+    STR_INVALID_NAME_FOR_PARK = 1716,
+    STR_CANT_RENAME_PARK = 1717,
+    STR_PARK_NAME = 1718,
+    STR_ENTER_PARK_NAME = 1719,
+    STR_NAME_PARK_TIP = 1720,
+    STR_PARK_CLOSED = 1721,
+    STR_PARK_OPEN = 1722,
+    STR_CANT_OPEN_PARK = 1723,
+    STR_CANT_CLOSE_PARK = 1724,
+    STR_CANT_BUY_LAND = 1725,
+    STR_LAND_NOT_FOR_SALE = 1726,
+    STR_CONSTRUCTION_RIGHTS_NOT_FOR_SALE = 1727,
+    STR_CANT_BUY_CONSTRUCTION_RIGHTS_HERE = 1728,
+    STR_LAND_NOT_OWNED_BY_PARK = 1729,
+    STR_BANNER_TEXT_CLOSED = 1730,
+    STR_BANNER_TEXT_FORMAT = 1731,
+    STR_RIDE_CONSTRUCTION_BUILD = 1732,
+    STR_RIDE_CONSTRUCTION_MODE = 1733,
+    STR_NUMBER_OF_LAPS = 1734,
+    STR_NUMBER_OF_LAPS_TIP = 1735,
+    STR_NUMBER_OF_LAPS_VALUE = 1736,
+
+    STR_CANT_CHANGE_NUMBER_OF_LAPS = 1738,
+    STR_RACE_WON_BY_GUEST = 1739,
+    STR_RACE_WON_BY = 1740,
+    STR_NOT_YET_CONSTRUCTED = 1741,
+    STR_MAX_PEOPLE_ON_RIDE = 1742,
+    STR_MAX_PEOPLE_ON_RIDE_TIP = 1743,
+    STR_MAX_PEOPLE_ON_RIDE_VALUE = 1744,
+
+    STR_CANT_CHANGE_THIS = 1746,
+    STR_TIME_LIMIT = 1747,
+    STR_TIME_LIMIT_TIP = 1748,
+    STR_RIDE_MODE_TIME_LIMIT_VALUE = 1749,
+
+    STR_CANT_CHANGE_TIME_LIMIT = 1751,
+    STR_INDIVIDUAL_GUESTS_TIP = 1752,
+    STR_SUMMARISED_GUESTS_TIP = 1753,
+    STR_FORMAT_NUM_GUESTS_PLURAL = 1754,
+    STR_FORMAT_NUM_GUESTS_SINGULAR = 1755,
+    STR_ADMISSION_PRICE = 1756,
+    STR_RELIABILITY_LABEL_1757 = 1757,
+    STR_RIDE_CONSTRUCTION_BUILD_MODE = 1758,
+    STR_RIDE_CONSTRUCTION_MOVE_MODE = 1759,
+    STR_RIDE_CONSTRUCTION_FILL_IN_MODE = 1760,
+    STR_RIDE_CONSTRUCTION_BUILD_MAZE_IN_THIS_DIRECTION_TIP = 1761,
+    STR_WATERFALLS = 1762,
+    STR_RAPIDS = 1763,
+    STR_LOG_BUMPS = 1764,
+    STR_ON_RIDE_PHOTO_SECTION = 1765,
+    STR_REVERSER_TURNTABLE = 1766,
+    STR_SPINNING_TUNNEL = 1767,
+    STR_CANT_CHANGE_NUMBER_OF_SWINGS = 1768,
+    STR_NUMBER_OF_SWINGS = 1769,
+    STR_NUMBER_OF_SWINGS_TIP = 1770,
+    STR_RIDE_MODE_NUMBER_OF_SWINGS_VALUE = 1771,
+
+    STR_ONLY_ONE_ON_RIDE_PHOTO_PER_RIDE = 1773,
+    STR_ONLY_ONE_CABLE_LIFT_HILL_PER_RIDE = 1774,
+
+
+    STR_RIDE_MUSIC = 1777,
+    STR_SCROLLING_SIGN_TEXT = 1778,
+    STR_STAFF_OPTION_COSTUME_PANDA = 1779,
+    STR_STAFF_OPTION_COSTUME_TIGER = 1780,
+    STR_STAFF_OPTION_COSTUME_ELEPHANT = 1781,
+    STR_STAFF_OPTION_COSTUME_ROMAN = 1782,
+    STR_STAFF_OPTION_COSTUME_GORILLA = 1783,
+    STR_STAFF_OPTION_COSTUME_SNOWMAN = 1784,
+    STR_STAFF_OPTION_COSTUME_KNIGHT = 1785,
+    STR_STAFF_OPTION_COSTUME_ASTRONAUT = 1786,
+    STR_STAFF_OPTION_COSTUME_BANDIT = 1787,
+    STR_STAFF_OPTION_COSTUME_SHERIFF = 1788,
+    STR_STAFF_OPTION_COSTUME_PIRATE = 1789,
+    STR_UNIFORM_COLOUR_TIP = 1790,
+    STR_UNIFORM_COLOUR = 1791,
+    STR_RESPONDING_TO_RIDE_BREAKDOWN_CALL = 1792,
+    STR_HEADING_TO_RIDE_FOR_INSPECTION = 1793,
+    STR_FIXING_RIDE = 1794,
+    STR_ANSWERING_RADIO_CALL = 1795,
+    STR_HAS_BROKEN_DOWN_AND_REQUIRES_FIXING = 1796,
+
+    STR_WHIRLPOOL = 1798,
+    STR_RIDE_SECONDARY_PRICE_VALUE = 1799,
+    STR_RIDE_BREAKDOWN_SAFETY_CUT_OUT = 1800,
+    STR_RIDE_BREAKDOWN_RESTRAINTS_STUCK_CLOSED = 1801,
+    STR_RIDE_BREAKDOWN_RESTRAINTS_STUCK_OPEN = 1802,
+    STR_RIDE_BREAKDOWN_DOORS_STUCK_CLOSED = 1803,
+    STR_RIDE_BREAKDOWN_DOORS_STUCK_OPEN = 1804,
+    STR_RIDE_BREAKDOWN_VEHICLE_MALFUNCTION = 1805,
+    STR_RIDE_BREAKDOWN_BRAKES_FAILURE = 1806,
+    STR_RIDE_BREAKDOWN_CONTROL_FAILURE = 1807,
+    STR_LAST_BREAKDOWN = 1808,
+    STR_CURRENT_BREAKDOWN = 1809,
+    STR_CARRYING = 1810,
+    STR_CANT_BUILD_PARK_ENTRANCE_HERE = 1811,
+    STR_STRING_DEFINED_TOOLTIP = 1812,
+    STR_MISCELLANEOUS = 1813,
+    STR_ACTIONS = 1814,
+    STR_THOUGHTS = 1815,
+    STR_INFORMATION_TYPE_TIP = 1816,
+    STR_GUESTS_COUNT_COMMA_SEP = 1817,
+    STR_ALL_GUESTS = 1818,
+    STR_ALL_GUESTS_SUMMARISED = 1819,
+    STR_GUESTS_FILTER = 1820,
+    STR_GUESTS_FILTER_THINKING = 1821,
+    STR_GUESTS_FILTER_THINKING_ABOUT = 1822,
+    STR_SHOW_GUESTS_THOUGHTS_ABOUT_THIS_RIDE_ATTRACTION_TIP = 1823,
+    STR_SHOW_GUESTS_ON_THIS_RIDE_ATTRACTION_TIP = 1824,
+    STR_SHOW_GUESTS_QUEUING_FOR_THIS_RIDE_ATTRACTION_TIP = 1825,
+    STR_STATUS = 1826,
+    STR_POPULARITY = 1827,
+    STR_SATISFACTION = 1828,
+    STR_PROFIT = 1829,
+    STR_QUEUE_LENGTH = 1830,
+    STR_QUEUE_TIME = 1831,
+    STR_RELIABILITY = 1832,
+    STR_DOWN_TIME = 1833,
+    STR_GUESTS_FAVOURITE = 1834,
+    STR_POPULARITY_UNKNOWN_LABEL = 1835,
+    STR_POPULARITY_LABEL = 1836,
+    STR_SATISFACTION_UNKNOWN_LABEL = 1837,
+    STR_SATISFACTION_LABEL = 1838,
+    STR_RELIABILITY_LABEL = 1839,
+    STR_DOWN_TIME_LABEL = 1840,
+    STR_PROFIT_LABEL = 1841,
+    STR_GUESTS_FAVOURITE_LABEL = 1842,
+    STR_GUESTS_FAVOURITE_PLURAL_LABEL = 1843,
+    STR_RIDE_LIST_INFORMATION_TYPE_TIP = 1844,
+
+    STR_BOTTOM_TOOLBAR_NUM_GUESTS_STABLE = 1846,
+    STR_BOTTOM_TOOLBAR_NUM_GUESTS_DECREASE = 1847,
+    STR_BOTTOM_TOOLBAR_NUM_GUESTS_INCREASE = 1848,
+    STR_PLAY_MUSIC = 1849,
+    STR_SELECT_MUSIC_TIP = 1850,
+    STR_RUNNING_COST_PER_HOUR = 1851,
+    STR_RUNNING_COST_UNKNOWN = 1852,
+    STR_BUILT_THIS_YEAR = 1853,
+    STR_BUILT_LAST_YEAR = 1854,
+    STR_BUILT_YEARS_AGO = 1855,
+    STR_PROFIT_PER_ITEM_SOLD = 1856,
+    STR_LOSS_PER_ITEM_SOLD = 1857,
+    STR_COST_PER_MONTH = 1858,
+    STR_HANDYMAN_PLURAL = 1859,
+    STR_MECHANIC_PLURAL = 1860,
+    STR_SECURITY_GUARD_PLURAL = 1861,
+    STR_ENTERTAINER_PLURAL = 1862,
+    STR_HANDYMAN_SINGULAR = 1863,
+    STR_MECHANIC_SINGULAR = 1864,
+    STR_SECURITY_GUARD_SINGULAR = 1865,
+    STR_ENTERTAINER_SINGULAR = 1866,
+    STR_STAFF_LIST_COUNTER = 1867,
+    STR_CANT_CHANGE_NUMBER_OF_ROTATIONS = 1868,
+    STR_NUMBER_OF_ROTATIONS = 1869,
+    STR_NUMBER_OF_ROTATIONS_TIP = 1870,
+    STR_NUMBER_OF_ROTATIONS_VALUE = 1871,
+
+    STR_INCOME_PER_HOUR = 1873,
+    STR_PROFIT_PER_HOUR = 1874,
+    STR_GUEST_ITEM_FORMAT = 1875,
+    STR_INSPECT_RIDES = 1876,
+    STR_FIX_RIDES = 1877,
+    STR_INSPECTION = 1878,
+    STR_EVERY_10_MINUTES = 1879,
+    STR_EVERY_20_MINUTES = 1880,
+    STR_EVERY_30_MINUTES = 1881,
+    STR_EVERY_45_MINUTES = 1882,
+    STR_EVERY_HOUR = 1883,
+    STR_EVERY_2_HOURS = 1884,
+    STR_NEVER = 1885,
+    STR_INSPECTING_RIDE = 1886,
+    STR_TIME_SINCE_LAST_INSPECTION_MINUTES = 1887,
+    STR_TIME_SINCE_LAST_INSPECTION_MORE_THAN_4_HOURS = 1888,
+    STR_DOWN_TIME_LABEL_1889 = 1889,
+    STR_SELECT_HOW_OFTEN_A_MECHANIC_SHOULD_CHECK_THIS_RIDE = 1890,
+    STR_NO_THING_IN_PARK_YET = 1891,
+
+
+    STR_ITEMS_SOLD = 1894,
+    STR_BUILD_RIDE_TIP = 1895,
+    STR_FINANCES_SUMMARY_EXPENDITURE_INCOME = 1896,
+    STR_FINANCES_SUMMARY_RIDE_CONSTRUCTION = 1897,
+    STR_FINANCES_SUMMARY_RIDE_RUNNING_COSTS = 1898,
+    STR_FINANCES_SUMMARY_LAND_PURCHASE = 1899,
+    STR_FINANCES_SUMMARY_LANDSCAPING = 1900,
+    STR_FINANCES_SUMMARY_PARK_ENTRANCE_TICKETS = 1901,
+    STR_FINANCES_SUMMARY_RIDE_TICKETS = 1902,
+    STR_FINANCES_SUMMARY_SHOP_SALES = 1903,
+    STR_FINANCES_SUMMARY_SHOP_STOCK = 1904,
+    STR_FINANCES_SUMMARY_FOOD_DRINK_SALES = 1905,
+    STR_FINANCES_SUMMARY_FOOD_DRINK_STOCK = 1906,
+    STR_FINANCES_SUMMARY_STAFF_WAGES = 1907,
+    STR_FINANCES_SUMMARY_MARKETING = 1908,
+    STR_FINANCES_SUMMARY_RESEARCH = 1909,
+    STR_FINANCES_SUMMARY_LOAN_INTEREST = 1910,
+    STR_FINANCES_SUMMARY_AT_X_PER_YEAR = 1911,
+    STR_FINANCES_SUMMARY_MONTH_HEADING = 1912,
+    STR_FINANCES_SUMMARY_INCOME_VALUE = 1913,
+    STR_FINANCES_SUMMARY_EXPENDITURE_VALUE = 1914,
+    STR_FINANCES_SUMMARY_LOSS_VALUE = 1915,
+    STR_FINANCES_SUMMARY_LOAN = 1916,
+    STR_FINANCES_SUMMARY_LOAN_VALUE = 1917,
+    STR_CANT_BORROW_ANY_MORE_MONEY = 1918,
+    STR_NOT_ENOUGH_CASH_AVAILABLE = 1919,
+    STR_CANT_PAY_BACK_LOAN = 1920,
+    STR_START_NEW_GAME_TIP = 1921,
+    STR_CONTINUE_SAVED_GAME_TIP = 1922,
+    STR_EXIT = 1924,
+    STR_ERR_CANT_PLACE_PERSON_HERE = 1925,
+
+    STR_RIDE_IS_BROKEN_DOWN = 1927,
+    STR_RIDE_HAS_CRASHED = 1928,
+    STR_RIDE_IS_STILL_NOT_FIXED = 1929,
+    STR_TOGGLE_GUEST_TRACKING_TIP = 1930,
+    STR_PEEP_TRACKING_PEEP_JOINED_QUEUE_FOR_X = 1931,
+    STR_PEEP_TRACKING_PEEP_IS_ON_X = 1932,
+    STR_PEEP_TRACKING_PEEP_IS_IN_X = 1933,
+    STR_PEEP_TRACKING_LEFT_RIDE_X = 1934,
+    STR_PEEP_TRACKING_LEFT_PARK = 1935,
+    STR_PEEP_TRACKING_NOTIFICATION_BOUGHT_X = 1936,
+    STR_SHOW_SUBJECT_TIP = 1937,
+    STR_SHOW_GUEST_VIEW_TIP = 1938,
+    STR_STAFF_OVERVIEW_TIP = 1939,
+    STR_SHOW_GUEST_NEEDS_TIP = 1940,
+    STR_SHOW_GUEST_VISITED_RIDES_TIP = 1941,
+    STR_SHOW_GUEST_FINANCE_TIP = 1942,
+    STR_SHOW_GUEST_THOUGHTS_TIP = 1943,
+    STR_SHOW_GUEST_ITEMS_TIP = 1944,
+    STR_STAFF_OPTIONS_TIP = 1945,
+    STR_SELECT_COSTUME_TIP = 1946,
+    STR_SHOW_PATROL_AREA_TIP = 1947,
+    STR_HIRE_STAFF_TIP = 1948,
+    STR_FINANCIAL_SUMMARY = 1949,
+    STR_FINANCIAL_GRAPH = 1950,
+    STR_PARK_VALUE_GRAPH = 1951,
+    STR_PROFIT_GRAPH = 1952,
+    STR_MARKETING = 1953,
+    STR_RESEARCH_FUNDING = 1954,
+    STR_NUMBER_OF_CIRCUITS = 1955,
+    STR_NUMBER_OF_CIRCUITS_TIP = 1956,
+    STR_NUMBER_OF_CIRCUITS_VALUE = 1957,
+
+
+    STR_SHOP_ITEM_PRICE_LABEL_BALLOON = 1960,
+    STR_SHOP_ITEM_PRICE_LABEL_CUDDLY_TOY = 1961,
+    STR_SHOP_ITEM_PRICE_LABEL_PARK_MAP = 1962,
+    STR_SHOP_ITEM_PRICE_LABEL_ON_RIDE_PHOTO = 1963,
+    STR_SHOP_ITEM_PRICE_LABEL_UMBRELLA = 1964,
+    STR_SHOP_ITEM_PRICE_LABEL_DRINK = 1965,
+    STR_SHOP_ITEM_PRICE_LABEL_BURGER = 1966,
+    STR_SHOP_ITEM_PRICE_LABEL_CHIPS = 1967,
+    STR_SHOP_ITEM_PRICE_LABEL_ICE_CREAM = 1968,
+    STR_SHOP_ITEM_PRICE_LABEL_CANDYFLOSS = 1969,
+    STR_SHOP_ITEM_PRICE_LABEL_EMPTY_CAN = 1970,
+    STR_SHOP_ITEM_PRICE_LABEL_RUBBISH = 1971,
+    STR_SHOP_ITEM_PRICE_LABEL_EMPTY_BURGER_BOX = 1972,
+    STR_SHOP_ITEM_PRICE_LABEL_PIZZA = 1973,
+    STR_SHOP_ITEM_PRICE_LABEL_VOUCHER = 1974,
+    STR_SHOP_ITEM_PRICE_LABEL_POPCORN = 1975,
+    STR_SHOP_ITEM_PRICE_LABEL_HOT_DOG = 1976,
+    STR_SHOP_ITEM_PRICE_LABEL_TENTACLE = 1977,
+    STR_SHOP_ITEM_PRICE_LABEL_HAT = 1978,
+    STR_SHOP_ITEM_PRICE_LABEL_TOFFEE_APPLE = 1979,
+    STR_SHOP_ITEM_PRICE_LABEL_T_SHIRT = 1980,
+    STR_SHOP_ITEM_PRICE_LABEL_DOUGHNUT = 1981,
+    STR_SHOP_ITEM_PRICE_LABEL_COFFEE = 1982,
+    STR_SHOP_ITEM_PRICE_LABEL_EMPTY_CUP = 1983,
+    STR_SHOP_ITEM_PRICE_LABEL_FRIED_CHICKEN = 1984,
+    STR_SHOP_ITEM_PRICE_LABEL_LEMONADE = 1985,
+    STR_SHOP_ITEM_PRICE_LABEL_EMPTY_BOX = 1986,
+    STR_SHOP_ITEM_PRICE_LABEL_EMPTY_BOTTLE = 1987,
+    STR_SHOP_ITEM_SINGULAR_BALLOON = 1988,
+    STR_SHOP_ITEM_SINGULAR_CUDDLY_TOY = 1989,
+    STR_SHOP_ITEM_SINGULAR_PARK_MAP = 1990,
+    STR_SHOP_ITEM_SINGULAR_ON_RIDE_PHOTO = 1991,
+    STR_SHOP_ITEM_SINGULAR_UMBRELLA = 1992,
+    STR_SHOP_ITEM_SINGULAR_DRINK = 1993,
+    STR_SHOP_ITEM_SINGULAR_BURGER = 1994,
+    STR_SHOP_ITEM_SINGULAR_CHIPS = 1995,
+    STR_SHOP_ITEM_SINGULAR_ICE_CREAM = 1996,
+    STR_SHOP_ITEM_SINGULAR_CANDYFLOSS = 1997,
+    STR_SHOP_ITEM_SINGULAR_EMPTY_CAN = 1998,
+    STR_SHOP_ITEM_SINGULAR_RUBBISH = 1999,
+    STR_SHOP_ITEM_SINGULAR_EMPTY_BURGER_BOX = 2000,
+    STR_SHOP_ITEM_SINGULAR_PIZZA = 2001,
+    STR_SHOP_ITEM_SINGULAR_VOUCHER = 2002,
+    STR_SHOP_ITEM_SINGULAR_POPCORN = 2003,
+    STR_SHOP_ITEM_SINGULAR_HOT_DOG = 2004,
+    STR_SHOP_ITEM_SINGULAR_TENTACLE = 2005,
+    STR_SHOP_ITEM_SINGULAR_HAT = 2006,
+    STR_SHOP_ITEM_SINGULAR_TOFFEE_APPLE = 2007,
+    STR_SHOP_ITEM_SINGULAR_T_SHIRT = 2008,
+    STR_SHOP_ITEM_SINGULAR_DOUGHNUT = 2009,
+    STR_SHOP_ITEM_SINGULAR_COFFEE = 2010,
+    STR_SHOP_ITEM_SINGULAR_EMPTY_CUP = 2011,
+    STR_SHOP_ITEM_SINGULAR_FRIED_CHICKEN = 2012,
+    STR_SHOP_ITEM_SINGULAR_LEMONADE = 2013,
+    STR_SHOP_ITEM_SINGULAR_EMPTY_BOX = 2014,
+    STR_SHOP_ITEM_SINGULAR_EMPTY_BOTTLE = 2015,
+    STR_SHOP_ITEM_PLURAL_BALLOON = 2016,
+    STR_SHOP_ITEM_PLURAL_CUDDLY_TOY = 2017,
+    STR_SHOP_ITEM_PLURAL_PARK_MAP = 2018,
+    STR_SHOP_ITEM_PLURAL_ON_RIDE_PHOTO = 2019,
+    STR_SHOP_ITEM_PLURAL_UMBRELLA = 2020,
+    STR_SHOP_ITEM_PLURAL_DRINK = 2021,
+    STR_SHOP_ITEM_PLURAL_BURGER = 2022,
+    STR_SHOP_ITEM_PLURAL_CHIPS = 2023,
+    STR_SHOP_ITEM_PLURAL_ICE_CREAM = 2024,
+    STR_SHOP_ITEM_PLURAL_CANDYFLOSS = 2025,
+    STR_SHOP_ITEM_PLURAL_EMPTY_CAN = 2026,
+    STR_SHOP_ITEM_PLURAL_RUBBISH = 2027,
+    STR_SHOP_ITEM_PLURAL_EMPTY_BURGER_BOX = 2028,
+    STR_SHOP_ITEM_PLURAL_PIZZA = 2029,
+    STR_SHOP_ITEM_PLURAL_VOUCHER = 2030,
+    STR_SHOP_ITEM_PLURAL_POPCORN = 2031,
+    STR_SHOP_ITEM_PLURAL_HOT_DOG = 2032,
+    STR_SHOP_ITEM_PLURAL_TENTACLE = 2033,
+    STR_SHOP_ITEM_PLURAL_HAT = 2034,
+    STR_SHOP_ITEM_PLURAL_TOFFEE_APPLE = 2035,
+    STR_SHOP_ITEM_PLURAL_T_SHIRT = 2036,
+    STR_SHOP_ITEM_PLURAL_DOUGHNUT = 2037,
+    STR_SHOP_ITEM_PLURAL_COFFEE = 2038,
+    STR_SHOP_ITEM_PLURAL_EMPTY_CUP = 2039,
+    STR_SHOP_ITEM_PLURAL_FRIED_CHICKEN = 2040,
+    STR_SHOP_ITEM_PLURAL_LEMONADE = 2041,
+    STR_SHOP_ITEM_PLURAL_EMPTY_BOX = 2042,
+    STR_SHOP_ITEM_PLURAL_EMPTY_BOTTLE = 2043,
+    STR_SHOP_ITEM_INDEFINITE_BALLOON = 2044,
+    STR_SHOP_ITEM_INDEFINITE_CUDDLY_TOY = 2045,
+    STR_SHOP_ITEM_INDEFINITE_PARK_MAP = 2046,
+    STR_SHOP_ITEM_INDEFINITE_ON_RIDE_PHOTO = 2047,
+    STR_SHOP_ITEM_INDEFINITE_UMBRELLA = 2048,
+    STR_SHOP_ITEM_INDEFINITE_DRINK = 2049,
+    STR_SHOP_ITEM_INDEFINITE_BURGER = 2050,
+    STR_SHOP_ITEM_INDEFINITE_CHIPS = 2051,
+    STR_SHOP_ITEM_INDEFINITE_ICE_CREAM = 2052,
+    STR_SHOP_ITEM_INDEFINITE_CANDYFLOSS = 2053,
+    STR_SHOP_ITEM_INDEFINITE_EMPTY_CAN = 2054,
+    STR_SHOP_ITEM_INDEFINITE_RUBBISH = 2055,
+    STR_SHOP_ITEM_INDEFINITE_EMPTY_BURGER_BOX = 2056,
+    STR_SHOP_ITEM_INDEFINITE_PIZZA = 2057,
+    STR_SHOP_ITEM_INDEFINITE_VOUCHER = 2058,
+    STR_SHOP_ITEM_INDEFINITE_POPCORN = 2059,
+    STR_SHOP_ITEM_INDEFINITE_HOT_DOG = 2060,
+    STR_SHOP_ITEM_INDEFINITE_TENTACLE = 2061,
+    STR_SHOP_ITEM_INDEFINITE_HAT = 2062,
+    STR_SHOP_ITEM_INDEFINITE_TOFFEE_APPLE = 2063,
+    STR_SHOP_ITEM_INDEFINITE_T_SHIRT = 2064,
+    STR_SHOP_ITEM_INDEFINITE_DOUGHNUT = 2065,
+    STR_SHOP_ITEM_INDEFINITE_COFFEE = 2066,
+    STR_SHOP_ITEM_INDEFINITE_EMPTY_CUP = 2067,
+    STR_SHOP_ITEM_INDEFINITE_FRIED_CHICKEN = 2068,
+    STR_SHOP_ITEM_INDEFINITE_LEMONADE = 2069,
+    STR_SHOP_ITEM_INDEFINITE_EMPTY_BOX = 2070,
+    STR_SHOP_ITEM_INDEFINITE_EMPTY_BOTTLE = 2071,
+    STR_SHOP_ITEM_DISPLAY_BALLOON = 2072,
+    STR_SHOP_ITEM_DISPLAY_CUDDLY_TOY = 2073,
+    STR_SHOP_ITEM_DISPLAY_PARK_MAP = 2074,
+    STR_SHOP_ITEM_DISPLAY_ON_RIDE_PHOTO = 2075,
+    STR_SHOP_ITEM_DISPLAY_UMBRELLA = 2076,
+    STR_SHOP_ITEM_DISPLAY_DRINK = 2077,
+    STR_SHOP_ITEM_DISPLAY_BURGER = 2078,
+    STR_SHOP_ITEM_DISPLAY_CHIPS = 2079,
+    STR_SHOP_ITEM_DISPLAY_ICE_CREAM = 2080,
+    STR_SHOP_ITEM_DISPLAY_CANDYFLOSS = 2081,
+    STR_SHOP_ITEM_DISPLAY_EMPTY_CAN = 2082,
+    STR_SHOP_ITEM_DISPLAY_RUBBISH = 2083,
+    STR_SHOP_ITEM_DISPLAY_EMPTY_BURGER_BOX = 2084,
+    STR_SHOP_ITEM_DISPLAY_PIZZA = 2085,
+    STR_SHOP_ITEM_DISPLAY_VOUCHER = 2086,
+    STR_SHOP_ITEM_DISPLAY_POPCORN = 2087,
+    STR_SHOP_ITEM_DISPLAY_HOT_DOG = 2088,
+    STR_SHOP_ITEM_DISPLAY_TENTACLE = 2089,
+    STR_SHOP_ITEM_DISPLAY_HAT = 2090,
+    STR_SHOP_ITEM_DISPLAY_TOFFEE_APPLE = 2091,
+    STR_SHOP_ITEM_DISPLAY_T_SHIRT = 2092,
+    STR_SHOP_ITEM_DISPLAY_DOUGHNUT = 2093,
+    STR_SHOP_ITEM_DISPLAY_COFFEE = 2094,
+    STR_SHOP_ITEM_DISPLAY_EMPTY_CUP = 2095,
+    STR_SHOP_ITEM_DISPLAY_FRIED_CHICKEN = 2096,
+    STR_SHOP_ITEM_DISPLAY_LEMONADE = 2097,
+    STR_SHOP_ITEM_DISPLAY_EMPTY_BOX = 2098,
+    STR_SHOP_ITEM_DISPLAY_EMPTY_BOTTLE = 2099,
+
+    STR_SHOP_ITEM_PRICE_LABEL_PRETZEL = 2103,
+    STR_SHOP_ITEM_PRICE_LABEL_HOT_CHOCOLATE = 2104,
+    STR_SHOP_ITEM_PRICE_LABEL_ICED_TEA = 2105,
+    STR_SHOP_ITEM_PRICE_LABEL_FUNNEL_CAKE = 2106,
+    STR_SHOP_ITEM_PRICE_LABEL_SUNGLASSES = 2107,
+    STR_SHOP_ITEM_PRICE_LABEL_BEEF_NOODLES = 2108,
+    STR_SHOP_ITEM_PRICE_LABEL_FRIED_RICE_NOODLES = 2109,
+    STR_SHOP_ITEM_PRICE_LABEL_WONTON_SOUP = 2110,
+    STR_SHOP_ITEM_PRICE_LABEL_MEATBALL_SOUP = 2111,
+    STR_SHOP_ITEM_PRICE_LABEL_FRUIT_JUICE = 2112,
+    STR_SHOP_ITEM_PRICE_LABEL_SOYBEAN_MILK = 2113,
+    STR_SHOP_ITEM_PRICE_LABEL_SUJONGKWA = 2114,
+    STR_SHOP_ITEM_PRICE_LABEL_SUB_SANDWICH = 2115,
+    STR_SHOP_ITEM_PRICE_LABEL_COOKIE = 2116,
+    STR_SHOP_ITEM_PRICE_LABEL_EMPTY_BOWL_RED = 2117,
+    STR_SHOP_ITEM_PRICE_LABEL_EMPTY_DRINK_CARTON = 2118,
+    STR_SHOP_ITEM_PRICE_LABEL_EMPTY_JUICE_CUP = 2119,
+    STR_SHOP_ITEM_PRICE_LABEL_ROAST_SAUSAGE = 2120,
+    STR_SHOP_ITEM_PRICE_LABEL_EMPTY_BOWL_BLUE = 2121,
+
+    STR_SHOP_ITEM_SINGULAR_PRETZEL = 2125,
+    STR_SHOP_ITEM_SINGULAR_HOT_CHOCOLATE = 2126,
+    STR_SHOP_ITEM_SINGULAR_ICED_TEA = 2127,
+    STR_SHOP_ITEM_SINGULAR_FUNNEL_CAKE = 2128,
+    STR_SHOP_ITEM_SINGULAR_SUNGLASSES = 2129,
+    STR_SHOP_ITEM_SINGULAR_BEEF_NOODLES = 2130,
+    STR_SHOP_ITEM_SINGULAR_FRIED_RICE_NOODLES = 2131,
+    STR_SHOP_ITEM_SINGULAR_WONTON_SOUP = 2132,
+    STR_SHOP_ITEM_SINGULAR_MEATBALL_SOUP = 2133,
+    STR_SHOP_ITEM_SINGULAR_FRUIT_JUICE = 2134,
+    STR_SHOP_ITEM_SINGULAR_SOYBEAN_MILK = 2135,
+    STR_SHOP_ITEM_SINGULAR_SUJONGKWA = 2136,
+    STR_SHOP_ITEM_SINGULAR_SUB_SANDWICH = 2137,
+    STR_SHOP_ITEM_SINGULAR_COOKIE = 2138,
+    STR_SHOP_ITEM_SINGULAR_EMPTY_BOWL_RED = 2139,
+    STR_SHOP_ITEM_SINGULAR_EMPTY_DRINK_CARTON = 2140,
+    STR_SHOP_ITEM_SINGULAR_EMPTY_JUICE_CUP = 2141,
+    STR_SHOP_ITEM_SINGULAR_ROAST_SAUSAGE = 2142,
+    STR_SHOP_ITEM_SINGULAR_EMPTY_BOWL_BLUE = 2143,
+
+    STR_SHOP_ITEM_PLURAL_PRETZEL = 2147,
+    STR_SHOP_ITEM_PLURAL_HOT_CHOCOLATE = 2148,
+    STR_SHOP_ITEM_PLURAL_ICED_TEA = 2149,
+    STR_SHOP_ITEM_PLURAL_FUNNEL_CAKE = 2150,
+    STR_SHOP_ITEM_PLURAL_SUNGLASSES = 2151,
+    STR_SHOP_ITEM_PLURAL_BEEF_NOODLES = 2152,
+    STR_SHOP_ITEM_PLURAL_FRIED_RICE_NOODLES = 2153,
+    STR_SHOP_ITEM_PLURAL_WONTON_SOUP = 2154,
+    STR_SHOP_ITEM_PLURAL_MEATBALL_SOUP = 2155,
+    STR_SHOP_ITEM_PLURAL_FRUIT_JUICE = 2156,
+    STR_SHOP_ITEM_PLURAL_SOYBEAN_MILK = 2157,
+    STR_SHOP_ITEM_PLURAL_SUJONGKWA = 2158,
+    STR_SHOP_ITEM_PLURAL_SUB_SANDWICH = 2159,
+    STR_SHOP_ITEM_PLURAL_COOKIE = 2160,
+    STR_SHOP_ITEM_PLURAL_EMPTY_BOWL_RED = 2161,
+    STR_SHOP_ITEM_PLURAL_EMPTY_DRINK_CARTON = 2162,
+    STR_SHOP_ITEM_PLURAL_EMPTY_JUICE_CUP = 2163,
+    STR_SHOP_ITEM_PLURAL_ROAST_SAUSAGE = 2164,
+    STR_SHOP_ITEM_PLURAL_EMPTY_BOWL_BLUE = 2165,
+
+    STR_SHOP_ITEM_INDEFINITE_PRETZEL = 2169,
+    STR_SHOP_ITEM_INDEFINITE_HOT_CHOCOLATE = 2170,
+    STR_SHOP_ITEM_INDEFINITE_ICED_TEA = 2171,
+    STR_SHOP_ITEM_INDEFINITE_FUNNEL_CAKE = 2172,
+    STR_SHOP_ITEM_INDEFINITE_SUNGLASSES = 2173,
+    STR_SHOP_ITEM_INDEFINITE_BEEF_NOODLES = 2174,
+    STR_SHOP_ITEM_INDEFINITE_FRIED_RICE_NOODLES = 2175,
+    STR_SHOP_ITEM_INDEFINITE_WONTON_SOUP = 2176,
+    STR_SHOP_ITEM_INDEFINITE_MEATBALL_SOUP = 2177,
+    STR_SHOP_ITEM_INDEFINITE_FRUIT_JUICE = 2178,
+    STR_SHOP_ITEM_INDEFINITE_SOYBEAN_MILK = 2179,
+    STR_SHOP_ITEM_INDEFINITE_SUJONGKWA = 2180,
+    STR_SHOP_ITEM_INDEFINITE_SUB_SANDWICH = 2181,
+    STR_SHOP_ITEM_INDEFINITE_COOKIE = 2182,
+    STR_SHOP_ITEM_INDEFINITE_EMPTY_BOWL_RED = 2183,
+    STR_SHOP_ITEM_INDEFINITE_EMPTY_DRINK_CARTON = 2184,
+    STR_SHOP_ITEM_INDEFINITE_EMPTY_JUICE_CUP = 2185,
+    STR_SHOP_ITEM_INDEFINITE_ROAST_SAUSAGE = 2186,
+    STR_SHOP_ITEM_INDEFINITE_EMPTY_BOWL_BLUE = 2187,
+
+    STR_SHOP_ITEM_DISPLAY_PRETZEL = 2191,
+    STR_SHOP_ITEM_DISPLAY_HOT_CHOCOLATE = 2192,
+    STR_SHOP_ITEM_DISPLAY_ICED_TEA = 2193,
+    STR_SHOP_ITEM_DISPLAY_FUNNEL_CAKE = 2194,
+    STR_SHOP_ITEM_DISPLAY_SUNGLASSES = 2195,
+    STR_SHOP_ITEM_DISPLAY_BEEF_NOODLES = 2196,
+    STR_SHOP_ITEM_DISPLAY_FRIED_RICE_NOODLES = 2197,
+    STR_SHOP_ITEM_DISPLAY_WONTON_SOUP = 2198,
+    STR_SHOP_ITEM_DISPLAY_MEATBALL_SOUP = 2199,
+    STR_SHOP_ITEM_DISPLAY_FRUIT_JUICE = 2200,
+    STR_SHOP_ITEM_DISPLAY_SOYBEAN_MILK = 2201,
+    STR_SHOP_ITEM_DISPLAY_SUJONGKWA = 2202,
+    STR_SHOP_ITEM_DISPLAY_SUB_SANDWICH = 2203,
+    STR_SHOP_ITEM_DISPLAY_COOKIE = 2204,
+    STR_SHOP_ITEM_DISPLAY_EMPTY_BOWL_RED = 2205,
+    STR_SHOP_ITEM_DISPLAY_EMPTY_DRINK_CARTON = 2206,
+    STR_SHOP_ITEM_DISPLAY_EMPTY_JUICE_CUP = 2207,
+    STR_SHOP_ITEM_DISPLAY_ROAST_SAUSAGE = 2208,
+    STR_SHOP_ITEM_DISPLAY_EMPTY_BOWL_BLUE = 2209,
+    STR_STAFF_HANDYMEN_TAB_TIP = 2210,
+    STR_STAFF_MECHANICS_TAB_TIP = 2211,
+    STR_STAFF_SECURITY_TAB_TIP = 2212,
+    STR_STAFF_ENTERTAINERS_TAB_TIP = 2213,
+    STR_CONSTRUCTION_NOT_POSSIBLE_WHILE_GAME_IS_PAUSED = 2214,
+    STR_RIDE_MAP_TIP = 2215,
+    STR_CELSIUS_VALUE = 2216,
+    STR_FAHRENHEIT_VALUE = 2217,
+    STR_NEWS_VEHICLE_HAS_STALLED = 2218,
+    STR_X_PEOPLE_DIED_ON_X = 2219,
+    STR_PARK_RATING_LABEL = 2220,
+    STR_PARK_RATING_TIP = 2221,
+    STR_GRAPH_LABEL = 2222,
+    STR_GUESTS_IN_PARK_LABEL = 2223,
+    STR_CASH_LABEL = 2224,
+    STR_CASH_NEGATIVE_LABEL = 2225,
+    STR_PARK_VALUE_LABEL = 2226,
+    STR_COMPANY_VALUE_LABEL = 2227,
+    STR_LAST_MONTH_PROFIT_FROM_FOOD_DRINK_MERCHANDISE_SALES_LABEL = 2228,
+    STR_SLOPE_UP_TO_VERTICAL = 2229,
+    STR_VERTICAL_TRACK = 2230,
+    STR_HOLDING_BRAKE_FOR_DROP = 2231,
+    STR_CABLE_LIFT_HILL = 2232,
+    STR_PARK_INFORMATION_TIP = 2233,
+    STR_RECENT_MESSAGES = 2234,
+    STR_NEWS_DATE_FORMAT = 2235,
+    STR_MONTH_JANUARY = 2236,
+    STR_MONTH_FEBRUARY = 2237,
+    STR_MONTH_MARCH = 2238,
+    STR_MONTH_APRIL = 2239,
+    STR_MONTH_MAY = 2240,
+    STR_MONTH_JUNE = 2241,
+    STR_MONTH_JULY = 2242,
+    STR_MONTH_AUGUST = 2243,
+    STR_MONTH_SEPTEMBER = 2244,
+    STR_MONTH_OCTOBER = 2245,
+    STR_MONTH_NOVEMBER = 2246,
+    STR_MONTH_DECEMBER = 2247,
+    STR_CANT_DEMOLISH_RIDE = 2248,
+    STR_NEWS_ITEM_RESEARCH_NEW_RIDE_AVAILABLE = 2249,
+    STR_NEWS_ITEM_RESEARCH_NEW_SCENERY_SET_AVAILABLE = 2250,
+
+    STR_CAN_ONLY_BE_BUILT_ACROSS_PATHS = 2252,
+    STR_RESEARCH_NEW_TRANSPORT_RIDES = 2253,
+    STR_RESEARCH_NEW_GENTLE_RIDES = 2254,
+    STR_RESEARCH_NEW_ROLLER_COASTERS = 2255,
+    STR_RESEARCH_NEW_THRILL_RIDES = 2256,
+    STR_RESEARCH_NEW_WATER_RIDES = 2257,
+    STR_RESEARCH_NEW_SHOPS_AND_STALLS = 2258,
+    STR_RESEARCH_NEW_SCENERY_AND_THEMING = 2259,
+    STR_RESEARCH_FUNDING_NONE = 2260,
+    STR_RESEARCH_FUNDING_MINIMUM = 2261,
+    STR_RESEARCH_FUNDING_NORMAL = 2262,
+    STR_RESEARCH_FUNDING_MAXIMUM = 2263,
+    STR_RESEARCH_FUNDING_ = 2264,
+    STR_RESEARCH_COST_PER_MONTH = 2265,
+    STR_RESEARCH_PRIORITIES = 2266,
+    STR_CURRENTLY_IN_DEVELOPMENT = 2267,
+    STR_LAST_DEVELOPMENT = 2268,
+    STR_RESEARCH_TYPE_LABEL = 2269,
+    STR_RESEARCH_PROGRESS_LABEL = 2270,
+    STR_RESEARCH_EXPECTED_LABEL = 2271,
+    STR_RESEARCH_RIDE_LABEL = 2272,
+    STR_RESEARCH_SCENERY_LABEL = 2273,
+    STR_RESEARCH_SHOW_DETAILS_TIP = 2274,
+    STR_FINANCES_RESEARCH_TIP = 2275,
+    STR_RESEARCH_AND_DEVELOPMENT_TIP = 2276,
+    STR_RESEARCH_UNKNOWN = 2277,
+    STR_RESEARCH_CATEGORY_TRANSPORT = 2278,
+    STR_RESEARCH_CATEGORY_GENTLE = 2279,
+    STR_RESEARCH_CATEGORY_ROLLERCOASTER = 2280,
+    STR_RESEARCH_CATEGORY_THRILL = 2281,
+    STR_RESEARCH_CATEGORY_WATER = 2282,
+    STR_RESEARCH_CATEGORY_SHOP = 2283,
+    STR_RESEARCH_CATEGORY_SCENERY_GROUP = 2284,
+    STR_RESEARCH_STAGE_INITIAL_RESEARCH = 2285,
+    STR_RESEARCH_STAGE_DESIGNING = 2286,
+    STR_RESEARCH_STAGE_COMPLETING_DESIGN = 2287,
+    STR_RESEARCH_STAGE_UNKNOWN = 2288,
+    STR_RESEARCH_EXPECTED_FORMAT = 2289,
+
+    STR_SELECT_SCENARIO = 2291,
+    STR_GUEST_LABEL_RIDES_BEEN_ON = 2292,
+    STR_NOTHING = 2293,
+    STR_CHANGE_BASE_LAND_TIP = 2294,
+    STR_CHANGE_VERTICAL_LAND_TIP = 2295,
+    STR_GUEST_EXPENSES_ENTRANCE_FEE = 2296,
+    STR_GUEST_EXPENSES_RIDE = 2297,
+    STR_GUEST_EXPENSES_RIDE_PLURAL = 2298,
+    STR_GUEST_EXPENSES_FOOD = 2299,
+    STR_GUEST_EXPENSES_FOOD_PLURAL = 2300,
+    STR_GUEST_EXPENSES_DRINK = 2301,
+    STR_GUEST_EXPENSES_DRINK_PLURAL = 2302,
+    STR_GUEST_EXPENSES_SOUVENIR = 2303,
+    STR_GUEST_EXPENSES_SOUVENIR_PLURAL = 2304,
+
+
+    STR_SELECT_DESIGN = 2307,
+    STR_TRACK_DESIGNS = 2308,
+    STR_TRACK_DESIGN_INSTALL_WINDOW_TITLE = 2309,
+    STR_BUILD_CUSTOM_DESIGN = 2310,
+    STR_TRACK_LIST_EXCITEMENT_RATING = 2311,
+    STR_TRACK_LIST_INTENSITY_RATING = 2312,
+    STR_TRACK_LIST_NAUSEA_RATING = 2313,
+    STR_TRACK_LIST_RIDE_LENGTH = 2314,
+    STR_TRACK_LIST_COST_AROUND = 2315,
+    STR_TRACK_LIST_SPACE_REQUIRED = 2316,
+
+
+
+
+    STR_NUMBER_OF_RIDES_LABEL = 2321,
+    STR_STAFF_LABEL = 2322,
+    STR_PARK_SIZE_METRIC_LABEL = 2323,
+    STR_PARK_SIZE_IMPERIAL_LABEL = 2324,
+    STR_BUY_LAND_RIGHTS_TIP = 2325,
+    STR_BUY_CONSTRUCTION_RIGHTS_TIP = 2326,
+    STR_OPTIONS = 2327,
+    STR_CURRENCY = 2328,
+    STR_DISTANCE_AND_SPEED = 2329,
+    STR_TEMPERATURE = 2330,
+    STR_HEIGHT_LABELS = 2331,
+    STR_UNITS = 2332,
+    STR_SOUND_EFFECTS = 2333,
+    STR_POUNDS = 2334,
+    STR_DOLLARS = 2335,
+    STR_FRANC = 2336,
+    STR_DEUTSCHE_MARK = 2337,
+    STR_YEN = 2338,
+    STR_PESETA = 2339,
+    STR_LIRA = 2340,
+    STR_GUILDERS = 2341,
+    STR_KRONA = 2342,
+    STR_EUROS = 2343,
+    STR_IMPERIAL = 2344,
+    STR_METRIC = 2345,
+
+    STR_NEWS_ITEM_GUEST_DROWNED = 2347,
+    STR_STAFF_STATS_TIP = 2348,
+    STR_STAFF_STAT_WAGES = 2349,
+    STR_STAFF_STAT_EMPLOYED_FOR = 2350,
+    STR_STAFF_STAT_LAWNS_MOWN = 2351,
+    STR_STAFF_STAT_GARDENS_WATERED = 2352,
+    STR_STAFF_STAT_LITTER_SWEPT = 2353,
+    STR_STAFF_STAT_BINS_EMPTIED = 2354,
+    STR_STAFF_STAT_RIDES_FIXED = 2355,
+    STR_STAFF_STAT_RIDES_INSPECTED = 2356,
+
+    STR_HEIGHT_IN_UNITS = 2358,
+    STR_REAL_VALUES = 2359,
+    STR_DISPLAY_RESOLUTION = 2360,
+    STR_TILE_SMOOTHING = 2361,
+    STR_TILE_SMOOTHING_TIP = 2362,
+    STR_GRIDLINES = 2363,
+    STR_GRIDLINES_TIP = 2364,
+    STR_BANK_REFUSES_TO_INCREASE_LOAN = 2365,
+    STR_CELSIUS = 2366,
+    STR_FAHRENHEIT = 2367,
+    STR_PEEP_STAT_NAUSEA_TOLERANCE_NONE = 2368,
+    STR_PEEP_STAT_NAUSEA_TOLERANCE_LOW = 2369,
+    STR_PEEP_STAT_NAUSEA_TOLERANCE_AVERAGE = 2370,
+    STR_PEEP_STAT_NAUSEA_TOLERANCE_HIGH = 2371,
+    STR_RATING_LOW = 2372,
+    STR_RATING_MEDIUM = 2373,
+    STR_RATING_HIGH = 2374,
+    STR_RATING_VERY_HIGH = 2375,
+    STR_RATING_EXTREME = 2376,
+    STR_RATING_ULTRA_EXTREME = 2377,
+    STR_ADJUST_SMALLER_LAND_TIP = 2378,
+    STR_ADJUST_LARGER_LAND_TIP = 2379,
+    STR_ADJUST_SMALLER_WATER_TIP = 2380,
+    STR_ADJUST_LARGER_WATER_TIP = 2381,
+    STR_LAND = 2382,
+    STR_WATER = 2383,
+    STR_OBJECTIVE_LABEL = 2384,
+    STR_OBJECTIVE_NONE = 2385,
+    STR_OBJECTIVE_GUESTS_BY = STR_OBJECTIVE_NONE + 1,
+    STR_OBJECTIVE_PARK_VALUE_BY = STR_OBJECTIVE_NONE + 2,
+    STR_OBJECTIVE_HAVE_FUN = STR_OBJECTIVE_NONE + 3,
+    STR_OBJECTIVE_BUILD_THE_BEST = STR_OBJECTIVE_NONE + 4,
+    STR_OBJECTIVE_10_ROLLERCOASTERS = STR_OBJECTIVE_NONE + 5,
+    STR_OBJECTIVE_GUESTS_AND_RATING = STR_OBJECTIVE_NONE + 6,
+    STR_OBJECTIVE_MONTHLY_RIDE_INCOME = STR_OBJECTIVE_NONE + 7,
+    STR_OBJECTIVE_10_ROLLERCOASTERS_LENGTH = STR_OBJECTIVE_NONE + 8,
+    STR_OBJECTIVE_FINISH_5_ROLLERCOASTERS = STR_OBJECTIVE_NONE + 9,
+    STR_OBJECTIVE_REPLAY_LOAN_AND_PARK_VALUE = STR_OBJECTIVE_NONE + 10,
+    STR_OBJECTIVE_MONTHLY_FOOD_INCOME = STR_OBJECTIVE_NONE + 11,
+    STR_OBJECTIVE_DROPDOWN_NONE = 2397,
+    STR_OBJECTIVE_DROPDOWN_NUMBER_OF_GUESTS_AT_A_GIVEN_DATE = STR_OBJECTIVE_DROPDOWN_NONE + 1,
+    STR_OBJECTIVE_DROPDOWN_PARK_VALUE_AT_A_GIVEN_DATE = STR_OBJECTIVE_DROPDOWN_NONE + 2,
+    STR_OBJECTIVE_DROPDOWN_HAVE_FUN = STR_OBJECTIVE_DROPDOWN_NONE + 3,
+    STR_OBJECTIVE_DROPDOWN_BUILD_THE_BEST_RIDE_YOU_CAN = STR_OBJECTIVE_DROPDOWN_NONE + 4,
+    STR_OBJECTIVE_DROPDOWN_BUILD_10_ROLLER_COASTERS = STR_OBJECTIVE_DROPDOWN_NONE + 5,
+    STR_OBJECTIVE_DROPDOWN_NUMBER_OF_GUESTS_IN_PARK = STR_OBJECTIVE_DROPDOWN_NONE + 6,
+    STR_OBJECTIVE_DROPDOWN_MONTHLY_INCOME_FROM_RIDE_TICKETS = STR_OBJECTIVE_DROPDOWN_NONE + 7,
+    STR_OBJECTIVE_DROPDOWN_BUILD_10_ROLLER_COASTERS_OF_A_GIVEN_LENGTH = STR_OBJECTIVE_DROPDOWN_NONE + 8,
+    STR_OBJECTIVE_DROPDOWN_FINISH_BUILDING_5_ROLLER_COASTERS = STR_OBJECTIVE_DROPDOWN_NONE + 9,
+    STR_OBJECTIVE_DROPDOWN_REPAY_LOAN_AND_ACHIEVE_A_GIVEN_PARK_VALUE = STR_OBJECTIVE_DROPDOWN_NONE + 10,
+    STR_OBJECTIVE_DROPDOWN_MONTHLY_PROFIT_FROM_FOOD_MERCHANDISE = STR_OBJECTIVE_DROPDOWN_NONE + 11,
+    STR_MARKETING_CAMPAIGNS_IN_OPERATION = 2409,
+    STR_MARKETING_CAMPAIGNS_NONE = 2410,
+    STR_MARKETING_CAMPAIGNS_AVAILABLE = 2411,
+    STR_START_THIS_MARKETING_CAMPAIGN = 2412,
+    STR_MARKETING_PER_WEEK = 2413,
+    STR_MARKETING_NOT_SELECTED = 2414,
+    STR_MARKETING_RIDE = 2415,
+    STR_MARKETING_ITEM = 2416,
+    STR_LENGTH_OF_TIME = 2417,
+    STR_PEEP_INVENTORY_VOUCHER_PARK_ENTRY_FREE = 2418,
+    STR_PEEP_INVENTORY_VOUCHER_RIDE_FREE = 2419,
+    STR_PEEP_INVENTORY_VOUCHER_PARK_ENTRY_HALF_PRICE = 2420,
+    STR_PEEP_INVENTORY_VOUCHER_FOOD_OR_DRINK_FREE = 2421,
+
+
+    STR_MARKETING_VOUCHERS_FOR_FREE_ENTRY_TO_THE_PARK = 2424,
+    STR_MARKETING_VOUCHERS_FOR_FREE_RIDES_ON_A_PARTICULAR_RIDE = 2425,
+    STR_MARKETING_VOUCHERS_FOR_HALF_PRICE_ENTRY_TO_THE_PARK = 2426,
+    STR_MARKETING_VOUCHERS_FOR_FREE_FOOD_OR_DRINK = 2427,
+    STR_MARKETING_ADVERTISING_CAMPAIGN_FOR_THE_PARK = 2428,
+    STR_MARKETING_ADVERTISING_CAMPAIGN_FOR_A_PARTICULAR_RIDE = 2429,
+    STR_VOUCHERS_FOR_FREE_ENTRY_TO = 2430,
+    STR_VOUCHERS_FOR_FREE_RIDE_ON = 2431,
+    STR_VOUCHERS_FOR_HALF_PRICE_ENTRY_TO = 2432,
+    STR_VOUCHERS_FOR_FREE = 2433,
+    STR_ADVERTISING_CAMPAIGN_FOR_1 = 2434,
+    STR_ADVERTISING_CAMPAIGN_FOR_2 = 2435,
+    STR_MARKETING_1_WEEK = 2436,
+
+
+
+
+
+
+    STR_MARKETING_COST_PER_WEEK = 2443,
+    STR_MARKETING_TOTAL_COST = 2444,
+    STR_MARKETING_START_THIS_MARKETING_CAMPAIGN = 2445,
+    STR_MARKETING_FINISHED_FREE_ENTRY = 2446,
+    STR_MARKETING_FINISHED_FREE_RIDES = 2447,
+    STR_MARKETING_FINISHED_HALF_PRICE_ENTRY = 2448,
+    STR_MARKETING_FINISHED_FREE_RIDE = 2449,
+    STR_MARKETING_FINISHED_PARK_ADS = 2450,
+    STR_MARKETING_FINISHED_RIDE_ADS = 2451,
+    STR_FINANCES_FINANCIAL_GRAPH_CASH_LESS_LOAN_POSITIVE = 2452,
+    STR_FINANCES_FINANCIAL_GRAPH_CASH_LESS_LOAN_NEGATIVE = 2453,
+    STR_FINANCES_FINANCIAL_GRAPH_CASH_VALUE = 2454,
+
+
+    STR_FINANCES_SHOW_SUMMARY_TAB_TIP = 2457,
+    STR_FINANCES_SHOW_CASH_TAB_TIP = 2458,
+    STR_FINANCES_SHOW_PARK_VALUE_TAB_TIP = 2459,
+    STR_FINANCES_SHOW_WEEKLY_PROFIT_TAB_TIP = 2460,
+    STR_FINANCES_SHOW_MARKETING_TAB_TIP = 2461,
+    STR_PARK_ENTRANCE_TAB_TIP = 2462,
+    STR_PARK_RATING_TAB_TIP = 2463,
+    STR_PARK_GUESTS_TAB_TIP = 2464,
+    STR_PARK_PRICE_TAB_TIP = 2465,
+    STR_PARK_STATS_TAB_TIP = 2466,
+    STR_PARK_OBJECTIVE_TAB_TIP = 2467,
+    STR_PARK_AWARDS_TAB_TIP = 2468,
+    STR_SELECT_LEVEL_OF_RESEARCH_AND_DEVELOPMENT = 2469,
+    STR_RESEARCH_NEW_TRANSPORT_RIDES_TIP = 2470,
+    STR_RESEARCH_NEW_GENTLE_RIDES_TIP = 2471,
+    STR_RESEARCH_NEW_ROLLER_COASTERS_TIP = 2472,
+    STR_RESEARCH_NEW_THRILL_RIDES_TIP = 2473,
+    STR_RESEARCH_NEW_WATER_RIDES_TIP = 2474,
+    STR_RESEARCH_NEW_SHOPS_AND_STALLS_TIP = 2475,
+    STR_RESEARCH_NEW_SCENERY_AND_THEMING_TIP = 2476,
+    STR_SELECT_OPERATING_MODE = 2477,
+    STR_SHOW_GRAPH_OF_VELOCITY_AGAINST_TIME_TIP = 2478,
+    STR_SHOW_GRAPH_OF_ALTITUDE_AGAINST_TIME_TIP = 2479,
+    STR_SHOW_GRAPH_OF_VERTICAL_ACCELERATION_AGAINST_TIME_TIP = 2480,
+    STR_SHOW_GRAPH_OF_LATERAL_ACCELERATION_AGAINST_TIME_TIP = 2481,
+    STR_PROFIT_PER_WEEK_AND_PARK_VALUE_TIP = 2482,
+    STR_FINANCES_WEEKLY_PROFIT_POSITIVE = 2483,
+    STR_FINANCES_WEEKLY_PROFIT_LOSS = 2484,
+
+
+    STR_REAL_NAME = 2487,
+    STR_REAL_NAME_TIP = 2488,
+    STR_HOTKEY = 2489,
+    STR_SHORTCUTS_TITLE = 2490,
+    STR_SHORTCUT_ACTION_RESET = 2491,
+    STR_SHORTCUT_ACTION_RESET_TIP = 2492,
+    STR_SHORTCUT_CLOSE_TOP_MOST_WINDOW = 2493,
+    STR_SHORTCUT_CLOSE_ALL_FLOATING_WINDOWS = 2494,
+    STR_SHORTCUT_CANCEL_CONSTRUCTION_MODE = 2495,
+    STR_SHORTCUT_PAUSE_GAME = 2496,
+    STR_SHORTCUT_ZOOM_VIEW_OUT = 2497,
+    STR_SHORTCUT_ZOOM_VIEW_IN = 2498,
+    STR_SHORTCUT_ROTATE_VIEW_CLOCKWISE = 2499,
+    STR_SHORTCUT_ROTATE_CONSTRUCTION_OBJECT = 2500,
+    STR_SHORTCUT_UNDERGROUND_VIEW_TOGGLE = 2501,
+    STR_SHORTCUT_REMOVE_BASE_LAND_TOGGLE = 2502,
+    STR_SHORTCUT_REMOVE_VERTICAL_LAND_TOGGLE = 2503,
+    STR_SHORTCUT_SEE_THROUGH_RIDES_TOGGLE = 2504,
+    STR_SHORTCUT_SEE_THROUGH_SCENERY_TOGGLE = 2505,
+    STR_SHORTCUT_INVISIBLE_SUPPORTS_TOGGLE = 2506,
+    STR_SHORTCUT_INVISIBLE_PEOPLE_TOGGLE = 2507,
+    STR_SHORTCUT_HEIGHT_MARKS_ON_LAND_TOGGLE = 2508,
+    STR_SHORTCUT_HEIGHT_MARKS_ON_RIDE_TRACKS_TOGGLE = 2509,
+    STR_SHORTCUT_HEIGHT_MARKS_ON_PATHS_TOGGLE = 2510,
+    STR_SHORTCUT_ADJUST_LAND = 2511,
+    STR_SHORTCUT_ADJUST_WATER = 2512,
+    STR_SHORTCUT_BUILD_SCENERY = 2513,
+    STR_SHORTCUT_BUILD_PATHS = 2514,
+    STR_SHORTCUT_BUILD_NEW_RIDE = 2515,
+    STR_SHORTCUT_SHOW_FINANCIAL_INFORMATION = 2516,
+    STR_SHORTCUT_SHOW_RESEARCH_INFORMATION = 2517,
+    STR_SHORTCUT_SHOW_RIDES_LIST = 2518,
+    STR_SHORTCUT_SHOW_PARK_INFORMATION = 2519,
+    STR_SHORTCUT_SHOW_GUEST_LIST = 2520,
+    STR_SHORTCUT_SHOW_STAFF_LIST = 2521,
+    STR_SHORTCUT_SHOW_RECENT_MESSAGES = 2522,
+    STR_SHORTCUT_SHOW_MAP = 2523,
+    STR_SHORTCUT_SCREENSHOT = 2524,
+
+
+
+    STR_SHORTCUT_BACKSPACE = 2533,
+    STR_SHORTCUT_TAB = 2534,
+
+
+
+    STR_SHORTCUT_CLEAR = 2537,
+    STR_SHORTCUT_RETURN = 2538,
+
+
+
+    STR_SHORTCUT_ALT = 2543,
+    STR_SHORTCUT_PAUSE = 2544,
+    STR_SHORTCUT_CAPS = 2545,
+
+
+
+    STR_SHORTCUT_ESCAPE = 2552,
+
+
+
+    STR_SHORTCUT_SPACEBAR = 2557,
+    STR_SHORTCUT_PGUP = 2558,
+    STR_SHORTCUT_PGDN = 2559,
+    STR_SHORTCUT_END = 2560,
+    STR_SHORTCUT_HOME = 2561,
+    STR_SHORTCUT_LEFT = 2562,
+    STR_SHORTCUT_UP = 2563,
+    STR_SHORTCUT_RIGHT = 2564,
+    STR_SHORTCUT_DOWN = 2565,
+    STR_SHORTCUT_SELECT = 2566,
+    STR_SHORTCUT_PRINT = 2567,
+    STR_SHORTCUT_EXECUTE = 2568,
+    STR_SHORTCUT_SNAPSHOT = 2569,
+    STR_SHORTCUT_INSERT = 2570,
+    STR_SHORTCUT_DELETE = 2571,
+    STR_SHORTCUT_HELP = 2572,
+
+
+
+    STR_SHORTCUT_MENU = 2618,
+
+
+
+    STR_SHORTCUT_NUMPAD_0 = 2621,
+    STR_SHORTCUT_NUMPAD_1 = 2622,
+    STR_SHORTCUT_NUMPAD_2 = 2623,
+    STR_SHORTCUT_NUMPAD_3 = 2624,
+    STR_SHORTCUT_NUMPAD_4 = 2625,
+    STR_SHORTCUT_NUMPAD_5 = 2626,
+    STR_SHORTCUT_NUMPAD_6 = 2627,
+    STR_SHORTCUT_NUMPAD_7 = 2628,
+    STR_SHORTCUT_NUMPAD_8 = 2629,
+    STR_SHORTCUT_NUMPAD_9 = 2630,
+    STR_SHORTCUT_NUMPAD_MULTIPLY = 2631,
+    STR_SHORTCUT_NUMPAD_PLUS = 2632,
+
+
+
+    STR_SHORTCUT_NUMPAD_MINUS = 2634,
+    STR_SHORTCUT_NUMPAD_PERIOD = 2635,
+    STR_SHORTCUT_NUMPAD_DIVIDE = 2636,
+
+
+
+    STR_SHORTCUT_NUMLOCK = 2669,
+    STR_SHORTCUT_SCROLL = 2670,
+
+
+
+    STR_RESEARCH_COMPLETED_AL = 2680,
+
+
+
+    STR_CHEAT_LARGE_TRAM_GUESTS_TIP = 2684,
+    STR_MAPGEN_SIMPLEX_NOISE = 2685,
+    STR_MAPGEN_SIMPLEX_NOISE_LOW_ = 2686,
+    STR_MAPGEN_SIMPLEX_NOISE_HIGH = 2687,
+    STR_MAPGEN_SIMPLEX_NOISE_BASE_FREQUENCY = 2688,
+    STR_MAPGEN_SIMPLEX_NOISE_OCTAVES = 2689,
+    STR_MAPGEN_WINDOW_TITLE = 2690,
+    STR_BASE_HEIGHT_LABEL = 2691,
+    STR_WATER_LEVEL_LABEL = 2692,
+    STR_TERRAIN_LABEL = 2693,
+    STR_MAPGEN_ACTION_GENERATE = 2694,
+    STR_MAPGEN_OPTION_RANDOM_TERRAIN = 2695,
+    STR_MAPGEN_OPTION_PLACE_TREES = 2696,
+
+
+
+    STR_OPTIONS_AUTOSAVE_FREQUENCY_LABEL = 2700,
+    STR_SAVE_EVERY_MINUTE = 2701,
+    STR_SAVE_EVERY_5MINUTES = 2702,
+    STR_SAVE_EVERY_15MINUTES = 2703,
+    STR_SAVE_EVERY_30MINUTES = 2704,
+    STR_SAVE_EVERY_HOUR = 2705,
+    STR_SAVE_NEVER = 2706,
+    STR_FILEBROWSER_USE_SYSTEM_WINDOW = 2707,
+    STR_FILEBROWSER_OVERWRITE_PROMPT = 2708,
+    STR_FILEBROWSER_OVERWRITE_TITLE = 2709,
+    STR_FILEBROWSER_FILE_NAME_PROMPT = 2710,
+
+
+
+    STR_FILEBROWSER_ACTION_UP = 2718,
+    STR_FILEBROWSER_ACTION_NEW_FILE = 2719,
+    STR_DURATION_SEC = 2720,
+    STR_DURATION_SECS = 2721,
+    STR_DURATION_MIN_SEC = 2722,
+    STR_DURATION_MIN_SECS = 2723,
+    STR_DURATION_MINS_SEC = 2724,
+    STR_DURATION_MINS_SECS = 2725,
+    STR_REALTIME_MIN = 2726,
+    STR_REALTIME_MINS = 2727,
+    STR_REALTIME_HOUR_MIN = 2728,
+    STR_REALTIME_HOUR_MINS = 2729,
+    STR_REALTIME_HOURS_MIN = 2730,
+    STR_REALTIME_HOURS_MINS = 2731,
+    STR_UNIT_SUFFIX_FEET = 2732,
+    STR_UNIT_SUFFIX_METRES = 2733,
+    STR_UNIT_SUFFIX_MILES_PER_HOUR = 2734,
+    STR_UNIT_SUFFIX_KILOMETRES_PER_HOUR = 2735,
+    STR_DATE_FORMAT_MY = 2736,
+    STR_DATE_FORMAT_DMY = 2737,
+    STR_OPTIONS_MUSIC_LABEL = 2738,
+    STR_OPTIONS_MUSIC_VALUE_NONE = 2739,
+    STR_ROLLERCOASTER_TYCOON_1_DROPDOWN = 2740,
+    STR_ROLLERCOASTER_TYCOON_2_DROPDOWN = 2741,
+    STR_OPTIONS_MUSIC_ERR_CSS50_NOT_FOUND = 2742,
+    STR_OPTIONS_MUSIC_ERR_CSS50_NOT_FOUND_HINT = 2743,
+
+
+
+    STR_MY_NEW_SCENARIO = 2749,
+    STR_MOVE_ALL_TOP = 2750,
+    STR_MOVE_ALL_BOTTOM = 2751,
+    STR_CHEAT_CLEAR_GRASS = 2752,
+    STR_CHEAT_MOWED_GRASS = 2753,
+    STR_CHEAT_WATER_PLANTS = 2754,
+    STR_CHEAT_FIX_VANDALISM = 2755,
+    STR_CHEAT_REMOVE_LITTER = 2756,
+
+
+
+    STR_CHEAT_LARGE_TRAM_GUESTS = 2765,
+    STR_CHEAT_WIN_SCENARIO = 2766,
+    STR_CHEAT_FREEZE_WEATHER = 2767,
+
+    STR_CHEAT_OPEN_PARK = 2769,
+    STR_CHEAT_CLOSE_PARK = 2770,
+
+
+    STR_OPTIONS_DISPLAY_WINDOWED = 2773,
+    STR_OPTIONS_DISPLAY_FULLSCREEN = 2774,
+    STR_OPTIONS_DISPLAY_FULLSCREEN_BORDERLESS = 2775,
+    STR_OPTIONS_LANGUAGE = 2776,
+    STR_OPTIONS_DROPDOWN_ITEM = 2777,
+    STR_OPTIONS_DROPDOWN_ITEM_SELECTED = 2778,
+    STR_VIEWPORT_NO = 2779,
+    STR_EXTRA_VIEWPORT = 2780,
+    STR_SHORTCUT_ENTRY_FORMAT = 2781,
+    STR_SHIFT_PLUS = 2782,
+    STR_CTRL_PLUS = 2783,
+    STR_SHORTCUT_CHANGE_TITLE = 2784,
+    STR_SHORTCUT_CHANGE_PROMPT = 2785,
+    STR_SHORTCUT_LIST_TIP = 2786,
+    STR_FINANCES_PARK_VALUE = 2787,
+    STR_OBJECTIVE_ACHIEVED = 2788,
+    STR_OBJECTIVE_FAILED = 2789,
+    STR_ENTER_NAME_INTO_SCENARIO_CHART = 2790,
+    STR_ENTER_NAME = 2791,
+    STR_PLEASE_ENTER_YOUR_NAME_FOR_THE_SCENARIO_CHART = 2792,
+    STR_COMPLETED_BY = 2793,
+    STR_COMPLETED_BY_WITH_COMPANY_VALUE = 2794,
+    STR_SORT = 2795,
+    STR_RIDE_LIST_SORT_TIP = 2796,
+    STR_SCREEN_EDGE_SCROLLING = 2797,
+    STR_SCREEN_EDGE_SCROLLING_TIP = 2798,
+    STR_HOTKEY_TIP = 2799,
+    STR_TOTAL_ADMISSIONS = 2800,
+    STR_INCOME_FROM_ADMISSIONS = 2801,
+    STR_MAP_LABEL = 2802,
+    STR_SHOW_GUESTS_ON_MAP_TIP = 2803,
+    STR_SHOW_STAFF_ON_MAP_TIP = 2804,
+    STR_SHOW_MAP_TIP = 2805,
+    STR_PEEPS_DISGUSTED_BY_PATHS = 2806,
+    STR_PEEPS_DISLIKE_LITTER = 2807,
+    STR_PEEPS_DISLIKE_VANDALISM = 2808,
+    STR_PEEPS_ARE_HUNGRY = 2809,
+    STR_PEEPS_ARE_THIRSTY = 2810,
+    STR_PEEPS_CANT_FIND_TOILET = 2811,
+    STR_PEEPS_GETTING_LOST_OR_STUCK = 2812,
+    STR_ENTRANCE_FEE_TOO_HI = 2813,
+    STR_AWARD_MOST_UNTIDY = 2814,
+    STR_AWARD_MOST_TIDY = STR_AWARD_MOST_UNTIDY + 1,
+    STR_AWARD_BEST_ROLLERCOASTERS = STR_AWARD_MOST_UNTIDY + 2,
+    STR_AWARD_BEST_VALUE = STR_AWARD_MOST_UNTIDY + 3,
+    STR_AWARD_MOST_BEAUTIFUL = STR_AWARD_MOST_UNTIDY + 4,
+    STR_AWARD_WORST_VALUE = STR_AWARD_MOST_UNTIDY + 5,
+    STR_AWARD_SAFEST = STR_AWARD_MOST_UNTIDY + 6,
+    STR_AWARD_BEST_STAFF = STR_AWARD_MOST_UNTIDY + 7,
+    STR_AWARD_BEST_FOOD = STR_AWARD_MOST_UNTIDY + 8,
+    STR_AWARD_WORST_FOOD = STR_AWARD_MOST_UNTIDY + 9,
+    STR_AWARD_BEST_RESTROOMS = STR_AWARD_MOST_UNTIDY + 10,
+    STR_AWARD_MOST_DISAPPOINTING = STR_AWARD_MOST_UNTIDY + 11,
+    STR_AWARD_BEST_WATER_RIDES = STR_AWARD_MOST_UNTIDY + 12,
+    STR_AWARD_BEST_CUSTOM_DESIGNED_RIDES = STR_AWARD_MOST_UNTIDY + 13,
+    STR_AWARD_MOST_DAZZLING_RIDE_COLOURS = STR_AWARD_MOST_UNTIDY + 14,
+    STR_AWARD_MOST_CONFUSING_LAYOUT = STR_AWARD_MOST_UNTIDY + 15,
+    STR_AWARD_BEST_GENTLE_RIDES = STR_AWARD_MOST_UNTIDY + 16,
+    STR_NEWS_ITEM_AWARD_MOST_UNTIDY = 2831,
+    STR_NEWS_ITEM_MOST_TIDY = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 1,
+    STR_NEWS_ITEM_BEST_ROLLERCOASTERS = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 2,
+    STR_NEWS_ITEM_BEST_VALUE = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 3,
+    STR_NEWS_ITEM_MOST_BEAUTIFUL = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 4,
+    STR_NEWS_ITEM_WORST_VALUE = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 5,
+    STR_NEWS_ITEM_SAFEST = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 6,
+    STR_NEWS_ITEM_BEST_STAFF = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 7,
+    STR_NEWS_ITEM_BEST_FOOD = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 8,
+    STR_NEWS_ITEM_WORST_FOOD = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 9,
+    STR_NEWS_ITEM_BEST_RESTROOMS = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 10,
+    STR_NEWS_ITEM_MOST_DISAPPOINTING = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 11,
+    STR_NEWS_ITEM_BEST_WATER_RIDES = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 12,
+    STR_NEWS_ITEM_BEST_CUSTOM_DESIGNED_RIDES = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 13,
+    STR_NEWS_ITEM_MOST_DAZZLING_RIDE_COLOURS = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 14,
+    STR_NEWS_ITEM_MOST_CONFUSING_LAYOUT = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 15,
+    STR_NEWS_ITEM_BEST_GENTLE_RIDES = STR_NEWS_ITEM_AWARD_MOST_UNTIDY + 16,
+    STR_NO_RECENT_AWARDS = 2848,
+
+
+
+
+    STR_FORBIDDEN_BY_THE_LOCAL_AUTHORITY = 2853,
+    STR_ENTRANCE_NOT_CONNECTED = 2854,
+    STR_EXIT_NOT_CONNECTED = 2855,
+    STR_CANT_START_MARKETING_CAMPAIGN = 2858,
+
+    STR_LICENSED_TO_INFOGRAMES_INTERACTIVE_INC = 2861,
+    STR_MUSIC_ACKNOWLEDGEMENTS_ELLIPSIS = 2862,
+    STR_MUSIC_ACKNOWLEDGEMENTS = 2863,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_MARCH_CHILDREN_OF_THE_REGIMENT = 2864,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_HEYKENS_SERENADE = 2865,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_IN_CONTINENTAL_MOOD = 2866,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_WEDDING_JOURNEY = 2867,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_TALES_FROM_THE_VIENNA_WOODS = 2868,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_SLAVONIC_DANCE = 2869,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_DAS_ALPENHORN = 2870,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_THE_BLOND_SAILOR = 2871,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_OVERTURE_POET_AND_PEASANT = 2872,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_WALTZ_MEDLEY = 2873,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_BELLA_BELLA_BIMBA = 2874,
+    STR_MUSIC_ACKNOWLEDGEMENTS_ORIGINAL_RECORDINGS = 2875,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_RCT2_TITLE_MUSIC = 2876,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_DODGEMS_BEAT = 2877,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_MIS_SUMMERS_HEAT = 2878,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_PHARAOS_TOMB = 2879,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_CAESARS_MARCH = 2880,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_DRIFTING_TO_HEAVEN = 2881,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_INVADERS = 2882,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_ETERNAL_TOYBOX = 2883,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_JUNGLE_JUICE = 2884,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_NINJAS_NOODLES = 2885,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_VOYAGE_TO_ANDROMEDA = 2886,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_BRIMBLES_BEAT = 2887,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_ATLANTIS = 2888,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_WILD_WEST_KID = 2889,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_VAMPIRES_LAIR = 2890,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_BLOCKUBSTER = 2891,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_AIRTIME_ROCK = 2892,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_SEARCHLIGHT_RAG = 2893,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_FLIGHT_OF_FANTASY = 2894,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_BIG_ROCK = 2895,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_HYPOTHERMIA = 2896,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_LAST_SLEIGH_RIDE = 2897,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_PIPES_OF_GLENCAIRN = 2898,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_TRAFFIC_JAM = 2899,
+
+    STR_MUSIC_ACKNOWLEDGEMENTS_SAMPLES_COURTESY = 2901,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_TOCCATA = 2902,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_SPACE_ROCK = 2903,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_MANIC_MECHANIC = 2904,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_TECHNO_TORTURE = 2905,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_SWEET_DREAMS = 2906,
+    STR_MUSIC_ACKNOWLEDGEMENTS_TRACK_WHAT_SHALL_WE_DO_WITH_THE_DRUNKEN_SAILOR = 2907,
+
+    STR_MAIN_COLOUR_SCHEME = 2971,
+    STR_ALTERNATIVE_COLOUR_SCHEME_1 = 2972,
+    STR_ALTERNATIVE_COLOUR_SCHEME_2 = 2973,
+    STR_ALTERNATIVE_COLOUR_SCHEME_3 = 2974,
+    STR_COLOUR_SCHEME_TO_CHANGE_TIP = 2975,
+    STR_PAINT_INDIVIDUAL_AREA_TIP = 2976,
+    STR_STAFF_TITLE_STAFF_MEMBER_NAME = 2977,
+    STR_STAFF_PROMPT_ENTER_NAME = 2978,
+    STR_STAFF_ERROR_CANT_NAME_STAFF_MEMBER = 2979,
+    STR_TOO_MANY_BANNERS_IN_GAME = 2980,
+    STR_NO_ENTRY = 2981,
+    STR_BANNER_TEXT = 2982,
+    STR_ENTER_BANNER_TEXT = 2983,
+    STR_ERR_CANT_SET_BANNER_TEXT = 2984,
+    STR_BANNER_WINDOW_TITLE = 2985,
+    STR_CHANGE_BANNER_TEXT_TIP = 2986,
+    STR_SET_AS_NO_ENTRY_BANNER_TIP = 2987,
+    STR_DEMOLISH_BANNER_TIP = 2988,
+    STR_SELECT_MAIN_SIGN_COLOUR_TIP = 2989,
+    STR_SELECT_TEXT_COLOUR_TIP = 2990,
+    STR_SIGN = 2991,
+    STR_SIGN_TEXT_TITLE = 2992,
+    STR_SIGN_TEXT_PROMPT = 2993,
+    STR_CHANGE_SIGN_TEXT_TIP = 2994,
+    STR_DEMOLISH_SIGN_TIP = 2995,
+    STR_TEXT_COLOR_BLACK = 2996,
+    STR_TEXT_COLOR_GREY = 2997,
+    STR_TEXT_COLOR_WHITE = 2998,
+    STR_TEXT_COLOR_RED = 2999,
+    STR_TEXT_COLOR_GREEN = 3000,
+    STR_TEXT_COLOR_YELLOW = 3001,
+    STR_TEXT_COLOR_TOPAZ = 3002,
+    STR_TEXT_COLOR_CELADON = 3003,
+    STR_TEXT_COLOR_BABYBLUE = 3004,
+    STR_TEXT_COLOR_PALELAVENDER = 3005,
+    STR_TEXT_COLOR_PALEGOLD = 3006,
+    STR_TEXT_COLOR_LIGHTPINK = 3007,
+    STR_TEXT_COLOR_PEARLAQUA = 3008,
+    STR_TEXT_COLOR_PALESILVER = 3009,
+    STR_UNABLE_TO_LOAD_FILE = 3010,
+    STR_FILE_CONTAINS_INVALID_DATA = 3011,
+    STR_MUSIC_STYLE_DODGEMS_BEAT = 3012,
+    STR_MUSIC_STYLE_FAIRGROUND_ORGAN = 3013,
+    STR_MUSIC_STYLE_ROMAN_FANFARE = 3014,
+    STR_MUSIC_STYLE_ORIENTAL = 3015,
+    STR_MUSIC_STYLE_MARTIAN = 3016,
+    STR_MUSIC_STYLE_JUNGLE_DRUMS = 3017,
+    STR_MUSIC_STYLE_EGYPTIAN = 3018,
+    STR_MUSIC_STYLE_TOYLAND = 3019,
+    STR_MUSIC_STYLE_CIRCUS_SHOW = 3020,
+    STR_MUSIC_STYLE_SPACE = 3021,
+    STR_MUSIC_STYLE_HORROR = 3022,
+    STR_MUSIC_STYLE_TECHNO = 3023,
+    STR_MUSIC_STYLE_GENTLE = 3024,
+    STR_MUSIC_STYLE_SUMMER = 3025,
+    STR_MUSIC_STYLE_WATER = 3026,
+    STR_MUSIC_STYLE_WILD_WEST = 3027,
+    STR_MUSIC_STYLE_JURASSIC = 3028,
+    STR_MUSIC_STYLE_ROCK = 3029,
+    STR_MUSIC_STYLE_RAGTIME = 3030,
+    STR_MUSIC_STYLE_FANTASY = 3031,
+    STR_MUSIC_STYLE_ROCK_STYLE_2 = 3032,
+    STR_MUSIC_STYLE_ICE = 3033,
+    STR_MUSIC_STYLE_SNOW = 3034,
+    STR_MUSIC_STYLE_CUSTOM_MUSIC_1 = 3035,
+    STR_MUSIC_STYLE_CUSTOM_MUSIC_2 = 3036,
+    STR_MUSIC_STYLE_MEDIEVAL = 3037,
+    STR_MUSIC_STYLE_URBAN = 3038,
+    STR_MUSIC_STYLE_ORGAN = 3039,
+    STR_MUSIC_STYLE_MECHANICAL = 3040,
+    STR_MUSIC_STYLE_MODERN = 3041,
+    STR_MUSIC_STYLE_PIRATES = 3042,
+    STR_MUSIC_STYLE_ROCK_STYLE_3 = 3043,
+    STR_MUSIC_STYLE_CANDY_STYLE = 3044,
+    STR_SELECT_MUSIC_STYLE_TIP = 3045,
+
+    STR_LOCAL_AUTHORITY_FORBIDS_DEMOLITION_OR_MODIFICATIONS_TO_THIS_RIDE = 3047,
+    STR_MARKETING_CAMPAIGNS_FORBIDDEN_BY_LOCAL_AUTHORITY = 3048,
+    STR_GOLF_HOLE_A = 3049,
+    STR_GOLF_HOLE_B = 3050,
+    STR_GOLF_HOLE_C = 3051,
+    STR_GOLF_HOLE_D = 3052,
+    STR_GOLF_HOLE_E = 3053,
+    STR_RIDE_DESIGN_MAZE_BRICK_WALLS = 3058,
+    STR_RIDE_DESIGN_MAZE_HEDGES = 3059,
+    STR_RIDE_DESIGN_MAZE_ICE_BLOCKS = 3060,
+    STR_RIDE_DESIGN_MAZE_WOODEN_FENCES = 3061,
+    STR_RIDE_CONSTRUCTION_STANDARD_RC_TRACK_TIP = 3062,
+    STR_RIDE_CONSTRUCTION_WATER_CHANNEL_TIP = 3063,
+    STR_BEGINNER_PARKS = 3064,
+    STR_CHALLENGING_PARKS = STR_BEGINNER_PARKS + 1,
+    STR_EXPERT_PARKS = STR_BEGINNER_PARKS + 2,
+    STR_REAL_PARKS = STR_BEGINNER_PARKS + 3,
+    STR_OTHER_PARKS = STR_BEGINNER_PARKS + 4,
+    STR_TOP_SECTION = 3069,
+    STR_SLOPE_TO_LEVEL = 3070,
+    STR_SAME_PRICE_THROUGHOUT_PARK = 3071,
+    STR_SAME_PRICE_THROUGHOUT_PARK_TIP = 3072,
+    STR_PARK_RATING_WARNING_4_WEEKS_REMAINING = 3073,
+    STR_PARK_RATING_WARNING_3_WEEKS_REMAINING = 3074,
+    STR_PARK_RATING_WARNING_2_WEEKS_REMAINING = 3075,
+    STR_PARK_RATING_WARNING_1_WEEK_REMAINING = 3076,
+    STR_PARK_HAS_BEEN_CLOSED_DOWN = 3077,
+    STR_SELECT_STYLE_OF_ENTRANCE_EXIT_STATION_TIP = 3090,
+    STR_YOU_ARE_NOT_ALLOWED_TO_REMOVE_THIS_SECTION = 3091,
+    STR_NOT_ALLOWED_TO_MODIFY_STATION = 3092,
+    STR_FAVOURITE_RIDE = 3093,
+    STR_PEEP_FAVOURITE_RIDE_NOT_AVAILABLE = 3094,
+    STR_LIFT_HILL_CHAIN_SPEED = 3095,
+    STR_LIFT_HILL_CHAIN_SPEED_VALUE = 3096,
+    STR_SELECT_LIFT_HILL_CHAIN_SPEED_TIP = 3097,
+
+    STR_SELECT_COLOUR = 3099,
+    STR_SELECT_SECONDARY_COLOUR = 3100,
+    STR_SELECT_TERNARY_COLOUR = 3101,
+    STR_SCENERY_PAINTBRUSH_TIP = 3102,
+    STR_CANT_REPAINT_THIS = 3103,
+    STR_LIST_RIDES_TIP = 3104,
+    STR_LIST_SHOPS_AND_STALLS_TIP = 3105,
+    STR_LIST_KIOSKS_AND_FACILITIES_TIP = 3106,
+    STR_CLOSE_RIDE = 3107,
+    STR_TEST_RIDE = 3108,
+    STR_OPEN_RIDE = 3109,
+    STR_BLOCK_SECTIONS = 3110,
+    STR_CLICK_ON_DESIGN_TO_BUILD_IT_TIP = 3111,
+    STR_CLICK_ON_DESIGN_TO_RENAME_OR_DELETE_IT = 3112,
+    STR_SELECT_A_DIFFERENT_DESIGN = 3113,
+    STR_GO_BACK_TO_DESIGN_SELECTION_WINDOW_TIP = 3114,
+    STR_SAVE_TRACK_DESIGN = 3115,
+    STR_SAVE_TRACK_DESIGN_NOT_POSSIBLE = 3116,
+    STR_CALLING_MECHANIC = 3117,
+    STR_MEHCANIC_IS_HEADING_FOR_THE_RIDE = 3118,
+    STR_MEHCANIC_IS_FIXING_THE_RIDE = 3119,
+    STR_LOCATE_NEAREST_AVAILABLE_MECHANIC_TIP = 3120,
+    STR_UNABLE_TO_LOCATE_MECHANIC = 3121,
+    STR_FAVOURITE_RIDE_OF_GUEST = 3122,
+    STR_FAVOURITE_RIDE_OF_GUESTS = 3123,
+    STR_BROKEN = 3124,
+    STR_EXCITEMENT_FACTOR = 3125,
+    STR_INTENSITY_FACTOR = 3126,
+    STR_NAUSEA_FACTOR = 3127,
+    STR_SAVE_TRACK_DESIGN_ITEM = 3128,
+    STR_SAVE_TRACK_DESIGN_WITH_SCENERY_ITEM = 3129,
+    STR_DESIGN_SAVE = 3130,
+    STR_DESIGN_CANCEL = 3131,
+    STR_CLICK_ITEMS_OF_SCENERY_TO_SELECT = 3132,
+    STR_ERR_UNABLE_TO_BUILD_THIS_ON_SLOPE = 3133,
+    STR_DESIGN_INCLUDES_SCENERY_WHICH_IS_UNAVAILABLE = 3134,
+    STR_VEHICLE_DESIGN_UNAVAILABLE = 3135,
+    STR_THIS_DESIGN_WILL_BE_BUILT_WITH_AN_ALTERNATIVE_VEHICLE_TYPE = 3136,
+    STR_SELECT_NEARBY_SCENERY = 3137,
+    STR_RESET_SELECTION = 3138,
+    STR_CABLE_LIFT_UNABLE_TO_WORK_IN_THIS_OPERATING_MODE = 3139,
+    STR_CABLE_LIFT_HILL_MUST_START_IMMEDIATELY_AFTER_STATION = 3140,
+    STR_MULTICIRCUIT_NOT_POSSIBLE_WITH_CABLE_LIFT_HILL = 3141,
+    STR_CAPACITY = 3142,
+    STR_SHOW_PEOPLE_ON_MAP_TIP = 3143,
+    STR_SHOW_RIDES_STALLS_ON_MAP_TIP = 3144,
+
+    STR_SELECT_NUMBER_OF_CIRCUITS_TIP = 3160,
+
+    STR_ERR_REASON_NOT_ENOUGH_MEMORY = 3162,
+
+    STR_OBJECT_SELECTION_SELECTION_SIZE = 3164,
+
+    STR_INCLUDES_X_OBJECTS = 3167,
+
+    STR_OBJECT_SELECTION_ERR_OBJECT_DATA_NOT_FOUND = 3169,
+    STR_OBJECT_SELECTION_ERR_NOT_ENOUGH_SPACE_FOR_GRAPHICS = 3170,
+    STR_OBJECT_SELECTION_ERR_TOO_MANY_OF_TYPE_SELECTED = 3171,
+    STR_OBJECT_SELECTION_ERR_SHOULD_SELECT_X_FIRST = 3172,
+    STR_OBJECT_SELECTION_ERR_CURRENTLY_IN_USE = 3173,
+    STR_OBJECT_SELECTION_ERR_IS_REQUIRED_BY_ANOTHER = 3174,
+    STR_OBJECT_SELECTION_ERR_ALWAYS_REQUIRED = 3175,
+    STR_UNABLE_TO_SELECT_THIS_OBJECT = 3176,
+    STR_UNABLE_TO_DE_SELECT_THIS_OBJECT = 3177,
+    STR_AT_LEAST_ONE_PATH_OBJECT_MUST_BE_SELECTED = 3178,
+    STR_AT_LEAST_ONE_RIDE_OBJECT_MUST_BE_SELECTED = 3179,
+    STR_INVALID_SELECTION_OF_OBJECTS = 3180,
+    STR_OBJECT_SELECTION = 3181,
+    STR_PARK_ENTRANCE_TYPE_MUST_BE_SELECTED = 3182,
+    STR_WATER_TYPE_MUST_BE_SELECTED = 3183,
+    STR_OBJECT_SELECTION_RIDE_VEHICLES_ATTRACTIONS = 3184,
+    STR_OBJECT_SELECTION_SMALL_SCENERY = 3185,
+    STR_OBJECT_SELECTION_LARGE_SCENERY = 3186,
+    STR_OBJECT_SELECTION_WALLS_FENCES = 3187,
+    STR_OBJECT_SELECTION_PATH_SIGNS = 3188,
+    STR_OBJECT_SELECTION_FOOTPATHS = 3189,
+    STR_OBJECT_SELECTION_PATH_EXTRAS = 3190,
+    STR_OBJECT_SELECTION_SCENERY_GROUPS = 3191,
+    STR_OBJECT_SELECTION_PARK_ENTRANCE = 3192,
+    STR_OBJECT_SELECTION_WATER = 3193,
+
+    STR_INVENTION_LIST = 3195,
+    STR_INVENTION_RESEARCH_GROUP = 3196,
+    STR_INVENTION_PREINVENTED_ITEMS = 3197,
+    STR_INVENTION_TO_BE_INVENTED_ITEMS = 3198,
+    STR_RANDOM_SHUFFLE = 3199,
+    STR_RANDOM_SHUFFLE_TIP = 3200,
+    STR_EDITOR_STEP_OBJECT_SELECTION = 3201,
+    STR_EDITOR_STEP_LANDSCAPE_EDITOR = 3202,
+    STR_EDITOR_STEP_INVENTIONS_LIST_SET_UP = 3203,
+    STR_EDITOR_STEP_OPTIONS_SELECTION = 3204,
+    STR_EDITOR_STEP_OBJECTIVE_SELECTION = 3205,
+    STR_EDITOR_STEP_SAVE_SCENARIO = 3206,
+    STR_EDITOR_STEP_ROLLERCOASTER_DESIGNER = 3207,
+    STR_EDITOR_STEP_TRACK_DESIGNS_MANAGER = 3208,
+    STR_BACK_TO_PREVIOUS_STEP = 3209,
+    STR_FORWARD_TO_NEXT_STEP = 3210,
+    STR_MAP_SIZE = 3211,
+    STR_MAP_SIZE_VALUE = 3212,
+    STR_CANT_DECREASE_MAP_SIZE_ANY_FURTHER = 3213,
+    STR_CANT_INCREASE_MAP_SIZE_ANY_FURTHER = 3214,
+    STR_TOO_CLOSE_TO_EDGE_OF_MAP = 3215,
+    STR_SELECT_PARK_OWNED_LAND_TIP = 3216,
+    STR_LAND_OWNED = 3217,
+    STR_CONSTRUCTION_RIGHTS_OWNED = 3218,
+    STR_LAND_SALE = 3219,
+    STR_CONSTRUCTION_RIGHTS_SALE = 3220,
+    STR_SET_LAND_TO_BE_OWNED_TIP = 3221,
+    STR_SET_CONSTRUCTION_RIGHTS_TO_BE_OWNED_TIP = 3222,
+    STR_SET_LAND_TO_BE_AVAILABLE_TIP = 3223,
+    STR_SET_CONSTRUCTION_RIGHTS_TO_BE_AVAILABLE_TIP = 3224,
+    STR_SCENERY_CLUSTER_TIP = 3225,
+    STR_BUILD_PARK_ENTRANCE_TIP = 3226,
+    STR_ERR_TOO_MANY_PARK_ENTRANCES = 3227,
+    STR_SET_STARTING_POSITIONS_TIP = 3228,
+    STR_BLOCK_BRAKES_CANNOT_BE_USED_DIRECTLY_AFTER_STATION = 3229,
+    STR_BLOCK_BRAKES_CANNOT_BE_USED_DIRECTLY_AFTER_EACH_OTHER = 3230,
+    STR_BLOCK_BRAKES_CANNOT_BE_USED_DIRECTLY_AFTER_THE_TOP_OF_THIS_LIFT_HILL = 3231,
+    STR_SCENARIO_OPTIONS_FINANCIAL = 3232,
+    STR_SCENARIO_OPTIONS_GUESTS = 3233,
+    STR_SCENARIO_OPTIONS_PARK = 3234,
+    STR_SCENARIO_OPTIONS_FINANCIAL_TIP = 3235,
+    STR_SCENARIO_OPTIONS_GUESTS_TIP = 3236,
+    STR_SCENARIO_OPTIONS_PARK_TIP = 3237,
+    STR_MAKE_PARK_NO_MONEY = 3238,
+    STR_MAKE_PARK_NO_MONEY_TIP = 3239,
+    STR_INIT_CASH_LABEL = 3240,
+    STR_INIT_LOAN_LABEL = 3241,
+    STR_MAX_LOAN_LABEL = 3242,
+    STR_INTEREST_RATE_LABEL = 3243,
+    STR_FORBID_MARKETING = 3244,
+    STR_FORBID_MARKETING_TIP = 3245,
+    STR_CURRENCY_FORMAT_LABEL = 3246,
+    STR_PERCENT_FORMAT_LABEL = 3247,
+    STR_CANT_INCREASE_CASH = 3248,
+    STR_CANT_REDUCE_CASH = 3249,
+    STR_CANT_INCREASE_INIT_LOAN = 3250,
+    STR_CANT_REDUCE_INIT_LOAN = 3251,
+    STR_CANT_INCREASE_MAX_LOAN = 3252,
+    STR_CANT_REDUCE_MAX_LOAN = 3253,
+    STR_CANT_INCREASE_INTEREST_RATE = 3254,
+    STR_CANT_REDUCE_INTEREST_RATE = 3255,
+    STR_GUESTS_PREFER_LESS_INTENSE_RIDES = 3256,
+    STR_GUESTS_PREFER_LESS_INTENSE_RIDES_TIP = 3257,
+    STR_GUESTS_PREFER_MORE_INTENSE_RIDES = 3258,
+    STR_GUESTS_PREFER_MORE_INTENSE_RIDES_TIP = 3259,
+    STR_CASH_PER_GUEST_LABEL = 3260,
+    STR_GUEST_INIT_HAPPINESS = 3261,
+    STR_GUEST_INIT_HUNGER = 3262,
+    STR_GUEST_INIT_THIRST = 3263,
+    STR_CANT_INCREASE_FURTHER = 3264,
+    STR_CANT_REDUCE_FURTHER = 3265,
+    STR_PAY_FOR_PARK_PAY_FOR_RIDES_TIP = 3266,
+    STR_FORBID_TREE_REMOVAL = 3267,
+    STR_FORBID_TREE_REMOVAL_TIP = 3268,
+    STR_FORBID_LANDSCAPE_CHANGES = 3269,
+    STR_FORBID_LANDSCAPE_CHANGES_TIP = 3270,
+    STR_FORBID_HIGH_CONSTRUCTION = 3271,
+    STR_FORBID_HIGH_CONSTRUCTION_TIP = 3272,
+    STR_HARD_PARK_RATING = 3273,
+    STR_HARD_PARK_RATING_TIP = 3274,
+    STR_HARD_GUEST_GENERATION = 3275,
+    STR_HARD_GUEST_GENERATION_TIP = 3276,
+    STR_LAND_COST_LABEL = 3277,
+    STR_RIGHTS_COST_LABEL = 3278,
+    STR_FREE_PARK_ENTER = 3279,
+    STR_PAY_PARK_ENTER = 3280,
+    STR_ENTRY_PRICE_LABEL = 3281,
+    STR_SELECT_OBJECTIVE_AND_PARK_NAME_TIP = 3282,
+    STR_SELECT_RIDES_TO_BE_PRESERVED_TIP = 3283,
+    STR_OBJECTIVE_SELECTION = 3284,
+    STR_OBJECTIVE_PRESERVED_RIDES_TITLE = 3285,
+    STR_SELECT_OBJECTIVE_FOR_THIS_SCENARIO_TIP = 3286,
+    STR_OBJECTIVE_WINDOW = 3287,
+    STR_SELECT_CLIMATE_TIP = 3288,
+    STR_CLIMATE_LABEL = 3289,
+    STR_CLIMATE_COOL_AND_WET = 3290,
+    STR_CLIMATE_WARM = STR_CLIMATE_COOL_AND_WET + 1,
+    STR_CLIMATE_HOT_AND_DRY = STR_CLIMATE_COOL_AND_WET + 2,
+    STR_CLIMATE_COLD = STR_CLIMATE_COOL_AND_WET + 3,
+    STR_CHANGE = 3294,
+    STR_CHANGE_NAME_OF_PARK_TIP = 3295,
+    STR_CHANGE_NAME_OF_SCENARIO_TIP = 3296,
+    STR_CHANGE_DETAIL_NOTES_ABOUT_PARK_SCENARIO_TIP = 3297,
+    STR_WINDOW_PARK_NAME = 3298,
+    STR_WINDOW_PARK_DETAILS = 3299,
+    STR_WINDOW_SCENARIO_NAME = 3300,
+    STR_WINDOW_OBJECTIVE_DATE = 3301,
+    STR_WINDOW_OBJECTIVE_VALUE_DATE = 3302,
+    STR_WINDOW_OBJECTIVE_GUEST_COUNT = 3303,
+    STR_WINDOW_OBJECTIVE_PARK_VALUE = 3304,
+    STR_WINDOW_OBJECTIVE_MONTHLY_INCOME = 3305,
+    STR_WINDOW_OBJECTIVE_MONTHLY_PROFIT = 3306,
+    STR_WINDOW_OBJECTIVE_MINIMUM_LENGTH = 3307,
+    STR_WINDOW_OBJECTIVE_EXCITEMENT_RATING = 3308,
+    STR_WINDOW_OBJECTIVE_VALUE_GUEST_COUNT = 3309,
+    STR_WINDOW_OBJECTIVE_VALUE_LENGTH = 3310,
+    STR_WINDOW_OBJECTIVE_VALUE_RATING = 3311,
+    STR_WINDOW_PRESERVATION_ORDER = 3312,
+    STR_SCENARIO_NAME = 3313,
+    STR_ENTER_SCENARIO_NAME = 3314,
+    STR_PARK_SCENARIO_DETAILS = 3315,
+    STR_ENTER_SCENARIO_DESCRIPTION = 3316,
+    STR_NO_DETAILS_YET = 3317,
+    STR_SELECT_WHICH_GROUP_THIS_SCENARIO_APPEARS_IN = 3318,
+    STR_WINDOW_SCENARIO_GROUP = 3319,
+    STR_UNABLE_TO_SAVE_SCENARIO_FILE = 3320,
+
+    STR_OBJECTIVE = 3322,
+
+    STR_WINDOW_NO_IMAGE = 3326,
+    STR_PEEP_SPAWNS_NOT_SET = 3327,
+    STR_CANT_ADVANCE_TO_NEXT_EDITOR_STAGE = 3328,
+    STR_NO_PARK_ENTRANCES = 3329,
+    STR_PARK_MUST_OWN_SOME_LAND = 3330,
+    STR_PARK_ENTRANCE_PATH_INCOMPLETE_OR_COMPLEX = 3331,
+    STR_PARK_ENTRANCE_WRONG_DIRECTION_OR_NO_PATH = 3332,
+    STR_SAVE_PLUGIN_DATA = 3333,
+    STR_SAVE_PLUGIN_DATA_TIP = 3334,
+    STR_ROLLER_COASTER_DESIGNER_SELECT_RIDE_TYPES_VEHICLES = 3335,
+    STR_TRACK_DESIGNS_MANAGER_SELECT_RIDE_TYPE = 3336,
+
+    STR_CUSTOM_DESIGNED_LAYOUT = 3338,
+    STR_1_DESIGN_AVAILABLE = 3339,
+    STR_X_DESIGNS_AVAILABLE = 3340,
+    STR_GAME_TOOLS_TIP = 3341,
+    STR_SCENARIO_EDITOR = 3342,
+    STR_CONVERT_SAVED_GAME_TO_SCENARIO = 3343,
+    STR_ROLLER_COASTER_DESIGNER = 3344,
+    STR_TRACK_DESIGNS_MANAGER = 3345,
+    STR_CANT_SAVE_TRACK_DESIGN = 3346,
+    STR_TRACK_TOO_LARGE_OR_TOO_MUCH_SCENERY = 3347,
+    STR_TRACK_MANAGE_RENAME = 3348,
+    STR_TRACK_MANAGE_DELETE = 3349,
+    STR_TRACK_DESIGN_RENAME_TITLE = 3350,
+    STR_TRACK_DESIGN_RENAME_DESC = 3351,
+    STR_CANT_RENAME_TRACK_DESIGN = 3352,
+    STR_NEW_NAME_CONTAINS_INVALID_CHARACTERS = 3353,
+    STR_ANOTHER_FILE_EXISTS_WITH_NAME_OR_FILE_IS_WRITE_PROTECTED = 3354,
+    STR_FILE_IS_WRITE_PROTECTED_OR_LOCKED = 3355,
+    STR_DELETE_FILE = 3356,
+    STR_ARE_YOU_SURE_YOU_WANT_TO_PERMANENTLY_DELETE_TRACK = 3357,
+    STR_CANT_DELETE_TRACK_DESIGN = 3358,
+    STR_NO_TRACK_DESIGNS_OF_THIS_TYPE = 3359,
+    STR_WARNING = 3360,
+    STR_TOO_MANY_TRACK_DESIGNS_OF_THIS_TYPE = 3361,
+
+    STR_OBJECT_SELECTION_ADVANCED = 3364,
+    STR_OBJECT_SELECTION_ADVANCED_TIP = 3365,
+    STR_MAP_RIDE = 3366,
+    STR_MAP_FOOD_STALL = 3367,
+    STR_MAP_DRINK_STALL = 3368,
+    STR_MAP_SOUVENIR_STALL = 3369,
+    STR_MAP_INFO_KIOSK = 3370,
+    STR_MAP_FIRST_AID = 3371,
+    STR_MAP_CASH_MACHINE = 3372,
+    STR_MAP_TOILET = 3373,
+    STR_WARNING_TOO_MANY_OBJECTS_SELECTED = 3374,
+    STR_NOT_ALL_OBJECTS_IN_THIS_SCENERY_GROUP_COULD_BE_SELECTED = 3375,
+    STR_INSTALL_NEW_TRACK_DESIGN = 3376,
+    STR_INSTALL_NEW_TRACK_DESIGN_TIP = 3377,
+    STR_INSTALL_NEW_TRACK_DESIGN_INSTALL = 3378,
+    STR_INSTALL_NEW_TRACK_DESIGN_CANCEL = 3379,
+    STR_UNABLE_TO_INSTALL_THIS_TRACK_DESIGN = 3380,
+
+    STR_SELECT_NEW_NAME_FOR_TRACK_DESIGN = 3383,
+    STR_AN_EXISTING_TRACK_DESIGN_ALREADY_HAS_THIS_NAME = 3384,
+
+    STR_SAVE_TRACK_SCENERY_UNABLE_TO_SELECT_ADDITIONAL_ITEM_OF_SCENERY = 3389,
+    STR_SAVE_TRACK_SCENERY_TOO_MANY_ITEMS_SELECTED = 3390,
+
+    STR_CLEAR_SCENERY_TIP = 3437,
+    STR_UNABLE_TO_REMOVE_ALL_SCENERY_FROM_HERE = 3438,
+    STR_CLEAR_SCENERY = 3439,
+    STR_SET_PATROL_AREA = 3445,
+    STR_CLEAR_PATROL_AREA = 3446,
+
+
+
+    STR_OPENRCT2_BEGIN_STRING_ID = 5120,
+
+    STR_FINANCES_BUTTON_ON_TOOLBAR = 5120,
+    STR_RESEARCH_BUTTON_ON_TOOLBAR = 5121,
+
+    STR_CHEAT_RENEW_RIDES = 5123,
+
+    STR_CHEAT_MAKE_DESTRUCTABLE = 5125,
+    STR_OPTIONS_MUSIC_VALUE_RANDOM = 5126,
+    STR_DISABLE_ELEVATION = 5127,
+    STR_SELECTION_SIZE = 5128,
+    STR_ENTER_SELECTION_SIZE = 5129,
+    STR_MAP_SIZE_2 = 5130,
+    STR_ENTER_MAP_SIZE = 5131,
+    STR_CHEAT_FIX_ALL_RIDES = 5132,
+    STR_ADJUST_SMALLER_LAND_RIGHTS_TIP = 5133,
+    STR_ADJUST_LARGER_LAND_RIGHTS_TIP = 5134,
+    STR_BUY_LAND_AND_CONSTRUCTION_RIGHTS_TIP = 5135,
+    STR_LAND_RIGHTS = 5136,
+    STR_CHEAT_UNLOCK_OPERATING_LIMITS = 5137,
+    STR_SMALL_WINDOW_COLOUR_2_STRINGID = 5138,
+    STR_WHITE_STRING = 5139,
+    STR_CHEAT_DISABLE_BRAKES_FAILURE = 5140,
+    STR_CHEAT_DISABLE_BREAKDOWNS = 5141,
+    STR_SPEED_NORMAL = 5142,
+    STR_SPEED_QUICK = 5143,
+    STR_SPEED_FAST = 5144,
+    STR_SPEED_TURBO = 5145,
+    STR_SPEED_HYPER = 5146,
+    STR_CHEATS_BUTTON_ON_TOOLBAR = 5147,
+    STR_GAME_SPEED_TIP = 5148,
+    STR_CHEATS_TIP = 5149,
+    STR_ENABLE_DEBUGGING_TOOLS = 5150,
+    STR_LOCALE_THOUSANDS_SEPARATOR = 5151,
+    STR_LOCALE_DECIMAL_POINT = 5152,
+    STR_EDIT_THEMES_BUTTON = 5153,
+    STR_HARDWARE_DISPLAY = 5154,
+    STR_CHEAT_UNLOCK_PRICES = 5157,
+    STR_QUIT_TO_MENU = 5158,
+    STR_EXIT_OPENRCT2 = 5159,
+    STR_DATE_FORMAT_MDY = 5160,
+    STR_DATE_FORMAT = 5161,
+    STR_DATE_FORMAT_DAY_MONTH_YEAR = 5162,
+    STR_DATE_FORMAT_MONTH_DAY_YEAR = 5163,
+    STR_FULLSCREEN_MODE = 5177,
+    STR_FINANCIAL_CHEATS_TIP = 5178,
+    STR_GUEST_CHEATS_TIP = 5179,
+    STR_PARK_CHEATS_TIP = 5180,
+    STR_RIDE_CHEATS_TIP = 5181,
+    STR_FORMAT_INTEGER = 5182,
+    STR_BASE_HEIGHT = 5183,
+    STR_ENTER_BASE_HEIGHT = 5184,
+    STR_WATER_LEVEL = 5185,
+    STR_ENTER_WATER_LEVEL = 5186,
+    STR_THEMES_WINDOW_FINANCES = 5187,
+    STR_THEMES_WINDOW_NEW_CAMPAIGN = 5188,
+    STR_THEMES_WINDOW_RESEARCH = 5189,
+    STR_THEMES_WINDOW_MAP = 5190,
+    STR_THEMES_WINDOW_VIEWPORT = 5191,
+    STR_THEMES_WINDOW_RECENT_NEWS = 5192,
+    STR_THEMES_WINDOW_LAND = 5193,
+    STR_THEMES_WINDOW_WATER = 5194,
+    STR_THEMES_WINDOW_CLEAR_SCENERY = 5195,
+    STR_THEMES_WINDOW_LAND_RIGHTS = 5196,
+    STR_THEMES_WINDOW_SCENERY = 5197,
+    STR_THEMES_WINDOW_FOOTPATH = 5198,
+    STR_THEMES_WINDOW_RIDE_CONSTRUCTION = 5199,
+    STR_THEMES_WINDOW_TRACK_DESIGN_PLACE = 5200,
+    STR_THEMES_WINDOW_CONSTRUCT_RIDE = 5201,
+    STR_THEMES_WINDOW_TRACK_DESIGN_LIST = 5202,
+    STR_THEMES_WINDOW_RIDE = 5203,
+    STR_THEMES_WINDOW_RIDE_LIST = 5204,
+    STR_THEMES_WINDOW_PEEP = 5205,
+    STR_THEMES_WINDOW_GUEST_LIST = 5206,
+    STR_THEMES_WINDOW_STAFF = 5207,
+    STR_THEMES_WINDOW_STAFF_LIST = 5208,
+    STR_THEMES_WINDOW_BANNER = 5209,
+    STR_THEMES_WINDOW_EDITOR_OBJECT_SELECTION = 5210,
+    STR_THEMES_WINDOW_EDITOR_INVENTION_LIST = 5211,
+    STR_THEMES_WINDOW_EDITOR_SCENARIO_OPTIONS = 5212,
+    STR_THEMES_WINDOW_EDTIOR_OBJECTIVE_OPTIONS = 5213,
+    STR_THEMES_WINDOW_MAPGEN = 5214,
+    STR_THEMES_WINDOW_MANAGE_TRACK_DESIGN = 5215,
+    STR_THEMES_WINDOW_INSTALL_TRACK = 5216,
+    STR_CHEAT_TITLE = 5217,
+    STR_THEMES_WINDOW_THEMES = 5218,
+    STR_THEMES_WINDOW_OPTIONS = 5219,
+    STR_THEMES_WINDOW_KEYBOARD_SHORTCUT_LIST = 5220,
+    STR_THEMES_WINDOW_CHANGE_KEYBOARD_SHORTCUT = 5221,
+    STR_THEMES_WINDOW_LOADSAVE = 5222,
+    STR_THEMES_WINDOW_SAVE_PROMPT = 5223,
+    STR_THEMES_WINDOW_DEMOLISH_RIDE_PROMPT = 5224,
+    STR_THEMES_WINDOW_FIRE_PROMPT = 5225,
+    STR_THEMES_WINDOW_TRACK_DELETE_PROMPT = 5226,
+    STR_THEMES_WINDOW_LOADSAVE_OVERWRITE_PROMPT = 5227,
+    STR_THEMES_TAB_MAIN_TIP = 5228,
+    STR_THEMES_TAB_PARK_TIP = 5229,
+    STR_THEMES_TAB_TOOLS_TIP = 5230,
+    STR_THEMES_TAB_RIDES_AND_GUESTS_TIP = 5231,
+    STR_THEMES_TAB_EDITORS_TIP = 5232,
+    STR_THEMES_TAB_MISC_TIP = 5233,
+    STR_THEMES_TAB_PROMPTS_TIP = 5234,
+    STR_THEMES_TAB_SETTINGS_TIP = 5235,
+    STR_THEMES_HEADER_WINDOW = 5236,
+    STR_THEMES_HEADER_PALETTE = 5237,
+    STR_THEMES_LABEL_CURRENT_THEME = 5238,
+    STR_TITLE_EDITOR_ACTION_DUPLICATE = 5239,
+    STR_THEMES_PROMPT_ENTER_THEME_NAME = 5240,
+    STR_THEMES_ERR_CANT_CHANGE_THIS_THEME = 5241,
+    STR_THEMES_ERR_NAME_ALREADY_EXISTS = 5242,
+    STR_ERROR_INVALID_CHARACTERS = 5243,
+    STR_THEMES_TITLE = 5244,
+    STR_THEMES_WINDOW_TOP_TOOLBAR = 5245,
+    STR_THEMES_WINDOW_BOTTOM_TOOLBAR = 5246,
+    STR_THEMES_WINDOW_BOTTOM_TOOLBAR_TRACK_EDITOR = 5247,
+    STR_THEMES_WINDOW_BOTTOM_TOOLBAR_SCENARIO_EDITOR = 5248,
+    STR_THEMES_WINDOW_TITLE_MENU_BUTTONS = 5249,
+    STR_THEMES_WINDOW_TITLE_MENU_EXIT = 5250,
+    STR_THEMES_WINDOW_TITLE_MENU_OPTIONS = 5251,
+    STR_THEMES_WINDOW_TITLE_MENU_SCENARIO_SELECTION = 5252,
+    STR_THEMES_WINDOW_PARK_INFORMATION = 5253,
+    STR_TITLE_EDITOR_ACTION_CREATE = 5254,
+    STR_TITLE_EDITOR_ACTION_CREATE_SEQUENCE_TIP = 5255,
+    STR_THEMES_DESC_CANT_CHANGE_THIS_THEME = 5256,
+    STR_THEMES_ACTION_DUPLICATE_TIP = 5257,
+    STR_THEMES_ACTION_DELETE_TIP = 5258,
+    STR_THEMES_ACTION_RENAME_TIP = 5259,
+    STR_GIANT_SCREENSHOT = 5260,
+    STR_OBJECT_FILTER = 5261,
+    STR_OBJECT_FILTER_WW = 5262,
+    STR_OBJECT_FILTER_TT = 5263,
+    STR_OBJECT_FILTER_CUSTOM = 5264,
+    STR_OBJECT_FILTER_TIP = 5265,
+    STR_OPTIONS_DISPLAY_TIP = 5266,
+    STR_OPTIONS_CULTURE_TIP = 5267,
+    STR_OPTIONS_AUDIO_TIP = 5268,
+    STR_OPTIONS_CONTROLS_AND_INTERFACE_TIP = 5269,
+    STR_OPTIONS_MISCELLANEOUS_TIP = 5270,
+    STR_CLEAR_SCENERY_REMOVE_SMALL_SCENERY_TIP = 5272,
+    STR_CLEAR_SCENERY_REMOVE_LARGE_SCENERY_TIP = 5273,
+    STR_CLEAR_SCENERY_REMOVE_FOOTPATHS_TIP = 5274,
+    STR_OBJECT_SEARCH = 5275,
+    STR_OBJECT_SEARCH_DESC = 5276,
+    STR_OBJECT_SEARCH_CLEAR = 5277,
+    STR_CHEAT_SANDBOX_MODE = 5278,
+    STR_CHEAT_SANDBOX_MODE_DISABLE = 5279,
+    STR_CHEAT_SANDBOX_MODE_TIP = 5280,
+    STR_THEMES_TAB_FEATURES_TIP = 5281,
+    STR_THEMES_OPTION_RCT1_RIDE_CONTROLS = 5282,
+    STR_THEMES_OPTION_RCT1_PARK_CONTROLS = 5283,
+    STR_THEMES_OPTION_RCT1_SCENARIO_SELECTION_FONT = 5284,
+
+    STR_DEBUG_RIDE_ALREADY_BROKEN = 5287,
+    STR_DEBUG_RIDE_IS_CLOSED = 5288,
+    STR_DEBUG_NO_BREAKDOWNS_AVAILABLE = 5289,
+    STR_DEBUG_FIX_RIDE = 5290,
+    STR_DEBUG_CANT_FORCE_BREAKDOWN = 5291,
+    STR_DEBUG_FORCE_BREAKDOWN_TIP = 5292,
+    STR_CLOSE_RIDE_TIP = 5293,
+    STR_TEST_RIDE_TIP = 5294,
+    STR_OPEN_RIDE_TIP = 5295,
+    STR_CLOSE_PARK_TIP = 5296,
+    STR_OPEN_PARK_TIP = 5297,
+    STR_RED_STRINGID = 5298,
+    STR_LIGHTPINK_STRINGID = 5299,
+    STR_QUICK_FIRE_STAFF = 5300,
+    STR_CHEAT_CLEAR_LOAN_TIP = 5301,
+    STR_CHEAT_CLEAR_LOAN = 5302,
+    STR_CHEAT_BUILD_IN_PAUSE_MODE = 5303,
+    STR_TITLE_SEQUENCE = 5304,
+    STR_TITLE_SEQUENCE_RCT1 = 5305,
+    STR_TITLE_SEQUENCE_RCT1_AA = 5306,
+    STR_TITLE_SEQUENCE_RCT1_AA_LL = 5307,
+    STR_TITLE_SEQUENCE_RCT2 = 5308,
+    STR_TITLE_SEQUENCE_OPENRCT2 = 5309,
+    STR_TITLE_SEQUENCE_RANDOM = 5310,
+    STR_DEBUG_TIP = 5311,
+    STR_DEBUG_DROPDOWN_CONSOLE = 5312,
+    STR_DEBUG_DROPDOWN_TILE_INSPECTOR = 5313,
+    STR_TILE_INSPECTOR_TITLE = 5314,
+    STR_TILE_INSPECTOR_ENTRANCE_TYPE_RIDE_ENTRANCE = 5335,
+    STR_TILE_INSPECTOR_ENTRANCE_TYPE_RIDE_EXIT = 5336,
+    STR_TILE_INSPECTOR_ENTRANCE_TYPE_PARK_ENTRANC = 5337,
+    STR_TILE_INSPECTOR_ELEMENT_TYPE = 5338,
+    STR_TILE_INSPECTOR_BASE_HEIGHT = 5339,
+    STR_TILE_INSPECTOR_CLEARANCE_HEIGHT = 5340,
+    STR_AUTO_STAFF_PLACEMENT = 5343,
+    STR_CHANGELOG_TITLE = 5344,
+    STR_CHEAT_TITLE_FINANCIAL = 5345,
+    STR_CHEAT_TITLE_GUEST = 5346,
+    STR_CHEAT_TITLE_PARK = 5347,
+    STR_CHEAT_TITLE_RIDE = 5348,
+    STR_OBJECT_FILTER_ALL_RIDES_TIP = 5349,
+    STR_MAX = 5350,
+    STR_MIN = 5351,
+    STR_CHEAT_GUEST_HAPPINESS = 5352,
+    STR_CHEAT_GUEST_ENERGY = 5353,
+    STR_CHEAT_GUEST_HUNGER = 5354,
+    STR_CHEAT_GUEST_THIRST = 5355,
+    STR_CHEAT_GUEST_NAUSEA = 5356,
+    STR_CHEAT_GUEST_NAUSEA_TOLERANCE = 5357,
+    STR_CHEAT_GUEST_TOILET = 5358,
+    STR_CHEAT_REMOVE_ALL_GUESTS = 5359,
+    STR_CHEAT_REMOVE_ALL_GUESTS_TIP = 5360,
+    STR_CHEAT_GIVE_ALL_GUESTS = 5361,
+    STR_CHEAT_GUEST_PREFERRED_INTENSITY = 5362,
+    STR_CHEAT_MORE_THAN_1 = 5363,
+    STR_CHEAT_LESS_THAN_15 = 5364,
+    STR_CHEAT_STAFF_SPEED = 5365,
+    STR_NORMAL = 5366,
+    STR_FAST = 5367,
+    STR_CHEAT_RESET_CRASH_STATUS = 5368,
+    STR_DEBUG_DROPDOWN_OBJECT_SELECTION = 5371,
+    STR_INVERT_RIGHT_MOUSE_DRAG = 5372,
+    STR_NAME = 5373,
+    STR_DATE = 5374,
+    STR_UP = 5375,
+    STR_DOWN = 5376,
+    STR_TITLE_EDITOR_SAVES_TAB_TIP = 5377,
+    STR_TITLE_EDITOR_SCRIPT_TAB_TIP = 5378,
+    STR_TITLE_EDITOR_ACTION_SKIP_TIP = 5379,
+    STR_TITLE_EDITOR_ACTION_PLAY_TIP = 5380,
+    STR_TITLE_EDITOR_ACTION_STOP_TIP = 5381,
+    STR_TITLE_EDITOR_ACTION_REPLAY_TIP = 5382,
+    STR_TITLE_EDITOR_ACTION_DUPLICATE_SEQUENCE_TIP = 5383,
+    STR_TITLE_EDITOR_ACTION_DELETE_SEQUENCE_TIP = 5384,
+    STR_TITLE_EDITOR_ACTION_RENAME_SEQUENCE_TIP = 5385,
+    STR_TITLE_EDITOR_ACTION_INSERT_TIP = 5386,
+    STR_TITLE_EDITOR_ACTION_EDIT_TIP = 5387,
+    STR_TITLE_EDITOR_ACTION_DELETE_TIP = 5388,
+    STR_TITLE_EDITOR_ACTION_SKIP_TO_TIP = 5389,
+    STR_TITLE_EDITOR_ACTION_MOVE_DOWN_TIP = 5390,
+    STR_TITLE_EDITOR_ACTION_MOVE_UP_TIP = 5391,
+    STR_TITLE_EDITOR_ACTION_ADD_TIP = 5392,
+    STR_TITLE_EDITOR_ACTION_REMOVE_TIP = 5393,
+    STR_TITLE_EDITOR_ACTION_RENAME_TIP = 5394,
+    STR_TITLE_EDITOR_ACTION_LOAD_TIP = 5395,
+    STR_TITLE_EDITOR_ACTION_RELOAD_TIP = 5396,
+
+    STR_TITLE_EDITOR_ERR_CANT_EDIT_WHILE_PLAYING = 5398,
+    STR_TITLE_EDITOR_PRESS_STOP_TO_CONTINUE_EDITING = 5399,
+    STR_ERROR_CANT_CHANGE_TITLE_SEQUENCE = 5400,
+
+    STR_ERR_FAILED_TO_LOAD_TITLE_SEQUENCE = 5402,
+
+    STR_ERROR_EXISTING_NAME = 5404,
+    STR_TITLE_EDITOR_ENTER_NAME_FOR_SAVE = 5405,
+    STR_TITLE_EDITOR_ENTER_NAME_FOR_SEQUENCE = 5406,
+    STR_TITLE_EDITOR_ACTION_ADD = 5407,
+    STR_TITLE_EDITOR_ACTION_REMOVE = 5408,
+    STR_TITLE_EDITOR_ACTION_INSERT = 5409,
+    STR_TITLE_EDITOR_ACTION_EDIT = 5410,
+    STR_TITLE_EDITOR_ACTION_RELOAD = 5411,
+    STR_TITLE_EDITOR_ACTION_SKIP_TO = 5412,
+    STR_TITLE_EDITOR_ACTION_LOAD = 5413,
+    STR_TITLE_EDITOR_COMMAND_LOAD_FILE = 5415,
+    STR_TITLE_EDITOR_COMMAND_LOAD_NO_SAVE = 5416,
+    STR_TITLE_EDITOR_COMMAND_TYPE_LOCATION = 5417,
+    STR_TITLE_EDITOR_COMMAND_LOCATION = 5418,
+    STR_TITLE_EDITOR_COMMAND_TYPE_ROTATE = 5419,
+    STR_TITLE_EDITOR_COMMAND_ROTATE = 5420,
+    STR_TITLE_EDITOR_COMMAND_TYPE_ZOOM = 5421,
+    STR_TITLE_EDITOR_COMMAND_ZOOM = 5422,
+    STR_TITLE_EDITOR_COMMAND_TYPE_WAIT = 5423,
+    STR_TITLE_EDITOR_COMMAND_WAIT = 5424,
+    STR_TITLE_EDITOR_RESTART = 5425,
+    STR_TITLE_EDITOR_END = 5426,
+    STR_TITLE_EDITOR_ARGUMENT_COORDINATES = 5427,
+    STR_TITLE_EDITOR_ARGUMENT_ROTATIONS = 5428,
+    STR_TITLE_EDITOR_ARGUMENT_ZOOM_LEVEL = 5429,
+    STR_TITLE_EDITOR_ARGUMENT_WAIT_SECONDS = 5430,
+    STR_TITLE_EDITOR_ARGUMENT_SAVEFILE = 5431,
+    STR_TITLE_COMMAND_EDITOR_COMMAND_LABEL = 5432,
+    STR_TITLE_EDITOR_TITLE = 5433,
+    STR_TITLE_COMMAND_EDITOR_TITLE = 5434,
+    STR_FILEBROWSER_RENAME_SAVE_TITLE = 5435,
+    STR_EDIT_TITLE_SEQUENCES_BUTTON = 5436,
+    STR_TITLE_COMMAND_EDITOR_NO_SAVE_SELECTED = 5437,
+    STR_TITLE_EDITOR_ERR_CANT_CHANGE_WHILE_EDITOR_IS_OPEN = 5438,
+    STR_TITLE_EDITOR_ERR_RESTART_REQUIRES_WAIT = 5439,
+    STR_MINIMISE_FULLSCREEN_ON_FOCUS_LOSS = 5440,
+
+    STR_FORCE_PARK_RATING = 5442,
+    STR_TITLE_EDITOR_COMMAND_SPEED = 5443,
+    STR_TITLE_EDITOR_ARGUMENT_SPEED = 5444,
+    STR_TITLE_EDITOR_COMMAND_TYPE_SPEED = 5445,
+    STR_TITLE_COMMAND_EDITOR_ACTION_GET_LOCATION = 5446,
+    STR_OBJECTS_SORT_TYPE = 5447,
+    STR_OBJECTS_SORT_RIDE = 5448,
+    STR_SHORTCUT_REDUCE_GAME_SPEED = 5449,
+    STR_SHORTCUT_INCREASE_GAME_SPEED = 5450,
+    STR_SHORTCUT_OPEN_CHEATS_WINDOW = 5451,
+    STR_SHORTCUT_TOGGLE_VISIBILITY_OF_TOOLBARS = 5452,
+    STR_SELECT_OTHER_RIDE = 5453,
+    STR_UNCAP_FPS = 5454,
+    STR_ENABLE_SANDBOX_MODE = 5455,
+    STR_DISABLE_CLEARANCE_CHECKS = 5456,
+    STR_DISABLE_SUPPORT_LIMITS = 5457,
+    STR_ROTATE_CLOCKWISE = 5458,
+    STR_ROTATE_ANTI_CLOCKWISE = 5459,
+    STR_SHORTCUT_ROTATE_VIEW_ANTICLOCKWISE = 5460,
+    STR_CHEAT_SET_GUESTS_PARAMETERS = 5461,
+    STR_CHEAT_CURRENCY_FORMAT = 5462,
+    STR_CHEAT_HAVE_FUN = 5463,
+    STR_CHEAT_GENERAL_GROUP = 5464,
+    STR_CHEAT_WEATHER_GROUP = 5465,
+    STR_CHEAT_STAFF_GROUP = 5466,
+    STR_ALT_PLUS = 5467,
+    STR_SHOW_RECENT_MESSAGES_ON_TOOLBAR = 5468,
+    STR_SHORTCUT_SCROLL_MAP_UP = 5469,
+    STR_SHORTCUT_SCROLL_MAP_LEFT = 5470,
+    STR_SHORTCUT_SCROLL_MAP_DOWN = 5471,
+    STR_SHORTCUT_SCROLL_MAP_RIGHT = 5472,
+    STR_CYCLE_DAY_NIGHT = 5473,
+    STR_UPPERCASE_BANNERS = 5474,
+    STR_X_WEEKS = 5475,
+    STR_HARDWARE_GROUP = 5476,
+    STR_RENDERING_GROUP = 5477,
+    STR_CONTROLS_GROUP = 5478,
+    STR_TOOLBAR_BUTTONS_GROUP = 5479,
+    STR_SHOW_TOOLBAR_BUTTONS_FOR = 5480,
+    STR_THEMES_GROUP = 5481,
+    STR_TIME_SINCE_LAST_INSPECTION_MINUTE = 5482,
+    STR_X_WEEKS_REMAINING = 5483,
+    STR_1_WEEK_REMAINING = 5484,
+    STR_BOTTOM_TOOLBAR_NEWS_TEXT = 5485,
+    STR_LAND_TOOL_SIZE_VALUE = 5486,
+    STR_SHOW_RECENT_MESSAGES_TIP = 5487,
+    STR_TRACKED_GUESTS_ONLY_TIP = 5489,
+    STR_AUDIO_FOCUS = 5490,
+    STR_DEBUG_DROPDOWN_INVENTIONS_LIST = 5491,
+    STR_DEBUG_DROPDOWN_SCENARIO_OPTIONS = 5492,
+    STR_SEND_MESSAGE = 5493,
+
+    STR_PLAYER_LIST = 5495,
+    STR_PLAYER = 5496,
+    STR_PING = 5497,
+    STR_SERVER_LIST = 5498,
+    STR_PLAYER_NAME = 5499,
+    STR_ADD_SERVER = 5500,
+    STR_START_SERVER = 5501,
+    STR_MULTIPLAYER = 5502,
+    STR_ENTER_HOSTNAME_OR_IP_ADDRESS = 5503,
+    STR_SHOW_MULTIPLAYER_STATUS_TIP = 5504,
+    STR_UNABLE_TO_CONNECT_TO_SERVER = 5505,
+    STR_CHEAT_IGNORE_INTENSITY = 5506,
+    STR_ALLOW_LOADING_WITH_INCORRECT_CHECKSUM = 5508,
+    STR_ALLOW_LOADING_WITH_INCORRECT_CHECKSUM_TIP = 5509,
+    STR_OPTIONS_SOUND_VALUE_DEFAULT = 5510,
+    STR_OPTIONS_SOUND_VALUE_UNKNOWN = 5511,
+    STR_SAVE_GAME_AS = 5512,
+    STR_SHORTCUT_QUICK_SAVE_GAME = 5513,
+    STR_CHEAT_DISABLE_VANDALISM = 5514,
+    STR_CHEAT_DISABLE_VANDALISM_TIP = 5515,
+    STR_COLOUR_BLACK_TIP = 5516,
+    STR_COLOUR_GREY_TIP = 5517,
+    STR_COLOUR_WHITE_TIP = 5518,
+    STR_COLOUR_DARK_PURPLE_TIP = 5519,
+    STR_COLOUR_LIGHT_PURPLE_TIP = 5520,
+    STR_COLOUR_BRIGHT_PURPLE_TIP = 5521,
+    STR_COLOUR_DARK_BLUE_TIP = 5522,
+    STR_COLOUR_LIGHT_BLUE_TIP = 5523,
+    STR_COLOUR_ICY_BLUE_TIP = 5524,
+    STR_COLOUR_TEAL_TIP = 5525,
+    STR_COLOUR_AQUAMARINE_TIP = 5526,
+    STR_COLOUR_SATURATED_GREEN_TIP = 5527,
+    STR_COLOUR_DARK_GREEN_TIP = 5528,
+    STR_COLOUR_MOSS_GREEN_TIP = 5529,
+    STR_COLOUR_BRIGHT_GREEN_TIP = 5530,
+    STR_COLOUR_OLIVE_GREEN_TIP = 5531,
+    STR_COLOUR_DARK_OLIVE_GREEN_TIP = 5532,
+    STR_COLOUR_BRIGHT_YELLOW_TIP = 5533,
+    STR_COLOUR_YELLOW_TIP = 5534,
+    STR_COLOUR_DARK_YELLOW_TIP = 5535,
+    STR_COLOUR_LIGHT_ORANGE_TIP = 5536,
+    STR_COLOUR_DARK_ORANGE_TIP = 5537,
+    STR_COLOUR_LIGHT_BROWN_TIP = 5538,
+    STR_COLOUR_SATURATED_BROWN_TIP = 5539,
+    STR_COLOUR_DARK_BROWN_TIP = 5540,
+    STR_COLOUR_SALMON_PINK_TIP = 5541,
+    STR_COLOUR_BORDEAUX_RED_TIP = 5542,
+    STR_COLOUR_SATURATED_RED_TIP = 5543,
+    STR_COLOUR_BRIGHT_RED_TIP = 5544,
+    STR_COLOUR_DARK_PINK_TIP = 5545,
+    STR_COLOUR_BRIGHT_PINK_TIP = 5546,
+    STR_COLOUR_LIGHT_PINK_TIP = 5547,
+    STR_CHEAT_SHOW_ALL_OPERATING_MODES = 5548,
+    STR_DATE_FORMAT_YEAR_MONTH_DAY = 5549,
+    STR_DATE_FORMAT_YMD = 5550,
+    STR_DATE_FORMAT_YEAR_DAY_MONTH = 5551,
+    STR_DATE_FORMAT_YDM = 5552,
+    STR_STEAM_OVERLAY_PAUSE = 5553,
+    STR_ENABLE_MOUNTAIN_TOOL_TIP = 5554,
+    STR_CHEAT_SHOW_VEHICLES_FROM_OTHER_TRACK_TYPES = 5555,
+    STR_KICK_PLAYER_TIP = 5556,
+    STR_STAY_CONNECTED_AFTER_DESYNC = 5557,
+    STR_RESTART_REQUIRED = 5558,
+    STR_CHEAT_10_MINUTE_INSPECTIONS = 5559,
+    STR_CHEAT_10_MINUTE_INSPECTIONS_TIP = 5560,
+    STR_LANGUAGE_LOAD_FAILED = 5561,
+    STR_WARNING_IN_CAPS = 5562,
+    STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE = 5563,
+
+    STR_PASSWORD = 5566,
+    STR_ADVERTISE = 5567,
+    STR_PASSWORD_REQUIRED = 5568,
+    STR_PASSWORD_REQUIRED_DESC = 5569,
+    STR_FETCH_SERVERS = 5570,
+    STR_JOIN_GAME = 5571,
+    STR_ADD_TO_FAVOURITES = 5572,
+    STR_REMOVE_FROM_FAVOURITES = 5573,
+    STR_SERVER_NAME = 5574,
+    STR_MAX_PLAYERS = 5575,
+    STR_PORT = 5576,
+    STR_WON = 5577,
+    STR_ROUBLE = 5578,
+    STR_UI_SCALING_DESC = 5579,
+    STR_CZECH_KORUNA = 5580,
+    STR_SHOW_FPS = 5581,
+    STR_TRAP_MOUSE = 5582,
+    STR_UNIT_SUFFIX_METRES_PER_SECOND = 5583,
+    STR_SI = 5584,
+    STR_CHEAT_UNLOCK_OPERATING_LIMITS_TIP = 5585,
+    STR_AUTO_OPEN_SHOPS = 5586,
+    STR_AUTO_OPEN_SHOPS_TIP = 5587,
+    STR_SHOW_MULTIPLAYER_TIP = 5588,
+    STR_NOTIFICATION_SETTINGS = 5589,
+    STR_NOTIFICATION_PARK_AWARD = 5590,
+    STR_NOTIFICATION_PARK_MARKETING_CAMPAIGN_FINISHED = 5591,
+    STR_NOTIFICATION_PARK_WARNINGS = 5592,
+    STR_NOTIFICATION_PARK_RATING_WARNINGS = 5593,
+    STR_NOTIFICATION_RIDE_BROKEN_DOWN = 5594,
+    STR_NOTIFICATION_RIDE_CRASHED = 5595,
+    STR_NOTIFICATION_RIDE_WARNINGS = 5596,
+    STR_NOTIFICATION_RIDE_RESEARCHED = 5597,
+    STR_NOTIFICATION_GUEST_WARNINGS = 5598,
+    STR_NOTIFICATION_GUEST_LEFT_PARK = 5600,
+    STR_NOTIFICATION_GUEST_QUEUING_FOR_RIDE = 5601,
+    STR_NOTIFICATION_GUEST_ON_RIDE = 5602,
+    STR_NOTIFICATION_GUEST_LEFT_RIDE = 5603,
+    STR_NOTIFICATION_GUEST_BOUGHT_ITEM = 5604,
+    STR_NOTIFICATION_GUEST_USED_FACILITY = 5605,
+    STR_NOTIFICATION_GUEST_DIED = 5606,
+    STR_TILE_INSPECTOR_BASE_HEIGHT_SHORT = 5608,
+    STR_TILE_INSPECTOR_CLEARANGE_HEIGHT_SHORT = 5609,
+    STR_REMOVE_SELECTED_ELEMENT_TIP = 5610,
+    STR_TILE_INSPECTOR_FLAG_GHOST_SHORT = 5611,
+    STR_TILE_INSPECTOR_FLAG_GHOST = 5612,
+    STR_TILE_INSPECTOR_FLAG_BROKEN_SHORT = 5613,
+    STR_TILE_INSPECTOR_FLAG_BROKEN = 5614,
+    STR_TILE_INSPECTOR_FLAG_LAST_SHORT = 5615,
+    STR_TILE_INSPECTOR_FLAG_LAST = 5616,
+    STR_MOVE_SELECTED_ELEMENT_UP_TIP = 5617,
+    STR_MOVE_SELECTED_ELEMENT_DOWN_TIP = 5618,
+    STR_SCENARIO_CATEGORY_RCT1 = 5619,
+    STR_SCENARIO_CATEGORY_RCT1_AA = 5620,
+    STR_SCENARIO_CATEGORY_RCT1_LL = 5621,
+    STR_SCENARIO_CATEGORY_RCT2 = 5622,
+    STR_SCENARIO_CATEGORY_RCT2_WW = 5623,
+    STR_SCENARIO_CATEGORY_RCT2_TT = 5624,
+    STR_SCENARIO_CATEGORY_REAL_PARKS = 5625,
+    STR_SCENARIO_CATEGORY_OTHER_PARKS = 5626,
+    STR_OPTIONS_SCENARIO_GROUPING = 5627,
+    STR_OPTIONS_SCENARIO_ORIGIN = 5628,
+    STR_OPTIONS_SCENARIO_DIFFICULTY = 5629,
+    STR_OPTIONS_SCENARIO_UNLOCKING = 5630,
+    STR_DLC_PARKS = 5631,
+    STR_BUILD_YOUR_OWN_PARKS = 5632,
+    STR_CMD_PLUS = 5633,
+    STR_OPTION_PLUS = 5634,
+    STR_MONEY_SPENT = 5635,
+    STR_COMMANDS_RAN = 5636,
+    STR_CANT_DO_THIS = 5637,
+    STR_PERMISSION_DENIED = 5638,
+    STR_PLAYERS_TIP = 5639,
+    STR_GROUPS_TIP = 5640,
+    STR_DEFAULT_GROUP = 5641,
+    STR_GROUP = 5642,
+    STR_ADD_GROUP = 5643,
+    STR_REMOVE_GROUP = 5644,
+    STR_ACTION_CHAT = 5645,
+    STR_ACTION_TERRAFORM = 5646,
+    STR_ACTION_TOGGLE_PAUSE = 5647,
+    STR_ACTION_SET_WATER_LEVEL = 5648,
+    STR_ACTION_CREATE_RIDE = 5649,
+    STR_ACTION_REMOVE_RIDE = 5650,
+    STR_ACTION_BUILD_RIDE = 5651,
+    STR_ACTION_RIDE_PROPERTIES = 5652,
+    STR_ACTION_SCENERY = 5653,
+    STR_ACTION_PATH = 5654,
+    STR_ACTION_GUEST = 5655,
+    STR_ACTION_STAFF = 5656,
+    STR_ACTION_PARK_PROPERTIES = 5657,
+    STR_ACTION_PARK_FUNDING = 5658,
+    STR_ACTION_KICK_PLAYER = 5659,
+    STR_ACTION_MODIFY_GROUPS = 5660,
+    STR_ACTION_SET_PLAYER_GROUP = 5661,
+    STR_ACTION_NA = 5662,
+    STR_ACTION_CLEAR_LANDSCAPE = 5663,
+    STR_ACTION_CHEAT = 5664,
+    STR_ACTION_TOGGLE_SCENERY_CLUSTER = 5665,
+    STR_ACTION_PASSWORDLESS_LOGIN = 5666,
+
+    STR_LAST_ACTION_RAN = 5701,
+    STR_LOCATE_PLAYER_TIP = 5702,
+    STR_CANT_KICK_THE_HOST = 5703,
+    STR_LAST_ACTION = 5704,
+    STR_CANT_SET_TO_THIS_GROUP = 5705,
+    STR_CANT_REMOVE_GROUP_THAT_PLAYERS_BELONG_TO = 5706,
+    STR_THIS_GROUP_CANNOT_BE_MODIFIED = 5707,
+    STR_CANT_CHANGE_GROUP_THAT_THE_HOST_BELONGS_TO = 5708,
+    STR_RENAME_GROUP = 5709,
+    STR_GROUP_NAME = 5710,
+    STR_ENTER_NEW_NAME_FOR_THIS_GROUP = 5711,
+    STR_CANT_MODIFY_PERMISSION_THAT_YOU_DO_NOT_HAVE_YOURSELF = 5712,
+
+    STR_SHORTCUT_SHOW_OPTIONS = 5714,
+    STR_NEW_GAME = 5715,
+    STR_NOT_ALLOWED_IN_MULTIPLAYER = 5716,
+    STR_NETWORK_VERSION = 5717,
+    STR_NETWORK_VERSION_TIP = 5718,
+    STR_SUNNY = 5719,
+    STR_PARTIALLY_CLOUDY = STR_SUNNY + 1,
+    STR_CLOUDY = STR_SUNNY + 2,
+    STR_RAIN = STR_SUNNY + 3,
+    STR_HEAVY_RAIN = STR_SUNNY + 4,
+    STR_THUNDERSTORM = STR_SUNNY + 5,
+    STR_CHANGE_WEATHER = 5725,
+    STR_CHANGE_WEATHER_TOOLTIP = 5726,
+    STR_SCALING_QUALITY = 5727,
+    STR_SCALING_QUALITY_LINEAR = 5731,
+    STR_OPTIONS_RENDERING_TIP = 5734,
+    STR_THEMES_WINDOW_NETWORK_STATUS = 5735,
+    STR_THEMES_WINDOW_PLAYER = 5736,
+    STR_CLOSED_WITH_PERSON = 5737,
+    STR_CLOSED_WITH_PEOPLE = 5738,
+    STR_CUSTOMERS_ON_RIDE = 5739,
+    STR_CHEAT_NEVERENDING_MARKETING = 5740,
+    STR_CHEAT_NEVERENDING_MARKETING_TIP = 5741,
+    STR_MULTIPLAYER_AUTHENTICATING = 5742,
+    STR_MULTIPLAYER_CONNECTING = 5743,
+    STR_MULTIPLAYER_RESOLVING = 5744,
+    STR_MULTIPLAYER_DESYNC = 5745,
+    STR_MULTIPLAYER_DISCONNECTED_NO_REASON = 5746,
+    STR_MULTIPLAYER_DISCONNECTED_WITH_REASON = 5747,
+    STR_MULTIPLAYER_KICKED = 5748,
+    STR_MULTIPLAYER_KICKED_REASON = 5749,
+    STR_MULTIPLAYER_CONNECTION_CLOSED = 5750,
+    STR_MULTIPLAYER_NO_DATA = 5751,
+    STR_MULTIPLAYER_PLAYER_HAS_DISCONNECTED_NO_REASON = 5752,
+    STR_MULTIPLAYER_PLAYER_HAS_DISCONNECTED_WITH_REASON = 5753,
+    STR_MULTIPLAYER_BAD_PLAYER_NAME = 5754,
+    STR_MULTIPLAYER_INCORRECT_SOFTWARE_VERSION = 5755,
+    STR_MULTIPLAYER_BAD_PASSWORD = 5756,
+    STR_MULTIPLAYER_SERVER_FULL = 5757,
+    STR_MULTIPLAYER_PLAYER_HAS_JOINED_THE_GAME = 5758,
+    STR_MULTIPLAYER_DOWNLOADING_MAP = 5759,
+    STR_HONG_KONG_DOLLAR = 5760,
+    STR_NEW_TAIWAN_DOLLAR = 5761,
+    STR_CHINESE_YUAN = 5762,
+    STR_ALL_FILES = 5763,
+    STR_INVALID_RIDE_TYPE = 5764,
+    STR_CANT_EDIT_INVALID_RIDE_TYPE = 5765,
+    STR_HUNGARIAN_FORINT = 5766,
+    STR_RIDE_LIST_INCOME = 5767,
+    STR_RIDE_LIST_TOTAL_CUSTOMERS = 5768,
+    STR_RIDE_LIST_TOTAL_PROFIT = 5769,
+    STR_RIDE_LIST_CUSTOMERS_PER_HOUR = 5770,
+    STR_RIDE_LIST_RUNNING_COST = 5771,
+    STR_RIDE_LIST_AGE = 5772,
+    STR_RIDE_LIST_TOTAL_CUSTOMERS_LABEL = 5773,
+    STR_RIDE_LIST_TOTAL_PROFIT_LABEL = 5774,
+    STR_RIDE_LIST_CUSTOMERS_PER_HOUR_LABEL = 5775,
+    STR_RIDE_LIST_BUILT_THIS_YEAR_LABEL = 5776,
+    STR_RIDE_LIST_BUILT_LAST_YEAR_LABEL = 5777,
+    STR_RIDE_LIST_BUILT_X_YEARS_AGO_LABEL = 5778,
+    STR_RIDE_LIST_INCOME_LABEL = 5779,
+    STR_RIDE_LIST_RUNNING_COST_LABEL = 5780,
+    STR_RIDE_LIST_RUNNING_COST_UNKNOWN = 5781,
+    STR_MULTIPLAYER_CONNECTED_CHAT_HINT = 5782,
+    STR_SCENARIO_LOCKED = 5783,
+    STR_SCENARIO_LOCKED_DESC = 5784,
+    STR_CANT_RENAME_GROUP = 5785,
+    STR_INVALID_GROUP_NAME = 5786,
+    STR_X_PLAYERS_ONLINE = 5787,
+    STR_DEFAULT_INSPECTION_INTERVAL = 5788,
+    STR_DISABLE_LIGHTNING_EFFECT = 5789,
+    STR_CHEAT_UNLOCK_PRICES_TIP = 5790,
+    STR_CHEAT_RENEW_RIDES_TIP = 5791,
+    STR_CHEAT_FIX_ALL_RIDES_TIP = 5792,
+    STR_CHEAT_RESET_CRASH_STATUS_TIP = 5793,
+    STR_CHEAT_MAKE_DESTRUCTABLE_TIP = 5794,
+    STR_CHEAT_IGNORE_INTENSITY_TIP = 5795,
+    STR_CHEAT_OPEN_PARK_TIP = 5796,
+    STR_CHEAT_FREEZE_WEATHER_TIP = 5797,
+    STR_CHEAT_BUILD_IN_PAUSE_MODE_TIP = 5798,
+    STR_CHEAT_DISABLE_BRAKES_FAILURE_TIP = 5799,
+    STR_CHEAT_DISABLE_BREAKDOWNS_TIP = 5800,
+    STR_CHEAT_DISABLE_LITTERING = 5801,
+    STR_CHEAT_DISABLE_LITTERING_TIP = 5802,
+    STR_ROTATE_SELECTED_ELEMENT_TIP = 5803,
+    STR_SHORTCUT_MUTE_SOUND = 5804,
+    STR_ADVERTISE_SERVER_TIP = 5805,
+    STR_SHORTCUT_WINDOWED_MODE_TOGGLE = 5806,
+    STR_NUMBER_RIDES = 5807,
+    STR_NUMBER_SHOPS_AND_STALLS = 5808,
+    STR_NUMBER_RESTROOMS_AND_INFORMATION_KIOSKS = 5809,
+    STR_CHEAT_DISABLE_TRAIN_LENGTH_LIMIT = 5810,
+    STR_CHEAT_DISABLE_TRAIN_LENGTH_LIMIT_TIP = 5811,
+    STR_SHORTCUT_SHOW_MULTIPLAYER = 5812,
+    STR_TRACK_LIST_NAME_FORMAT = 5813,
+    STR_TRACK_PREVIEW_NAME_FORMAT = 5814,
+    STR_SHOW_FPS_TIP = 5815,
+    STR_WINDOW_SCALE_TIP = 5816,
+    STR_SCALE_QUALITY_TIP = 5817,
+    STR_STEAM_OVERLAY_PAUSE_TIP = 5819,
+    STR_MINIMISE_FULLSCREEN_ON_FOCUS_LOSS_TIP = 5820,
+    STR_CYCLE_DAY_NIGHT_TIP = 5822,
+    STR_UPPERCASE_BANNERS_TIP = 5823,
+    STR_DISABLE_LIGHTNING_EFFECT_TIP = 5824,
+    STR_TRAP_MOUSE_TIP = 5825,
+    STR_INVERT_RIGHT_MOUSE_DRAG_TIP = 5826,
+    STR_CURRENT_THEME_TIP = 5827,
+    STR_DISTANCE_AND_SPEED_TIP = 5828,
+    STR_CURRENCY_TIP = 5829,
+    STR_LANGUAGE_TIP = 5830,
+    STR_TEMPERATURE_FORMAT_TIP = 5831,
+    STR_HEIGHT_LABELS_UNITS_TIP = 5832,
+    STR_DATE_FORMAT_TIP = 5833,
+    STR_AUDIO_DEVICE_TIP = 5834,
+    STR_AUDIO_FOCUS_TIP = 5835,
+    STR_TITLE_MUSIC_TIP = 5836,
+    STR_EDIT_THEMES_BUTTON_TIP = 5837,
+    STR_FINANCES_BUTTON_ON_TOOLBAR_TIP = 5838,
+    STR_RESEARCH_BUTTON_ON_TOOLBAR_TIP = 5839,
+    STR_CHEATS_BUTTON_ON_TOOLBAR_TIP = 5840,
+    STR_SHOW_RECENT_MESSAGES_ON_TOOLBAR_TIP = 5841,
+    STR_SCENARIO_GROUPING_TIP = 5842,
+    STR_SCENARIO_UNLOCKING_TIP = 5843,
+    STR_STAY_CONNECTED_AFTER_DESYNC_TIP = 5844,
+    STR_ENABLE_DEBUGGING_TOOLS_TIP = 5845,
+    STR_AUTOSAVE_FREQUENCY_TIP = 5846,
+    STR_TITLE_SEQUENCE_TIP = 5847,
+    STR_EDIT_TITLE_SEQUENCES_BUTTON_TIP = 5848,
+    STR_AUTO_STAFF_PLACEMENT_TIP = 5849,
+    STR_HANDYMEN_MOW_BY_DEFAULT_TIP = 5850,
+    STR_DEFAULT_INSPECTION_INTERVAL_TIP = 5851,
+    STR_SOUND_EFFECTS_TIP = 5853,
+    STR_RIDE_MUSIC_TIP = 5854,
+    STR_FULLSCREEN_MODE_TIP = 5855,
+    STR_DISPLAY_RESOLUTION_TIP = 5856,
+    STR_OPTIONS_TIP = 5857,
+    STR_HARDWARE_DISPLAY_TIP = 5858,
+    STR_UNCAP_FPS_TIP = 5859,
+    STR_SHORTCUT_PAINT_ORIGINAL = 5860,
+    STR_MULTIPLAYER_VERIFICATION_FAILURE = 5861,
+    STR_ALLOW_KNOWN_KEYS_ONLY = 5862,
+    STR_ALLOW_KNOWN_KEYS_ONLY_TIP = 5863,
+    STR_MULTIPLAYER_UNKNOWN_KEY_DISALLOWED = 5864,
+    STR_LOG_CHAT = 5865,
+    STR_LOG_CHAT_TIP = 5866,
+    STR_PROVIDER_NAME = 5867,
+    STR_PROVIDER_EMAIL = 5868,
+    STR_PROVIDER_WEBSITE = 5869,
+    STR_SHOW_SERVER_INFO_TIP = 5870,
+    STR_CHEAT_DISABLE_PLANT_AGING = 5871,
+    STR_CHEAT_DISABLE_PLANT_AGING_TIP = 5872,
+    STR_CHEAT_ENABLE_CHAIN_LIFT_ON_ALL_TRACK = 5873,
+    STR_CHEAT_ENABLE_CHAIN_LIFT_ON_ALL_TRACK_TIP = 5874,
+    STR_DRAWING_ENGINE = 5875,
+    STR_DRAWING_ENGINE_TIP = 5876,
+    STR_DRAWING_ENGINE_SOFTWARE = 5877,
+    STR_DRAWING_ENGINE_SOFTWARE_WITH_HARDWARE_DISPLAY = 5878,
+    STR_DRAWING_ENGINE_OPENGL = 5879,
+    STR_SELECTED_ONLY = 5880,
+    STR_NON_SELECTED_ONLY = 5881,
+    STR_CUSTOM_CURRENCY = 5882,
+    STR_CUSTOM_CURRENCY_WINDOW_TITLE = 5883,
+    STR_RATE = 5884,
+    STR_CUSTOM_CURRENCY_EQUIVALENCY = 5885,
+    STR_CURRENCY_SYMBOL_TEXT = 5886,
+    STR_PREFIX = 5887,
+    STR_SUFFIX = 5888,
+    STR_CUSTOM_CURRENCY_SYMBOL_INPUT_TITLE = 5889,
+    STR_CUSTOM_CURRENCY_SYMBOL_INPUT_DESC = 5890,
+    STR_LOADSAVE_DEFAULT = 5891,
+    STR_LOADSAVE_DEFAULT_TIP = 5892,
+    STR_RATE_INPUT_TITLE = 5893,
+    STR_RATE_INPUT_DESC = 5894,
+    STR_FILE_DIALOG_TITLE_SAVE_TRACK = 5895,
+    STR_TRACK_SAVE_FAILED = 5896,
+    STR_TRACK_LOAD_FAILED_ERROR = 5898,
+    STR_SHORTCUT_DEBUG_PAINT_TOGGLE = 5899,
+    STR_DEBUG_PAINT_USE_OLD_DRAWING = 5900,
+    STR_DEBUG_PAINT_SHOW_SEGMENT_HEIGHTS = 5901,
+    STR_DEBUG_PAINT_SHOW_BOUND_BOXES = 5902,
+    STR_DEBUG_DROPDOWN_DEBUG_PAINT = 5903,
+    STR_CHEAT_RESET_DATE = 5904,
+    STR_MAP_GENERATOR_TIP = 5905,
+    STR_ZOOM_TO_CURSOR = 5906,
+    STR_ZOOM_TO_CURSOR_TIP = 5907,
+    STR_CHEAT_ALLOW_ARBITRARY_RIDE_TYPE_CHANGES = 5908,
+    STR_CHEAT_ALLOW_ARBITRARY_RIDE_TYPE_CHANGES_TIP = 5909,
+    STR_APPLY = 5910,
+    STR_SEE_THROUGH_PATHS = 5911,
+    STR_SHORTCUT_SEE_THROUGH_PATHS_TOGGLE = 5912,
+    STR_CHAT = 5913,
+    STR_RIDE_DESCRIPTION_UNKNOWN = 5914,
+    STR_MULTIPLAYER_DEFAULT_NAME = 5915,
+    STR_MULTIPLAYER_PLAYER_COUNT = 5916,
+    STR_MULTIPLAYER_PLAYER_COUNT_PLURAL = 5917,
+    STR_SERVER_MAX_PLAYERS_VALUE = 5918,
+    STR_COMMA16 = 5919,
+    STR_RENDER_WEATHER_EFFECTS = 5920,
+    STR_RENDER_WEATHER_EFFECTS_TIP = 5921,
+    STR_MAX_VEHICLES_TIP = 5922,
+    STR_MAX_CARS_PER_TRAIN_TIP = 5923,
+    STR_TILE_INSPECTOR_GROUPBOX_SURFACE_INFO = 5924,
+    STR_TILE_INSPECTOR_GROUPBOX_PATH_INFO = 5925,
+    STR_TILE_INSPECTOR_GROUPBOX_TRACK_INFO = 5926,
+    STR_TILE_INSPECTOR_GROUPBOX_SCENERY_INFO = 5927,
+    STR_TILE_INSPECTOR_GROUPBOX_ENTRANCE_INFO = 5928,
+    STR_TILE_INSPECTOR_GROUPBOX_WALL_INFO = 5929,
+    STR_TILE_INSPECTOR_GROUPBOX_LARGE_SCENERY_INFO = 5930,
+    STR_TILE_INSPECTOR_GROUPBOX_BANNER_INFO = 5931,
+    STR_TILE_INSPECTOR_GROUPBOX_PROPERTIES = 5933,
+    STR_TILE_INSPECTOR_SURFACE_TERAIN = 5934,
+    STR_TILE_INSPECTOR_SURFACE_EDGE = 5935,
+    STR_TILE_INSPECTOR_SURFACE_OWNERSHIP = 5936,
+    STR_TILE_INSPECTOR_LAND_NOT_OWNED_AND_NOT_AVAILABLE = 5937,
+    STR_TILE_INSPECTOR_SURFACE_WATER_LEVEL = 5938,
+    STR_TILE_INSPECTOR_SURFACE_REMOVE_FENCES = 5939,
+    STR_TILE_INSPECTOR_SURFACE_RESTORE_FENCES = 5940,
+    STR_TILE_INSPECTOR_BASE_HEIGHT_FULL = 5941,
+    STR_TILE_INSPECTOR_PATH_NAME = 5942,
+    STR_TILE_INSPECTOR_PATH_ADDITIONS = 5943,
+    STR_TILE_INSPECTOR_PATH_ADDITIONS_NONE = 5944,
+    STR_TILE_INSPECTOR_PATH_CONNECTED_EDGES = 5945,
+    STR_TILE_INSPECTOR_TRACK_RIDE_TYPE = 5946,
+    STR_TILE_INSPECTOR_TRACK_RIDE_ID = 5947,
+    STR_TILE_INSPECTOR_TRACK_RIDE_NAME = 5948,
+    STR_TILE_INSPECTOR_TRACK_CHAIN_LIFT = 5949,
+    STR_TILE_INSPECTOR_TRACK_ENTIRE_TRACK_PIECE = 5950,
+    STR_TILE_INSPECTOR_TRACK_PIECE_ID = 5951,
+    STR_TILE_INSPECTOR_TRACK_SEQUENCE = 5952,
+    STR_TILE_INSPECTOR_SORT_TIP = 5953,
+    STR_TILE_INSPECTOR_SCENERY_AGE = 5954,
+    STR_TILE_INSPECTOR_SCENERY_QUADRANT = 5955,
+    STR_TILE_INSPECTOR_SCENERY_QUADRANT_SW = 5956,
+    STR_TILE_INSPECTOR_SCENERY_QUADRANT_NW = 5957,
+    STR_TILE_INSPECTOR_SCENERY_QUADRANT_NE = 5958,
+    STR_TILE_INSPECTOR_SCENERY_QUADRANT_SE = 5959,
+    STR_TILE_INSPECTOR_SCENERY_QUADRANT_LABEL = 5960,
+    STR_TILE_INSPECTOR_SCENERY_ENTRY_IDX = 5961,
+    STR_TILE_INSPECTOR_COLLISSION = 5962,
+    STR_TILE_INSPECTOR_SURFACE_CORNERS = 5963,
+    STR_TILE_INSPECTOR_SURFACE_DIAGONAL = 5964,
+    STR_TILE_INSPECTOR_ENTRANCE_TYPE = 5965,
+    STR_TILE_INSPECTOR_ENTRANCE_PART = 5966,
+    STR_TILE_INSPECTOR_ENTRANCE_MIDDLE = 5967,
+    STR_TILE_INSPECTOR_ENTRANCE_LEFT = 5968,
+    STR_TILE_INSPECTOR_ENTRANCE_RIGHT = 5969,
+    STR_TILE_INSPECTOR_ENTRANCE_ENTRANCE_ID = 5970,
+    STR_TILE_INSPECTOR_ENTRANCE_EXIT_ID = 5971,
+    STR_TILE_INSPECTOR_ENTRANCE_RIDE_ID = 5972,
+    STR_TILE_INSPECTOR_CLAMP_TO_NEXT = 5973,
+    STR_TILE_INSPECTOR_CLAMP_TO_NEXT_TIP = 5974,
+    STR_TILE_INSPECTOR_WALL_SLOPE = 5975,
+    STR_TILE_INSPECTOR_WALL_FLAT = 5976,
+    STR_TILE_INSPECTOR_WALL_SLOPED_LEFT = 5977,
+    STR_TILE_INSPECTOR_WALL_SLOPED_RIGHT = 5978,
+    STR_TILE_INSPECTOR_WALL_TYPE = 5979,
+    STR_TILE_INSPECTOR_ENTRY_BANNER_TEXT = 5980,
+    STR_TILE_INSPECTOR_ENTRY_BANNER_NONE = 5981,
+    STR_TILE_INSPECTOR_LARGE_SCENERY_TYPE = 5982,
+    STR_TILE_INSPECTOR_LARGE_SCENERY_PIECE_ID = 5983,
+    STR_TILE_INSPECTOR_BANNER_BLOCKED_PATHS = 5984,
+    STR_FILEBROWSER_ACTION_NEW_FOLDER = 5985,
+    STR_FILEBROWSER_FOLDER_NAME_PROMPT = 5986,
+    STR_UNABLE_TO_CREATE_FOLDER = 5987,
+    STR_NO_LAND_RIGHTS_FOR_SALE_TIP = 5988,
+    STR_NO_CONSTRUCTION_RIGHTS_FOR_SALE_TIP = 5989,
+    STR_NO_LAND_OR_CONSTRUCTION_RIGHTS_FOR_SALE_TIP = 5990,
+    STR_CANT_PASTE = 5991,
+    STR_TILE_ELEMENT_LIMIT_REACHED = 5992,
+    STR_TILE_INSPECTOR_COPY_TIP = 5993,
+    STR_TILE_INSPECTOR_PASTE_TIP = 5994,
+    STR_BOOSTER = 5995,
+    STR_RIDE_CONSTRUCTION_BOOSTER_SPEED = 5996,
+
+    STR_ADD_SET_MONEY = 5997,
+    STR_ADD_MONEY = 5998,
+    STR_SET_MONEY = 5999,
+    STR_ENTER_NEW_VALUE = 6000,
+
+    STR_ENABLE_LIGHTING_EFFECTS = 6001,
+    STR_ENABLE_LIGHTING_EFFECTS_TIP = 6002,
+
+    STR_VIEW_CLIPPING_MENU = 6003,
+    STR_VIEW_CLIPPING_TITLE = 6004,
+    STR_VIEW_CLIPPING_HEIGHT_ENABLE = 6005,
+    STR_VIEW_CLIPPING_HEIGHT_ENABLE_TIP = 6006,
+    STR_VIEW_CLIPPING_HEIGHT_VALUE = 6007,
+    STR_VIEW_CLIPPING_HEIGHT_VALUE_TOGGLE = 6008,
+    STR_VIEW_CLIPPING_HEIGHT_SCROLL_TIP = 6009,
+    STR_UNIT2DP_SUFFIX_METRES = 6010,
+    STR_UNIT1DP_SUFFIX_FEET = 6011,
+    STR_UNIT1DP_NO_SUFFIX = 6012,
+    STR_RIDE_INCOME_ADMISSION_PAY_FOR_ENTRY_TIP = 6013,
+    STR_ADMISSION_PRICE_PAY_PER_RIDE_TIP = 6014,
+    STR_TILE_INSPECTOR_PATH_SLOPED = 6015,
+    STR_ACTION_MODIFY_TILE = 6016,
+    STR_NETWORK_ACTION_RATE_LIMIT_MESSAGE = 6017,
+    STR_SHORTCUT_CONSTRUCTION_TURN_LEFT = 6018,
+    STR_SHORTCUT_CONSTRUCTION_TURN_RIGHT = 6019,
+    STR_SHORTCUT_CONSTRUCTION_USE_TRACK_DEFAULT = 6020,
+    STR_SHORTCUT_CONSTRUCTION_SLOPE_DOWN = 6021,
+    STR_SHORTCUT_CONSTRUCTION_SLOPE_UP = 6022,
+    STR_SHORTCUT_CONSTRUCTION_CHAIN_LIFT_TOGGLE = 6023,
+    STR_SHORTCUT_CONSTRUCTION_BANK_LEFT = 6024,
+    STR_SHORTCUT_CONSTRUCTION_BANK_RIGHT = 6025,
+    STR_SHORTCUT_CONSTRUCTION_PREVIOUS_TRACK = 6026,
+    STR_SHORTCUT_CONSTRUCTION_NEXT_TRACK = 6027,
+    STR_SHORTCUT_CONSTRUCTION_BUILD_CURRENT = 6028,
+    STR_SHORTCUT_CONSTRUCTION_DEMOLISH_CURRENT = 6029,
+
+    STR_SCENERY_EYEDROPPER_TIP = 6030,
+
+    STR_SERVER_DESCRIPTION = 6031,
+    STR_SERVER_GREETING = 6032,
+
+    STR_PATH_TO_RCT1 = 6033,
+    STR_STRING_TOOLTIP = 6034,
+    STR_PATH_TO_RCT1_BROWSER = 6035,
+    STR_PATH_TO_RCT1_CLEAR_TIP = 6036,
+    STR_PATH_TO_RCT1_WRONG_ERROR = 6037,
+    STR_PATH_TO_RCT1_TIP = 6038,
+
+    STR_QUICK_DEMOLISH_RIDE = 6039,
+
+    STR_ACTION_EDIT_SCENARIO_OPTIONS = 6040,
+
+    STR_NO_MECHANICS_ARE_HIRED_MESSAGE = 6041,
+
+    STR_FILE_DIALOG_TITLE_LOAD_HEIGHTMAP = 6042,
+    STR_MAPGEN_SELECT_HEIGHTMAP = 6043,
+    STR_MAPGEN_SMOOTH_HEIGHTMAP = 6044,
+    STR_MAPGEN_SMOOTH_STRENGTH = 6045,
+    STR_MAPGEN_NORMALIZE = 6046,
+    STR_MAPGEN_SMOOTH_TILE = 6047,
+    STR_HEIGHT_MAP_ERROR = 6048,
+    STR_ERROR_READING_PNG = 6049,
+    STR_ERROR_READING_BITMAP = 6050,
+    STR_ERROR_WIDTH_AND_HEIGHT_DO_NOT_MATCH = 6051,
+    STR_ERROR_HEIHGT_MAP_TOO_BIG = 6052,
+    STR_ERROR_CANNOT_NORMALIZE = 6053,
+    STR_ERROR_24_BIT_BITMAP = 6054,
+    STR_OPENRCT2_HEIGHTMAP_FILE = 6055,
+
+    STR_TOOLBAR_MUTE_TIP = 6056,
+    STR_MUTE_BUTTON_ON_TOOLBAR_TIP = 6057,
+    STR_MUTE_BUTTON_ON_TOOLBAR = 6058,
+
+    STR_RIGHTGUILLEMET = 6059,
+
+    STR_SHOW_GUEST_PURCHASES = 6060,
+    STR_SHOW_GUEST_PURCHASES_TIP = 6061,
+    STR_MONEY_EFFECT_RECEIVE_HIGHP = 6062,
+    STR_MONEY_EFFECT_SPEND_HIGHP = 6063,
+
+    STR_CHEAT_OWN_ALL_LAND = 6064,
+
+    STR_LOG_SERVER_ACTIONS = 6065,
+    STR_LOG_SERVER_ACTIONS_TIP = 6066,
+    STR_LOG_SERVER_STARTED = 6067,
+    STR_LOG_SERVER_STOPPED = 6068,
+    STR_LOG_PLAYER_KICKED = 6069,
+    STR_LOG_SET_PLAYER_GROUP = 6070,
+    STR_LOG_ADD_PLAYER_GROUP = 6071,
+    STR_LOG_REMOVE_PLAYER_GROUP = 6072,
+    STR_LOG_EDIT_PLAYER_GROUP_PERMISSIONS = 6073,
+    STR_LOG_EDIT_PLAYER_GROUP_NAME = 6074,
+    STR_LOG_EDIT_DEFAULT_PLAYER_GROUP = 6075,
+    STR_LOG_CHEAT_USED = 6076,
+    STR_LOG_CHEAT_ADD_MONEY = 6077,
+    STR_LOG_CREATE_RIDE = 6078,
+    STR_LOG_DEMOLISH_RIDE = 6079,
+    STR_LOG_RIDE_APPEARANCE = 6080,
+    STR_LOG_RIDE_STATUS_CLOSED = 6081,
+    STR_LOG_RIDE_STATUS_OPEN = 6082,
+    STR_LOG_RIDE_STATUS_TESTING = 6083,
+    STR_LOG_RIDE_VEHICLES = 6084,
+    STR_LOG_RIDE_SETTINGS = 6085,
+    STR_LOG_RIDE_NAME = 6086,
+    STR_LOG_RIDE_PRICE = 6087,
+    STR_LOG_RIDE_SECONDARY_PRICE = 6088,
+    STR_LOG_PARK_NAME = 6089,
+    STR_LOG_PARK_CLOSED = 6090,
+    STR_LOG_PARK_OPEN = 6091,
+    STR_LOG_PARK_ENTRANCE_FEE = 6092,
+    STR_LOG_PLACE_SCENERY = 6093,
+    STR_LOG_REMOVE_SCENERY = 6094,
+    STR_LOG_EDIT_SCENERY = 6095,
+    STR_LOG_SET_SIGN_NAME = 6096,
+    STR_LOG_PLACE_TRACK = 6097,
+    STR_LOG_REMOVE_TRACK = 6098,
+    STR_LOG_CLIENT_STARTED = 6099,
+    STR_LOG_CLIENT_STOPPED = 6100,
+    STR_CHEAT_DISABLE_RIDE_VALUE_AGING = 6101,
+    STR_CHEAT_DISABLE_RIDE_VALUE_AGING_TIP = 6102,
+    STR_OPTION_DISABLED_DURING_NETWORK_PLAY = 6103,
+
+    STR_RIDE_NAME_HYPERCOASTER = 6105,
+    STR_RIDE_NAME_MONSTER_TRUCKS = 6107,
+    STR_RIDE_NAME_HYPER_TWISTER = 6109,
+    STR_RIDE_NAME_CLASSIC_MINI_ROLLER_COASTER = 6111,
+    STR_RIDE_DESCRIPTION_HYPERCOASTER = 6113,
+    STR_RIDE_DESCRIPTION_MONSTER_TRUCKS_GROUP = 6115,
+    STR_RIDE_DESCRIPTION_TWISTER_ROLLER_COASTER = 6116,
+    STR_RIDE_DESCRIPTION_CLASSIC_MINI_COASTER = 6119,
+
+    STR_NEWS_ITEM_RESEARCH_NEW_VEHICLE_AVAILABLE = 6120,
+
+    STR_CHEAT_OWN_ALL_LAND_TIP = 6121,
+
+    STR_NOT_ENOUGH_ROLLER_COASTERS = 6122,
+
+    STR_OBJECT_LOAD_ERROR_TITLE = 6123,
+    STR_OBJECT_NAME = 6124,
+    STR_OBJECT_TYPE = 6125,
+    STR_UNKNOWN_OBJECT_TYPE = 6126,
+    STR_OBJECT_ERROR_WINDOW_FILE = 6127,
+    STR_OBJECT_ERROR_WINDOW_EXPLANATION = 6128,
+    STR_COPY_SELECTED = 6129,
+    STR_COPY_ALL = 6130,
+    STR_OBJECT_SOURCE = 6131,
+
+    STR_CHEAT_IGNORE_RESEARCH_STATUS = 6132,
+    STR_CHEAT_IGNORE_RESEARCH_STATUS_TIP = 6133,
+
+    STR_SHORTCUT_CLEAR_SCENERY = 6134,
+
+    STR_MULTIPLAYER_CLIENT_INVALID_REQUEST = 6135,
+    STR_MULTIPLAYER_SERVER_INVALID_REQUEST = 6136,
+
+    STR_ABOUT_OPENRCT2_DESCRIPTION = 6137,
+    STR_ABOUT_OPENRCT2_DESCRIPTION_2 = 6138,
+    STR_ABOUT_OPENRCT2_DESCRIPTION_3 = 6139,
+
+    STR_CHANGELOG_ELLIPSIS = 6140,
+
+    STR_THEMES_OPTION_RCT1_BOTTOM_TOOLBAR = 6141,
+
+    STR_TRACK_DESIGN_NAME = 6142,
+    STR_TRACK_DESIGN_TYPE = 6143,
+
+    STR_DEBUG_PAINT_SHOW_DIRTY_VISUALS = 6144,
+
+    STR_RIDE_CONSTRUCTION_BOOSTER_SPEED_LIMIT_TIP = 6145,
+
+    STR_CHEAT_ENABLE_ALL_DRAWABLE_TRACK_PIECES = 6146,
+    STR_CHEAT_ENABLE_ALL_DRAWABLE_TRACK_PIECES_TIP = 6147,
+
+    STR_SERVER_LIST_CONNECTING = 6148,
+    STR_SERVER_LIST_NO_CONNECTION = 6149,
+    STR_SERVER_LIST_INVALID_RESPONSE_JSON_NUMBER = 6150,
+    STR_SERVER_LIST_MASTER_SERVER_FAILED = 6151,
+    STR_SERVER_LIST_INVALID_RESPONSE_JSON_ARRAY = 6152,
+
+    STR_PAID_ENTRY_PAID_RIDES = 6153,
+
+    STR_ADMIN_NOT_RECOMMENDED = 6154,
+    STR_MISSING_DIALOG_APPLICATION_ERROR = 6155,
+
+    STR_ERROR_RESERVED_NAME = 6156,
+
+    STR_CONSOLE = 6157,
+
+    STR_FAILED_TO_LOAD_IMCOMPATIBLE_RCTC_FLAG = 6158,
+
+    STR_SCALING_QUALITY_SMOOTH_NN = 6159,
+
+    STR_AVAILABLE_VEHICLES = 6160,
+
+    STR_SHORTCUT_GRIDLINES_DISPLAY_TOGGLE = 6161,
+
+    STR_SPINNING_WILD_MOUSE_GROUP = 6162,
+    STR_SPINNING_WILD_MOUSE_GROUP_DESC = 6163,
+
+    STR_CLOSE_X_WHITE = 6164,
+
+    STR_USE_VSYNC = 6165,
+    STR_USE_VSYNC_TIP = 6166,
+
+    STR_OPTIONS_ADVANCED = 6167,
+    STR_OPTIONS_TITLE_SEQUENCE = 6168,
+    STR_OPTIONS_SCENARIO_SELECTION = 6169,
+    STR_OPTIONS_TWEAKS = 6170,
+
+    STR_GUESTS_FILTER_BY_NAME = 6171,
+    STR_GUESTS_FILTER_BY_NAME_TIP = 6172,
+    STR_GUESTS_ENTER_NAME_TO_SEARCH = 6173,
+
+    STR_TITLE_EDITOR_ACTION_LOAD_SAVE = 6174,
+    STR_TITLE_EDITOR_ACTION_LOAD_SCENARIO = 6175,
+    STR_TITLE_EDITOR_ARGUMENT_SCENARIO = 6176,
+    STR_TITLE_EDITOR_COMMAND_LOAD_NO_SCENARIO = 6177,
+    STR_TITLE_EDITOR_COMMAND_LOAD_MISSING_SCENARIO = 6178,
+    STR_TITLE_COMMAND_EDITOR_ACTION_SELECT_SCENARIO = 6179,
+    STR_TITLE_COMMAND_EDITOR_NO_SCENARIO_SELECTED = 6180,
+    STR_TITLE_COMMAND_EDITOR_MISSING_SCENARIO = 6181,
+
+    STR_TITLE_EDITOR_COMMAND_FOLLOW = 6182,
+    STR_TITLE_EDITOR_COMMAND_FOLLOW_NO_SPRITE = 6183,
+    STR_TITLE_EDITOR_COMMAND_TYPE_FOLLOW = 6184,
+    STR_TITLE_COMMAND_EDITOR_SELECT_SPRITE = 6185,
+    STR_TITLE_COMMAND_EDITOR_FOLLOW_NO_SPRITE = 6186,
+    STR_TITLE_COMMAND_EDITOR_FORMAT_SPRITE_NAME = 6187,
+    STR_LITTER_VOMIT = 6188,
+    STR_DUCK = 6189,
+    STR_TITLE_COMMAND_EDITOR_SELECT_SPRITE_TOOLTIP = 6190,
+
+    STR_TILE_INSPECTOR_SURFACE = 6191,
+    STR_TILE_INSPECTOR_WALL = 6192,
+
+    STR_BOTTOM_TOOLBAR_NUM_GUESTS_STABLE_SINGULAR = 6193,
+    STR_BOTTOM_TOOLBAR_NUM_GUESTS_DECREASE_SINGULAR = 6194,
+    STR_BOTTOM_TOOLBAR_NUM_GUESTS_INCREASE_SINGULAR = 6195,
+
+    STR_YEAR = 6196,
+    STR_MONTH = 6197,
+    STR_DAY = 6198,
+    STR_DATE_SET = 6199,
+    STR_DATE_RESET = 6200,
+    STR_FORMAT_MONTH = 6201,
+
+    STR_VIRTUAL_FLOOR_STYLE = 6202,
+    STR_VIRTUAL_FLOOR_STYLE_TIP = 6203,
+
+    STR_CHEAT_GROUP_CONSTRUCTION = 6215,
+    STR_CHEAT_GROUP_OPERATION = 6216,
+    STR_CHEAT_GROUP_AVAILABILITY = 6217,
+
+    STR_OBJECT_FILTER_OPENRCT2_OFFICIAL = 6218,
+
+    STR_HIGHLIGHT_PATH_ISSUES_MENU = 6219,
+
+    STR_TILE_INSPECTOR_ENTRANCE_MAKE_USABLE = 6220,
+    STR_TILE_INSPECTOR_ENTRANCE_MAKE_USABLE_TIP = 6221,
+
+    STR_ERR_CANT_PLACE_PEEP_SPAWN_HERE = 6222,
+    STR_ERR_MUST_BE_OUTSIDE_PARK_BOUNDARIES = 6223,
+    STR_LOG_PLACE_PEEP_SPAWN = 6224,
+
+    STR_NOT_SUPPPORTED_IN_OPENGL = 6225,
+
+    STR_ALLOW_EARLY_COMPLETION = 6226,
+    STR_EARLY_COMPLETION_TIP = 6227,
+    STR_SCENARIO_OPTIONS = 6228,
+
+    STR_WINDOW_COLOUR_2_STRINGID_STRINGID = 6229,
+    STR_INVENTIONS_LIST_RIDE_AND_VEHICLE_NAME = 6230,
+    STR_INVENTIONS_LIST_RIDE_AND_VEHICLE_NAME_DRAG = 6231,
+
+    STR_FROZEN = 6232,
+
+    STR_SHORTCUT_VIEW_CLIPPING = 6233,
+    STR_SHORTCUT_HIGHLIGHT_PATH_ISSUES_TOGGLE = 6234,
+
+    STR_MULTIPLAYER_INFORMATION_TITLE = 6235,
+    STR_MULTIPLAYER_PLAYERS_TITLE = 6236,
+    STR_MULTIPLAYER_GROUPS_TITLE = 6237,
+    STR_MULTIPLAYER_OPTIONS_TITLE = 6238,
+
+    STR_VIEW_CLIPPING_VERTICAL_CLIPPING = 6239,
+    STR_VIEW_CLIPPING_HORIZONTAL_CLIPPING = 6240,
+    STR_VIEW_CLIPPING_SELECT_AREA = 6241,
+    STR_VIEW_CLIPPING_CLEAR_SELECTION = 6242,
+
+    STR_REFURBISH_RIDE_TIP = 6243,
+    STR_CANT_REFURBISH_RIDE = 6244,
+    STR_CANT_REFURBISH_NOT_NEEDED = 6245,
+    STR_REFURBISH = 6246,
+    STR_REFURBISH_RIDE = 6247,
+    STR_REFURBISH_RIDE_ID_MONEY = 6248,
+    STR_REFURBISH_RIDE_ID_NO_MONEY = 6249,
+    STR_DEMOLISH_RIDE_ID_MONEY = 6250,
+    STR_RIDE_NOT_YET_EMPTY = 6251,
+
+    STR_INVALID_URL = 6255,
+
+    STR_EFFECTS_GROUP = 6256,
+    STR_VIRTUAL_FLOOR_STYLE_GLASSY = 6257,
+    STR_VIRTUAL_FLOOR_STYLE_TRANSPARENT = 6258,
+    STR_VIRTUAL_FLOOR_STYLE_DISABLED = 6259,
+
+    STR_DEBUG_PAINT_SHOW_BLOCKED_TILES = 6260,
+    STR_DEBUG_PAINT_SHOW_WIDE_PATHS = 6261,
+
+    STR_MASTER_VOLUME = 6262,
+    STR_MASTER_VOLUME_TIP = 6263,
+
+    STR_ALWAYS_NATIVE_LOADSAVE = 6264,
+    STR_ALWAYS_NATIVE_LOADSAVE_TIP = 6265,
+
+    STR_OPEN_USER_CONTENT_FOLDER = 6266,
+
+    STR_SHORTCUT_OPEN_TILE_INSPECTOR = 6267,
+
+    STR_ADVANCE_TO_NEXT_TICK = 6268,
+
+    STR_INVALID_CLIMATE_ID = 6269,
+
+    STR_OBJECT_SELECTION_TERRAIN_SURFACES = 6270,
+    STR_OBJECT_SELECTION_TERRAIN_EDGES = 6271,
+    STR_OBJECT_SELECTION_STATIONS = 6272,
+    STR_OBJECT_SELECTION_MUSIC = 6273,
+
+    STR_CANT_SET_COLOUR_SCHEME = 6274,
+
+    STR_STATION_STYLE = 6275,
+    STR_GUESTS_GETTING_STUCK_ON_RIDE = 6276,
+
+    STR_TILE_INSPECTOR_STATION_INDEX = 6277,
+
+    STR_AUTOSAVE_AMOUNT = 6278,
+    STR_AUTOSAVE_AMOUNT_TIP = 6279,
+
+    STR_TOOLBAR_CHAT_TIP = 6280,
+    STR_CHAT_BUTTON_ON_TOOLBAR_TIP = 6281,
+    STR_CHAT_BUTTON_ON_TOOLBAR = 6282,
+    STR_CHAT_UNAVAILABLE = 6283,
+
+    STR_SIZE_BYTE = 6293,
+    STR_SIZE_KILOBYTE = 6294,
+    STR_SIZE_MEGABYTE = 6295,
+    STR_SIZE_GIGABYTE = 6296,
+    STR_SIZE_TERABYTE = 6297,
+
+    STR_NETWORK_SPEED_SEC = 6298,
+
+    STR_DOWNLOAD_ALL = 6299,
+    STR_DOWNLOAD_ALL_TIP = 6300,
+    STR_COPY_SELECTED_TIP = 6301,
+    STR_COPY_ALL_TIP = 6302,
+    STR_DOWNLOADING_OBJECTS = 6303,
+
+    STR_SHORTCUT_OPEN_SCENERY_PICKER = 6304,
+
+    STR_MULTITHREADING = 6305,
+    STR_MULTITHREADING_TIP = 6306,
+
+    STR_TILE_INSPECTOR_COLOUR_SCHEME = 6307,
+    STR_TILE_INSPECTOR_TRACK_BLOCK_BRAKE = 6319,
+    STR_TILE_INSPECTOR_TRACK_IS_INDESTRUCTIBLE = 6320,
+    STR_TILE_INSPECTOR_PATH_BROKEN = 6321,
+
+    STR_MAP_TOOLTIP_BANNER_STRINGID_STRINGID = 6308,
+
+    STR_MULTIPLAYER_RECONNECT = 6309,
+
+    STR_PEEP_DEBUG_POSITION = 6310,
+    STR_PEEP_DEBUG_NEXT = 6311,
+    STR_PEEP_DEBUG_NEXT_SURFACE = 6312,
+    STR_PEEP_DEBUG_NEXT_SLOPE = 6313,
+    STR_PEEP_DEBUG_DEST = 6314,
+    STR_PEEP_DEBUG_PATHFIND_GOAL = 6315,
+    STR_PEEP_DEBUG_PATHFIND_HISTORY = 6316,
+    STR_PEEP_DEBUG_PATHFIND_HISTORY_ITEM = 6317,
+    STR_PEEP_DEBUG_SPRITE_INDEX = 6322,
+
+    STR_DESYNC_REPORT = 6318,
+
+    STR_SIMULATING = 6323,
+    STR_SIMULATE_RIDE = 6324,
+    STR_SIMULATE_RIDE_TIP = 6325,
+    STR_CANT_SIMULATE = 6326,
+
+    STR_TRANSPARENT_SCREENSHOT = 6327,
+    STR_TRANSPARENT_SCREENSHOT_TIP = 6328,
+
+    STR_STRING_STRINGID = 6329,
+    STR_DOWNLOADING_OBJECTS_FROM = 6330,
+
+    STR_CREATE_DUCKS = 6331,
+    STR_REMOVE_DUCKS = 6332,
+    STR_SHORTCUT_SCALE_UP = 6333,
+    STR_SHORTCUT_SCALE_DOWN = 6334,
+
+    STR_SHORTCUT_COPY_ELEMENT = 6336,
+    STR_SHORTCUT_PASTE_ELEMENT = 6337,
+    STR_SHORTCUT_REMOVE_ELEMENT = 6338,
+    STR_SHORTCUT_MOVE_ELEMENT_UP = 6339,
+    STR_SHORTCUT_MOVE_ELEMENT_DOWN = 6340,
+    STR_SHORTCUT_INCREASE_X_COORD = 6341,
+    STR_SHORTCUT_DECREASE_X_COORD = 6342,
+    STR_SHORTCUT_INCREASE_Y_COORD = 6343,
+    STR_SHORTCUT_DECREASE_Y_COORD = 6344,
+    STR_SHORTCUT_INCREASE_ELEM_HEIGHT = 6345,
+    STR_SHORTCUT_DECREASE_ELEM_HEIGHT = 6346,
+
+    STR_CANNOT_BUILD_PATH_ADDITIONS_ON_LEVEL_CROSSINGS = 6347,
+    STR_REMOVE_LEVEL_CROSSING_FIRST = 6348,
+
+    STR_OPTIONS_RANDOM_TITLE_SEQUENCE = 6349,
+
+    STR_SCENERY_SCATTER = 6350,
+    STR_THEMES_WINDOW_SCENERY_SCATTER = 6351,
+    STR_SCATTER_TOOL_DENSITY = 6352,
+    STR_SCATTER_TOOL_DENSITY_LOW = 6353,
+    STR_SCATTER_TOOL_DENSITY_MEDIUM = 6354,
+    STR_SCATTER_TOOL_DENSITY_HIGH = 6355,
+
+    STR_CREATE_DUCKS_TIP = 6356,
+    STR_REMOVE_DUCKS_TIP = 6357,
+
+    STR_PAGE_X = 6358,
+    STR_ARG_4_PAGE_X = 6359,
+
+    STR_GRAPH_AXIS_LABEL = 6360,
+
+    STR_ENABLE_LIGHTING_VEHICLES = 6361,
+    STR_ENABLE_LIGHTING_VEHICLES_TIP = 6362,
+
+    STR_COPY_INPUT_TO_CLIPBOARD = 6363,
+
+    STR_X_PERSON_DIED_ON_X = 6364,
+
+    STR_NOTIFICATION_RIDE_CASUALTIES = 6365,
+    STR_NOTIFICATION_RIDE_VEHICLE_STALLED = 6366,
+
+    STR_TILE_INSPECTOR_WALL_ANIMATION_FRAME = 6367,
+
+    STR_WINE_NOT_RECOMMENDED = 6368,
+    STR_CHEAT_ALLOW_TRACK_PLACE_INVALID_HEIGHTS = 6369,
+    STR_CHEAT_ALLOW_TRACK_PLACE_INVALID_HEIGHTS_TIP = 6370,
+
+    STR_PATH_TO_RCT1_DOES_NOT_CONTAIN_CSG1I_DAT = 6371,
+    STR_PATH_TO_RCT1_IS_WRONG_VERSION = 6372,
+
+    STR_SHORTCUT_TOGGLE_CLEARANCE_CHECKS = 6373,
+    STR_OVERLAY_CLEARANCE_CHECKS_DISABLED = 6374,
+
+    STR_UNKNOWN_RIDE = 6375,
+
+    STR_RESEARCH_VEHICLE_LABEL = 6376,
+    STR_RESEARCH_TYPE_LABEL_VEHICLE = 6377,
+
+    STR_MULTIPLAYER_RECEIVING_OBJECTS_LIST = 6378,
+
+    STR_MULTIPLAYER_RECEIVED_INVALID_DATA = 6379,
+
+    STR_UPDATE_AVAILABLE = 6380,
+    STR_JOIN_DISCORD = 6381,
+    STR_NEW_RELEASE_VERSION_INFO = 6382,
+    STR_NEW_RELEASE_DOWNLOAD_PAGE = 6383,
+
+    STR_SNOW = 6384,
+    STR_HEAVY_SNOW = 6385,
+    STR_BLIZZARD = 6386,
+
+    STR_CANT_LOWER_ELEMENT_HERE = 6387,
+    STR_CANT_RAISE_ELEMENT_HERE = 6388,
+    STR_NO_CLEARANCE = 6389,
+
+    STR_NEEDS_RCT2_FILES = 6390,
+    STR_PICK_RCT2_DIR = 6391,
+    STR_COULD_NOT_FIND_AT_PATH = 6392,
+
+    STR_CHEATS_MENU_OBJECTIVE_OPTIONS = 6393,
+    STR_CHEAT_OBJECTIVE_GROUP = 6394,
+    STR_CHEAT_MAINTENANCE_GROUP = 6395,
+
+    STR_DISABLE_SCREENSAVER = 6396,
+    STR_DISABLE_SCREENSAVER_TIP = 6397,
+
+    STR_FILE_CONTAINS_UNSUPPORTED_RIDE_TYPES = 6398,
+
+    STR_NEEDS_RCT2_FILES_MANUAL = 6399,
+
+    STR_OWN_ON_GOG = 6400,
+    STR_INSTALLED_ON_HDD = 6401,
+    STR_OPENRCT2_SETUP = 6402,
+    STR_WHICH_APPLIES_BEST = 6403,
+    STR_PLEASE_SELECT_GOG_INSTALLER = 6404,
+    STR_SELECT_GOG_INSTALLER = 6405,
+    STR_GOG_INSTALLER = 6406,
+    STR_THIS_WILL_TAKE_A_FEW_MINUTES = 6407,
+    STR_INSTALL_INNOEXTRACT = 6408,
+    STR_NOT_THE_GOG_INSTALLER = 6409,
+
+    STR_ZOOM_BUTTON_ON_TOOLBAR = 6410,
+    STR_ZOOM_BUTTON_ON_TOOLBAR_TIP = 6411,
+
+    STR_SHORTCUT_NUMPAD_RETURN = 6412,
+
+    STR_SHORTCUT_MOD_SHIFT = 6413,
+    STR_SHORTCUT_MOD_LSHIFT = 6414,
+    STR_SHORTCUT_MOD_RSHIFT = 6415,
+    STR_SHORTCUT_MOD_CTRL = 6416,
+    STR_SHORTCUT_MOD_LCTRL = 6417,
+    STR_SHORTCUT_MOD_RCTRL = 6418,
+    STR_SHORTCUT_MOD_ALT = 6419,
+    STR_SHORTCUT_MOD_LALT = 6420,
+    STR_SHORTCUT_MOD_RALT = 6421,
+    STR_SHORTCUT_MOD_GUI = 6422,
+    STR_SHORTCUT_MOD_LGUI = 6423,
+    STR_SHORTCUT_MOD_RGUI = 6424,
+
+    STR_SHORTCUT_JOY_LEFT = 6425,
+    STR_SHORTCUT_JOY_RIGHT = 6426,
+    STR_SHORTCUT_JOY_UP = 6427,
+    STR_SHORTCUT_JOY_DOWN = 6428,
+    STR_SHORTCUT_JOY_NUMBER = 6429,
+
+    STR_SHORTCUT_MOUSE_LEFT = 6430,
+    STR_SHORTCUT_MOUSE_RIGHT = 6431,
+    STR_SHORTCUT_MOUSE_NUMBER = 6432,
+
+    STR_SHORTCUT_REMOVE = 6433,
+    STR_SHORTCUT_REMOVE_TIP = 6434,
+
+    STR_STAFF_STAT_VANDALS_STOPPED = 6435,
+
+    STR_TILE_INSPECTOR_TOGGLE_INVISIBILITY_TIP = 6436,
+    STR_TILE_INSPECTOR_FLAG_INVISIBLE = 6437,
+    STR_TILE_INSPECTOR_INVISIBLE_SHORT = 6438,
+    STR_SHORTCUT_TOGGLE_INVISIBILITY = 6439,
+
+
+
+};
+# 19 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Localisation.h" 2
+
+
+
+std::string format_string(rct_string_id format, const void* args);
+void format_string(char* dest, size_t size, rct_string_id format, const void* args);
+void format_string_to_upper(char* dest, size_t size, rct_string_id format, const void* args);
+void generate_string_file();
+
+
+
+
+void format_readable_size(char* buf, size_t bufSize, uint64_t sizeBytes);
+
+
+
+
+void format_readable_speed(char* buf, size_t bufSize, uint64_t sizeBytesPerSec);
+
+utf8* get_string_end(const utf8* text);
+size_t get_string_size(const utf8* text);
+
+
+
+money32 string_to_money(const char* string_to_monetise);
+void money_to_string(money32 amount, char* buffer_to_put_value_to, size_t buffer_len, bool forceDecimals);
+
+bool is_user_string_id(rct_string_id stringId);
+# 56 "/home/ted/dev/openrct2/src/openrct2/core/../localisation/Localisation.h"
+extern const char real_name_initials[16];
+extern const char* real_names[1024];
+
+extern thread_local char gCommonStringFormatBuffer[512];
+extern bool gDebugStringFormatting;
+
+extern const rct_string_id SpeedNames[5];
+extern const rct_string_id ObjectiveNames[12];
+extern const rct_string_id ResearchFundingLevelNames[4];
+extern const rct_string_id MarketingCampaignNames[ADVERTISING_CAMPAIGN_COUNT][3];
+extern const rct_string_id RideInspectionIntervalNames[];
+extern const rct_string_id PeepThoughts[174];
+extern const rct_string_id DateDayNames[31];
+extern const rct_string_id DateGameMonthNames[MONTH_COUNT];
+extern const rct_string_id DateGameShortMonthNames[MONTH_COUNT];
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../network/NetworkTypes.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/../network/NetworkTypes.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../network/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../network/NetworkTypes.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../network/../core/Endianness.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/../network/../core/Endianness.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../network/../core/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../network/../core/Endianness.h" 2
+
+# 1 "/usr/include/c++/10.2.0/cstring" 1 3
+# 39 "/usr/include/c++/10.2.0/cstring" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstring" 3
+# 15 "/home/ted/dev/openrct2/src/openrct2/core/../network/../core/Endianness.h" 2
+
+
+template<size_t size> struct ByteSwapT
+{
+};
+
+template<> struct ByteSwapT<1>
+{
+    using UIntType = uint8_t;
+    static uint8_t SwapBE(uint8_t value)
+    {
+        return value;
+    }
+};
+
+template<> struct ByteSwapT<2>
+{
+    using UIntType = uint16_t;
+    static uint16_t SwapBE(uint16_t value)
+    {
+        return static_cast<uint16_t>((value << 8) | (value >> 8));
+    }
+};
+
+template<> struct ByteSwapT<4>
+{
+    using UIntType = uint32_t;
+    static uint32_t SwapBE(uint32_t value)
+    {
+        return static_cast<uint32_t>(
+            ((value << 24) | ((value << 8) & 0x00FF0000) | ((value >> 8) & 0x0000FF00) | (value >> 24)));
+    }
+};
+
+template<> struct ByteSwapT<8>
+{
+    using UIntType = uint64_t;
+    static uint64_t SwapBE(uint64_t value)
+    {
+        value = (value & 0x00000000FFFFFFFF) << 32 | (value & 0xFFFFFFFF00000000) >> 32;
+        value = (value & 0x0000FFFF0000FFFF) << 16 | (value & 0xFFFF0000FFFF0000) >> 16;
+        value = (value & 0x00FF00FF00FF00FF) << 8 | (value & 0xFF00FF00FF00FF00) >> 8;
+        return value;
+    }
+};
+
+template<typename T> static T ByteSwapBE(const T& value)
+{
+    using ByteSwap = ByteSwapT<sizeof(T)>;
+    using UIntType = typename ByteSwap::UIntType;
+
+    if constexpr (std::is_enum_v<T> || std::is_integral_v<T>)
+    {
+        auto result = ByteSwap::SwapBE(static_cast<const UIntType>(value));
+        return static_cast<T>(result);
+    }
+    else
+    {
+
+
+        UIntType temp;
+        std::memcpy(&temp, &value, sizeof(T));
+        auto result = ByteSwap::SwapBE(temp);
+        T res;
+        std::memcpy(&res, &result, sizeof(T));
+        return res;
+    }
+}
+# 14 "/home/ted/dev/openrct2/src/openrct2/core/../network/NetworkTypes.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../network/../util/Util.h" 1
+# 16 "/home/ted/dev/openrct2/src/openrct2/core/../network/NetworkTypes.h" 2
+
+enum
+{
+    SERVER_EVENT_PLAYER_JOINED,
+    SERVER_EVENT_PLAYER_DISCONNECTED,
+};
+
+enum
+{
+    NETWORK_TICK_FLAG_CHECKSUMS = 1 << 0,
+};
+
+enum
+{
+    NETWORK_MODE_NONE,
+    NETWORK_MODE_CLIENT,
+    NETWORK_MODE_SERVER
+};
+
+enum
+{
+    NETWORK_PLAYER_FLAG_ISSERVER = 1 << 0,
+};
+
+enum
+{
+    NETWORK_STATUS_NONE,
+    NETWORK_STATUS_READY,
+    NETWORK_STATUS_CONNECTING,
+    NETWORK_STATUS_CONNECTED
+};
+
+enum class NetworkAuth : int32_t
+{
+    None,
+    Requested,
+    Ok,
+    BadVersion,
+    BadName,
+    BadPassword,
+    VerificationFailure,
+    Full,
+    RequirePassword,
+    Verified,
+    UnknownKeyDisallowed
+};
+
+enum class NetworkCommand : uint32_t
+{
+    Auth,
+    Map,
+    Chat,
+    Tick = 4,
+    PlayerList,
+    Ping,
+    PingList,
+    DisconnectMessage,
+    GameInfo,
+    ShowError,
+    GroupList,
+    Event,
+    Token,
+    ObjectsList,
+    MapRequest,
+    GameAction,
+    PlayerInfo,
+    RequestGameState,
+    GameState,
+    Scripts,
+    Heartbeat,
+    Max,
+    Invalid = static_cast<uint32_t>(-1),
+};
+
+static_assert(NetworkCommand::GameInfo == static_cast<NetworkCommand>(9), "Master server expects this to be 9");
+
+enum class NetworkServerState
+{
+    Ok,
+    Desynced
+};
+
+struct NetworkServerState_t
+{
+    NetworkServerState state = NetworkServerState::Ok;
+    uint32_t desyncTick = 0;
+    uint32_t tick = 0;
+    uint32_t srand0 = 0;
+    bool gamestateSnapshotsEnabled = false;
+};
+
+
+
+
+#pragma pack(push, 1)
+template<typename T, size_t _TypeID> struct NetworkObjectId_t
+{
+    NetworkObjectId_t(T v)
+        : id(v)
+    {
+    }
+    NetworkObjectId_t()
+        : id(T(-1))
+    {
+    }
+    operator T() const
+    {
+        return id;
+    }
+    T id;
+};
+#pragma pack(pop)
+
+
+
+using NetworkPlayerId_t = NetworkObjectId_t<int32_t, 0>;
+using NetworkRideId_t = NetworkObjectId_t<ride_id_t, 1>;
+using NetworkCheatType_t = NetworkObjectId_t<int32_t, 2>;
+
+enum class NetworkStatisticsGroup : uint32_t
+{
+    Total = 0,
+    Base,
+    Commands,
+    MapData,
+    Max,
+};
+
+struct NetworkStats_t
+{
+    uint64_t bytesReceived[EnumValue(NetworkStatisticsGroup::Max)];
+    uint64_t bytesSent[EnumValue(NetworkStatisticsGroup::Max)];
+};
+# 16 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../network/network.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/../network/network.h"
+       
+
+
+
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../network/../Game.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/../network/../Game.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../network/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../network/../Game.h" 2
+
+
+
+struct ParkLoadResult;
+struct rct_s6_data;
+
+enum class GameCommand : int32_t
+{
+    PasswordlessLogin = -3,
+    ToggleSceneryCluster = -2,
+    Chat = -1,
+
+    SetRideAppearance,
+    SetLandHeight,
+    TogglePause,
+    PlaceTrack,
+    RemoveTrack,
+    LoadOrQuit,
+    CreateRide,
+    DemolishRide,
+    SetRideStatus,
+    SetRideVehicles,
+    SetRideName,
+    SetRideSetting,
+    PlaceRideEntranceOrExit,
+    RemoveRideEntranceOrExit,
+    RemoveScenery,
+    PlaceScenery,
+    SetWaterHeight,
+    PlacePath,
+    PlacePathFromTrack,
+    RemovePath,
+    ChangeSurfaceStyle,
+    SetRidePrice,
+    SetGuestName,
+    SetStaffName,
+    RaiseLand,
+    LowerLand,
+    EditLandSmooth,
+    RaiseWater,
+    LowerWater,
+    SetBrakesSpeed,
+    HireNewStaffMember,
+    SetStaffPatrol,
+    FireStaffMember,
+    SetStaffOrders,
+    SetParkName,
+    SetParkOpen,
+    BuyLandRights,
+    PlaceParkEntrance,
+    RemoveParkEntrance,
+    SetMazeTrack,
+    SetParkEntranceFee,
+    SetStaffColour,
+    PlaceWall,
+    RemoveWall,
+    PlaceLargeScenery,
+    RemoveLargeScenery,
+    SetCurrentLoan,
+    SetResearchFunding,
+    PlaceTrackDesign,
+    StartMarketingCampaign,
+    PlaceMazeDesign,
+    PlaceBanner,
+    RemoveBanner,
+    SetSceneryColour,
+    SetWallColour,
+    SetLargeSceneryColour,
+    SetBannerColour,
+    SetLandOwnership,
+    ClearScenery,
+    SetBannerName,
+    SetSignName,
+    SetBannerStyle,
+    SetSignStyle,
+    SetPlayerGroup,
+    ModifyGroups,
+    KickPlayer,
+    Cheat,
+    PickupGuest,
+    PickupStaff,
+    BalloonPress,
+    ModifyTile,
+    EditScenarioOptions,
+    PlacePeepSpawn,
+    SetClimate,
+    SetColourScheme,
+    SetStaffCostume,
+    PlaceFootpathAddition,
+    RemoveFootpathAddition,
+    GuestSetFlags,
+    SetDate,
+    Custom,
+    Count,
+};
+
+enum : uint32_t
+{
+    GAME_COMMAND_FLAG_APPLY = (1 << 0),
+    GAME_COMMAND_FLAG_REPLAY = (1 << 1),
+    GAME_COMMAND_FLAG_2 = (1 << 2),
+    GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED = (1 << 3),
+    GAME_COMMAND_FLAG_4 = (1 << 4),
+    GAME_COMMAND_FLAG_NO_SPEND = (1 << 5),
+    GAME_COMMAND_FLAG_GHOST = (1 << 6),
+    GAME_COMMAND_FLAG_PATH_SCENERY = (1 << 7),
+    GAME_COMMAND_FLAG_NETWORKED = (1u << 31)
+};
+
+enum
+{
+    GAME_PAUSED_NORMAL = 1 << 0,
+    GAME_PAUSED_MODAL = 1 << 1,
+    GAME_PAUSED_SAVING_TRACK = 1 << 2,
+};
+
+enum
+{
+    ERROR_TYPE_NONE = 0,
+    ERROR_TYPE_GENERIC = 254,
+    ERROR_TYPE_FILE_LOAD = 255
+};
+
+extern rct_string_id gGameCommandErrorTitle;
+extern rct_string_id gGameCommandErrorText;
+
+extern uint32_t gCurrentTicks;
+extern uint32_t gCurrentRealTimeTicks;
+
+extern uint16_t gCurrentDeltaTime;
+extern uint8_t gGamePaused;
+extern int32_t gGameSpeed;
+extern bool gDoSingleUpdate;
+extern float gDayNightCycle;
+extern bool gInUpdateCode;
+extern bool gInMapInitCode;
+extern std::string gCurrentLoadedPath;
+
+extern bool gLoadKeepWindowsOpen;
+
+void game_reset_speed();
+void game_increase_game_speed();
+void game_reduce_game_speed();
+
+void game_create_windows();
+void reset_all_sprite_quadrant_placements();
+void update_palette_effects();
+
+void game_load_or_quit_no_save_prompt();
+void load_from_sv6(const char* path);
+void game_load_init();
+void game_load_scripts();
+void game_unload_scripts();
+void pause_toggle();
+bool game_is_paused();
+bool game_is_not_paused();
+void save_game();
+void* create_save_game_as_intent();
+void save_game_as();
+void save_game_cmd(const utf8* name = nullptr);
+void save_game_with_name(const utf8* name);
+void game_autosave();
+void game_convert_strings_to_utf8();
+void game_convert_strings_to_rct2(rct_s6_data* s6);
+void utf8_to_rct2_self(char* buffer, size_t length);
+void rct2_to_utf8_self(char* buffer, size_t length);
+void game_fix_save_vars();
+void start_silent_record();
+bool stop_silent_record();
+# 18 "/home/ted/dev/openrct2/src/openrct2/core/../network/network.h" 2
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../network/../localisation/StringIds.h" 1
+# 21 "/home/ted/dev/openrct2/src/openrct2/core/../network/network.h" 2
+
+
+
+
+
+
+struct GameAction;
+struct Peep;
+struct CoordsXYZ;
+namespace GameActions
+{
+    class Result;
+}
+enum class ModifyGroupType : uint8_t;
+enum class PermissionState : uint8_t;
+enum class NetworkPermission : uint32_t;
+
+namespace OpenRCT2
+{
+    struct IPlatformEnvironment;
+}
+
+void network_set_env(const std::shared_ptr<OpenRCT2::IPlatformEnvironment>& env);
+void network_close();
+void network_reconnect();
+void network_shutdown_client();
+int32_t network_begin_client(const std::string& host, int32_t port);
+int32_t network_begin_server(int32_t port, const std::string& address);
+
+int32_t network_get_mode();
+int32_t network_get_status();
+bool network_is_desynchronised();
+bool network_check_desynchronisation();
+void network_request_gamestate_snapshot();
+void network_send_tick();
+bool network_gamestate_snapshots_enabled();
+void network_update();
+void network_process_pending();
+void network_flush();
+
+NetworkAuth network_get_authstatus();
+uint32_t network_get_server_tick();
+uint8_t network_get_current_player_id();
+int32_t network_get_num_players();
+const char* network_get_player_name(uint32_t index);
+uint32_t network_get_player_flags(uint32_t index);
+int32_t network_get_player_ping(uint32_t index);
+int32_t network_get_player_id(uint32_t index);
+money32 network_get_player_money_spent(uint32_t index);
+std::string network_get_player_ip_address(uint32_t id);
+std::string network_get_player_public_key_hash(uint32_t id);
+void network_add_player_money_spent(uint32_t index, money32 cost);
+int32_t network_get_player_last_action(uint32_t index, int32_t time);
+void network_set_player_last_action(uint32_t index, GameCommand command);
+CoordsXYZ network_get_player_last_action_coord(uint32_t index);
+void network_set_player_last_action_coord(uint32_t index, const CoordsXYZ& coord);
+uint32_t network_get_player_commands_ran(uint32_t index);
+int32_t network_get_player_index(uint32_t id);
+uint8_t network_get_player_group(uint32_t index);
+void network_set_player_group(uint32_t index, uint32_t groupindex);
+int32_t network_get_group_index(uint8_t id);
+int32_t network_get_current_player_group_index();
+uint8_t network_get_group_id(uint32_t index);
+int32_t network_get_num_groups();
+const char* network_get_group_name(uint32_t index);
+std::unique_ptr<GameActions::Result> network_set_player_group(
+    NetworkPlayerId_t actionPlayerId, NetworkPlayerId_t playerId, uint8_t groupId, bool isExecuting);
+std::unique_ptr<GameActions::Result> network_modify_groups(
+    NetworkPlayerId_t actionPlayerId, ModifyGroupType type, uint8_t groupId, const std::string& name, uint32_t permissionIndex,
+    PermissionState permissionState, bool isExecuting);
+std::unique_ptr<GameActions::Result> network_kick_player(NetworkPlayerId_t playerId, bool isExecuting);
+uint8_t network_get_default_group();
+int32_t network_get_num_actions();
+rct_string_id network_get_action_name_string_id(uint32_t index);
+int32_t network_can_perform_action(uint32_t groupindex, NetworkPermission index);
+int32_t network_can_perform_command(uint32_t groupindex, int32_t index);
+void network_set_pickup_peep(uint8_t playerid, Peep* peep);
+Peep* network_get_pickup_peep(uint8_t playerid);
+void network_set_pickup_peep_old_x(uint8_t playerid, int32_t x);
+int32_t network_get_pickup_peep_old_x(uint8_t playerid);
+
+void network_send_map();
+void network_send_chat(const char* text, const std::vector<uint8_t>& playerIds = {});
+void network_send_game_action(const GameAction* action);
+void network_enqueue_game_action(const GameAction* action);
+void network_send_password(const std::string& password);
+
+void network_set_password(const char* password);
+
+void network_print_error();
+void network_append_chat_log(const utf8* text);
+void network_append_server_log(const utf8* text);
+const utf8* network_get_server_name();
+const utf8* network_get_server_description();
+const utf8* network_get_server_greeting();
+const utf8* network_get_server_provider_name();
+const utf8* network_get_server_provider_email();
+const utf8* network_get_server_provider_website();
+
+std::string network_get_version();
+
+NetworkStats_t network_get_stats();
+NetworkServerState_t network_get_server_state();
+json_t network_get_server_info_as_json();
+# 17 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../ride/Ride.h" 1
+# 19 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../ride/TrackDesign.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/../ride/TrackDesign.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../ride/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/core/../ride/TrackDesign.h" 2
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/../ride/../world/Map.h" 1
+# 18 "/home/ted/dev/openrct2/src/openrct2/core/../ride/TrackDesign.h" 2
+
+struct Ride;
+
+
+
+
+struct TrackDesignEntranceElement
+{
+    int8_t z;
+    uint8_t direction;
+    int16_t x;
+    int16_t y;
+    bool isExit;
+};
+
+
+struct TrackDesignSceneryElement
+{
+    rct_object_entry scenery_object;
+    int8_t x;
+    int8_t y;
+    int8_t z;
+    uint8_t flags;
+    uint8_t primary_colour;
+    uint8_t secondary_colour;
+};
+
+
+
+
+
+
+struct TrackDesignTrackElement
+{
+    track_type_t type;
+    uint8_t flags;
+};
+
+
+struct TrackDesignMazeElement
+{
+    union
+    {
+        uint32_t all;
+        struct
+        {
+            int8_t x;
+            int8_t y;
+            union
+            {
+                uint16_t maze_entry;
+                struct
+                {
+                    uint8_t direction;
+                    uint8_t type;
+                };
+            };
+        };
+    };
+};
+
+class DataSerialiser;
+enum class RideMode : uint8_t;
+
+struct TrackDesign
+{
+    uint8_t type;
+    uint8_t vehicle_type;
+    money32 cost;
+    uint32_t flags;
+    RideMode ride_mode;
+    uint8_t track_flags;
+    uint8_t colour_scheme;
+    std::array<rct_vehicle_colour, RCT2_MAX_CARS_PER_TRAIN> vehicle_colours;
+    uint8_t entrance_style;
+    uint8_t total_air_time;
+    uint8_t depart_flags;
+    uint8_t number_of_trains;
+    uint8_t number_of_cars_per_train;
+    uint8_t min_waiting_time;
+    uint8_t max_waiting_time;
+    uint8_t operation_setting;
+    int8_t max_speed;
+    int8_t average_speed;
+    uint16_t ride_length;
+    uint8_t max_positive_vertical_g;
+    int8_t max_negative_vertical_g;
+    uint8_t max_lateral_g;
+    uint8_t inversions;
+    uint8_t holes;
+    uint8_t drops;
+    uint8_t highest_drop_height;
+    uint8_t excitement;
+    uint8_t intensity;
+    uint8_t nausea;
+    money16 upkeep_cost;
+    uint8_t track_spine_colour[RCT12_NUM_COLOUR_SCHEMES];
+    uint8_t track_rail_colour[RCT12_NUM_COLOUR_SCHEMES];
+    uint8_t track_support_colour[RCT12_NUM_COLOUR_SCHEMES];
+    uint32_t flags2;
+    rct_object_entry vehicle_object;
+    uint8_t space_required_x;
+    uint8_t space_required_y;
+    uint8_t vehicle_additional_colour[RCT2_MAX_CARS_PER_TRAIN];
+    uint8_t lift_hill_speed;
+    uint8_t num_circuits;
+
+    std::vector<TrackDesignMazeElement> maze_elements;
+    std::vector<TrackDesignTrackElement> track_elements;
+    std::vector<TrackDesignEntranceElement> entrance_elements;
+    std::vector<TrackDesignSceneryElement> scenery_elements;
+
+    std::string name;
+
+public:
+    rct_string_id CreateTrackDesign(const Ride& ride);
+    rct_string_id CreateTrackDesignScenery();
+    void Serialise(DataSerialiser& stream);
+
+private:
+    uint8_t _saveDirection;
+    rct_string_id CreateTrackDesignTrack(const Ride& ride);
+    rct_string_id CreateTrackDesignMaze(const Ride& ride);
+    CoordsXYE MazeGetFirstElement(const Ride& ride);
+};
+
+
+enum : uint32_t
+{
+    TRACK_FLAGS_CONTAINS_VERTICAL_LOOP = (1 << 7),
+    TRACK_FLAGS_CONTAINS_INLINE_TWIST = (1 << 17),
+    TRACK_FLAGS_CONTAINS_HALF_LOOP = (1 << 18),
+    TRACK_FLAGS_CONTAINS_CORKSCREW = (1 << 19),
+    TRACK_FLAGS_CONTAINS_WATER_SPLASH = (1 << 27),
+    TRACK_FLAGS_CONTAINS_BARREL_ROLL = (1 << 29),
+    TRACK_FLAGS_CONTAINS_POWERED_LIFT = (1 << 30),
+    TRACK_FLAGS_CONTAINS_LARGE_HALF_LOOP = (1u << 31),
+};
+
+enum : uint32_t
+{
+    TRACK_FLAGS2_CONTAINS_LOG_FLUME_REVERSER = (1 << 1),
+    TRACK_FLAGS2_SIX_FLAGS_RIDE_DEPRECATED = (1u << 31)
+};
+
+enum
+{
+    TDPF_PLACE_SCENERY = 1 << 0,
+};
+
+enum
+{
+    TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE = (1 << 0),
+    TRACK_DESIGN_FLAG_HAS_SCENERY = (1 << 1),
+    TRACK_DESIGN_FLAG_VEHICLE_UNAVAILABLE = (1 << 2),
+};
+
+enum
+{
+    PTD_OPERATION_DRAW_OUTLINES,
+    PTD_OPERATION_PLACE_QUERY,
+    PTD_OPERATION_PLACE,
+    PTD_OPERATION_GET_PLACE_Z,
+    PTD_OPERATION_PLACE_GHOST,
+    PTD_OPERATION_PLACE_TRACK_PREVIEW,
+    PTD_OPERATION_REMOVE_GHOST,
+};
+
+static constexpr uint8_t PTD_OPERATION_FLAG_IS_REPLAY = (1 << 7);
+
+enum
+{
+    MAZE_ELEMENT_TYPE_MAZE_TRACK = 0,
+    MAZE_ELEMENT_TYPE_ENTRANCE = (1 << 3),
+    MAZE_ELEMENT_TYPE_EXIT = (1 << 7)
+};
+
+extern TrackDesign* gActiveTrackDesign;
+extern bool gTrackDesignSceneryToggle;
+
+extern bool byte_9D8150;
+
+extern bool _trackDesignPlaceStateSceneryUnavailable;
+extern bool gTrackDesignSaveMode;
+extern ride_id_t gTrackDesignSaveRideIndex;
+
+std::unique_ptr<TrackDesign> track_design_open(const utf8* path);
+
+void track_design_mirror(TrackDesign* td6);
+
+int32_t place_virtual_track(TrackDesign* td6, uint8_t ptdOperation, bool placeScenery, Ride* ride, const CoordsXYZ& coords);
+
+
+
+
+void track_design_draw_preview(TrackDesign* td6, uint8_t* pixels);
+
+
+
+
+void track_design_save_init();
+void track_design_save_reset_scenery();
+bool track_design_save_contains_tile_element(const TileElement* tileElement);
+void track_design_save_select_nearby_scenery(ride_id_t rideIndex);
+void track_design_save_select_tile_element(
+    ViewportInteractionItem interactionType, const CoordsXY& loc, TileElement* tileElement, bool collect);
+
+bool track_design_are_entrance_and_exit_placed();
+
+extern std::vector<TrackDesignSceneryElement> _trackSavedTileElementsDesc;
+extern std::vector<const TileElement*> _trackSavedTileElements;
+# 20 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTag.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTag.h"
+       
+
+template<typename T> class DataSerialiserTag
+{
+public:
+    DataSerialiserTag(const char* name, T& data)
+        : _name(name)
+        , _data(data)
+    {
+    }
+
+    const char* Name() const
+    {
+        return _name;
+    }
+
+    T& Data() const
+    {
+        return _data;
+    }
+
+private:
+    const char* _name = nullptr;
+    T& _data;
+};
+
+template<typename T> inline DataSerialiserTag<T> CreateDataSerialiserTag(const char* name, T& data)
+{
+    DataSerialiserTag<T> r(name, data);
+    return r;
+}
+# 23 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdio" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 27 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+# 1 "/usr/include/c++/10.2.0/iomanip" 1 3
+# 36 "/usr/include/c++/10.2.0/iomanip" 3
+       
+# 37 "/usr/include/c++/10.2.0/iomanip" 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/locale" 1 3
+# 36 "/usr/include/c++/10.2.0/locale" 3
+       
+# 37 "/usr/include/c++/10.2.0/locale" 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+
+# 1 "/usr/include/c++/10.2.0/ctime" 1 3
+# 39 "/usr/include/c++/10.2.0/ctime" 3
+       
+# 40 "/usr/include/c++/10.2.0/ctime" 3
+# 40 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 2 3
+
+
+# 41 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 52 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  class time_base
+  {
+  public:
+    enum dateorder { no_order, dmy, mdy, ymd, ydm };
+  };
+
+  template<typename _CharT>
+    struct __timepunct_cache : public locale::facet
+    {
+
+      static const _CharT* _S_timezones[14];
+
+      const _CharT* _M_date_format;
+      const _CharT* _M_date_era_format;
+      const _CharT* _M_time_format;
+      const _CharT* _M_time_era_format;
+      const _CharT* _M_date_time_format;
+      const _CharT* _M_date_time_era_format;
+      const _CharT* _M_am;
+      const _CharT* _M_pm;
+      const _CharT* _M_am_pm_format;
+
+
+      const _CharT* _M_day1;
+      const _CharT* _M_day2;
+      const _CharT* _M_day3;
+      const _CharT* _M_day4;
+      const _CharT* _M_day5;
+      const _CharT* _M_day6;
+      const _CharT* _M_day7;
+
+
+      const _CharT* _M_aday1;
+      const _CharT* _M_aday2;
+      const _CharT* _M_aday3;
+      const _CharT* _M_aday4;
+      const _CharT* _M_aday5;
+      const _CharT* _M_aday6;
+      const _CharT* _M_aday7;
+
+
+      const _CharT* _M_month01;
+      const _CharT* _M_month02;
+      const _CharT* _M_month03;
+      const _CharT* _M_month04;
+      const _CharT* _M_month05;
+      const _CharT* _M_month06;
+      const _CharT* _M_month07;
+      const _CharT* _M_month08;
+      const _CharT* _M_month09;
+      const _CharT* _M_month10;
+      const _CharT* _M_month11;
+      const _CharT* _M_month12;
+
+
+      const _CharT* _M_amonth01;
+      const _CharT* _M_amonth02;
+      const _CharT* _M_amonth03;
+      const _CharT* _M_amonth04;
+      const _CharT* _M_amonth05;
+      const _CharT* _M_amonth06;
+      const _CharT* _M_amonth07;
+      const _CharT* _M_amonth08;
+      const _CharT* _M_amonth09;
+      const _CharT* _M_amonth10;
+      const _CharT* _M_amonth11;
+      const _CharT* _M_amonth12;
+
+      bool _M_allocated;
+
+      __timepunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_date_format(0), _M_date_era_format(0), _M_time_format(0),
+      _M_time_era_format(0), _M_date_time_format(0),
+      _M_date_time_era_format(0), _M_am(0), _M_pm(0),
+      _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
+      _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
+      _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
+      _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
+      _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
+      _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
+      _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
+      _M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
+      _M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
+      _M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
+      _M_amonth11(0), _M_amonth12(0), _M_allocated(false)
+      { }
+
+      ~__timepunct_cache();
+
+    private:
+      __timepunct_cache&
+      operator=(const __timepunct_cache&);
+
+      explicit
+      __timepunct_cache(const __timepunct_cache&);
+    };
+
+  template<typename _CharT>
+    __timepunct_cache<_CharT>::~__timepunct_cache()
+    {
+      if (_M_allocated)
+ {
+
+ }
+    }
+
+
+  template<>
+    const char*
+    __timepunct_cache<char>::_S_timezones[14];
+
+
+  template<>
+    const wchar_t*
+    __timepunct_cache<wchar_t>::_S_timezones[14];
+
+
+
+  template<typename _CharT>
+    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
+
+  template<typename _CharT>
+    class __timepunct : public locale::facet
+    {
+    public:
+
+      typedef _CharT __char_type;
+      typedef __timepunct_cache<_CharT> __cache_type;
+
+    protected:
+      __cache_type* _M_data;
+      __c_locale _M_c_locale_timepunct;
+      const char* _M_name_timepunct;
+
+    public:
+
+      static locale::id id;
+
+      explicit
+      __timepunct(size_t __refs = 0);
+
+      explicit
+      __timepunct(__cache_type* __cache, size_t __refs = 0);
+# 206 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
+
+
+
+      void
+      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
+      const tm* __tm) const throw ();
+
+      void
+      _M_date_formats(const _CharT** __date) const
+      {
+
+ __date[0] = _M_data->_M_date_format;
+ __date[1] = _M_data->_M_date_era_format;
+      }
+
+      void
+      _M_time_formats(const _CharT** __time) const
+      {
+
+ __time[0] = _M_data->_M_time_format;
+ __time[1] = _M_data->_M_time_era_format;
+      }
+
+      void
+      _M_date_time_formats(const _CharT** __dt) const
+      {
+
+ __dt[0] = _M_data->_M_date_time_format;
+ __dt[1] = _M_data->_M_date_time_era_format;
+      }
+
+
+      void
+      _M_am_pm_format(const _CharT*) const
+      { }
+
+
+      void
+      _M_am_pm(const _CharT** __ampm) const
+      {
+ __ampm[0] = _M_data->_M_am;
+ __ampm[1] = _M_data->_M_pm;
+      }
+
+      void
+      _M_days(const _CharT** __days) const
+      {
+ __days[0] = _M_data->_M_day1;
+ __days[1] = _M_data->_M_day2;
+ __days[2] = _M_data->_M_day3;
+ __days[3] = _M_data->_M_day4;
+ __days[4] = _M_data->_M_day5;
+ __days[5] = _M_data->_M_day6;
+ __days[6] = _M_data->_M_day7;
+      }
+
+      void
+      _M_days_abbreviated(const _CharT** __days) const
+      {
+ __days[0] = _M_data->_M_aday1;
+ __days[1] = _M_data->_M_aday2;
+ __days[2] = _M_data->_M_aday3;
+ __days[3] = _M_data->_M_aday4;
+ __days[4] = _M_data->_M_aday5;
+ __days[5] = _M_data->_M_aday6;
+ __days[6] = _M_data->_M_aday7;
+      }
+
+      void
+      _M_months(const _CharT** __months) const
+      {
+ __months[0] = _M_data->_M_month01;
+ __months[1] = _M_data->_M_month02;
+ __months[2] = _M_data->_M_month03;
+ __months[3] = _M_data->_M_month04;
+ __months[4] = _M_data->_M_month05;
+ __months[5] = _M_data->_M_month06;
+ __months[6] = _M_data->_M_month07;
+ __months[7] = _M_data->_M_month08;
+ __months[8] = _M_data->_M_month09;
+ __months[9] = _M_data->_M_month10;
+ __months[10] = _M_data->_M_month11;
+ __months[11] = _M_data->_M_month12;
+      }
+
+      void
+      _M_months_abbreviated(const _CharT** __months) const
+      {
+ __months[0] = _M_data->_M_amonth01;
+ __months[1] = _M_data->_M_amonth02;
+ __months[2] = _M_data->_M_amonth03;
+ __months[3] = _M_data->_M_amonth04;
+ __months[4] = _M_data->_M_amonth05;
+ __months[5] = _M_data->_M_amonth06;
+ __months[6] = _M_data->_M_amonth07;
+ __months[7] = _M_data->_M_amonth08;
+ __months[8] = _M_data->_M_amonth09;
+ __months[9] = _M_data->_M_amonth10;
+ __months[10] = _M_data->_M_amonth11;
+ __months[11] = _M_data->_M_amonth12;
+      }
+
+    protected:
+      virtual
+      ~__timepunct();
+
+
+      void
+      _M_initialize_timepunct(__c_locale __cloc = 0);
+    };
+
+  template<typename _CharT>
+    locale::id __timepunct<_CharT>::id;
+
+
+  template<>
+    void
+    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
+
+  template<>
+    void
+    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();
+
+
+  template<>
+    void
+    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
+
+  template<>
+    void
+    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
+     const tm*) const throw ();
+
+
+
+}
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/time_members.h" 1 3
+# 37 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/time_members.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(size_t __refs)
+    : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
+      _M_name_timepunct(_S_get_c_name())
+    { _M_initialize_timepunct(); }
+
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
+    : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(0),
+      _M_name_timepunct(_S_get_c_name())
+    { _M_initialize_timepunct(); }
+
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
+         size_t __refs)
+    : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
+      _M_name_timepunct(0)
+    {
+      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
+ {
+   const size_t __len = __builtin_strlen(__s) + 1;
+   char* __tmp = new char[__len];
+   __builtin_memcpy(__tmp, __s, __len);
+   _M_name_timepunct = __tmp;
+ }
+      else
+ _M_name_timepunct = _S_get_c_name();
+
+      try
+ { _M_initialize_timepunct(__cloc); }
+      catch(...)
+ {
+   if (_M_name_timepunct != _S_get_c_name())
+     delete [] _M_name_timepunct;
+   throw;
+ }
+    }
+
+  template<typename _CharT>
+    __timepunct<_CharT>::~__timepunct()
+    {
+      if (_M_name_timepunct != _S_get_c_name())
+ delete [] _M_name_timepunct;
+      delete _M_data;
+      _S_destroy_c_locale(_M_c_locale_timepunct);
+    }
+
+
+}
+# 347 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+namespace __cxx11 {
+# 367 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _InIter>
+    class time_get : public locale::facet, public time_base
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+
+
+      static locale::id id;
+# 388 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      time_get(size_t __refs = 0)
+      : facet (__refs) { }
+# 405 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      dateorder
+      date_order() const
+      { return this->do_date_order(); }
+# 429 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_time(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
+# 454 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_date(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
+# 482 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
+# 511 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
+# 537 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_year(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_year(__beg, __end, __io, __err, __tm); }
+# 558 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      inline
+      iter_type get(iter_type __s, iter_type __end, ios_base& __io,
+                    ios_base::iostate& __err, tm* __tm, char __format,
+                    char __modifier = 0) const
+      {
+        return this->do_get(__s, __end, __io, __err, __tm, __format,
+                            __modifier);
+      }
+# 585 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type get(iter_type __s, iter_type __end, ios_base& __io,
+                    ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
+                    const char_type* __fmtend) const;
+
+
+    protected:
+
+      virtual
+      ~time_get() { }
+# 605 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual dateorder
+      do_date_order() const;
+# 623 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+# 642 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+# 661 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
+       ios_base::iostate& __err, tm* __tm) const;
+# 680 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
+         ios_base::iostate& __err, tm* __tm) const;
+# 699 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+# 722 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual
+
+      iter_type
+      do_get(iter_type __s, iter_type __end, ios_base& __f,
+             ios_base::iostate& __err, tm* __tm,
+             char __format, char __modifier) const;
+
+
+
+      iter_type
+      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+       int __min, int __max, size_t __len,
+       ios_base& __io, ios_base::iostate& __err) const;
+
+
+      iter_type
+      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+        const _CharT** __names, size_t __indexlen,
+        ios_base& __io, ios_base::iostate& __err) const;
+
+
+      iter_type
+      _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+          const _CharT** __names, size_t __indexlen,
+          ios_base& __io, ios_base::iostate& __err) const;
+
+
+      iter_type
+      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+       ios_base::iostate& __err, tm* __tm,
+       const _CharT* __format) const;
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id time_get<_CharT, _InIter>::id;
+
+
+  template<typename _CharT, typename _InIter>
+    class time_get_byname : public time_get<_CharT, _InIter>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+      explicit
+      time_get_byname(const char*, size_t __refs = 0)
+      : time_get<_CharT, _InIter>(__refs) { }
+
+
+      explicit
+      time_get_byname(const string& __s, size_t __refs = 0)
+      : time_get_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~time_get_byname() { }
+    };
+
+}
+# 796 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _OutIter>
+    class time_put : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+
+
+      static locale::id id;
+# 817 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      time_put(size_t __refs = 0)
+      : facet(__refs) { }
+# 836 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+   const _CharT* __beg, const _CharT* __end) const;
+# 856 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   const tm* __tm, char __format, char __mod = 0) const
+      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
+
+    protected:
+
+      virtual
+      ~time_put()
+      { }
+# 883 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+      char __format, char __mod) const;
+    };
+
+  template<typename _CharT, typename _OutIter>
+    locale::id time_put<_CharT, _OutIter>::id;
+
+
+  template<typename _CharT, typename _OutIter>
+    class time_put_byname : public time_put<_CharT, _OutIter>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+      explicit
+      time_put_byname(const char*, size_t __refs = 0)
+      : time_put<_CharT, _OutIter>(__refs)
+      { }
+
+
+      explicit
+      time_put_byname(const string& __s, size_t __refs = 0)
+      : time_put_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~time_put_byname() { }
+    };
+# 928 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  class money_base
+  {
+  public:
+    enum part { none, space, symbol, sign, value };
+    struct pattern { char field[4]; };
+
+    static const pattern _S_default_pattern;
+
+    enum
+    {
+      _S_minus,
+      _S_zero,
+      _S_end = 11
+    };
+
+
+
+    static const char* _S_atoms;
+
+
+
+    __attribute__ ((__const__)) static pattern
+    _S_construct_pattern(char __precedes, char __space, char __posn) throw ();
+  };
+
+  template<typename _CharT, bool _Intl>
+    struct __moneypunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+      const _CharT* _M_curr_symbol;
+      size_t _M_curr_symbol_size;
+      const _CharT* _M_positive_sign;
+      size_t _M_positive_sign_size;
+      const _CharT* _M_negative_sign;
+      size_t _M_negative_sign_size;
+      int _M_frac_digits;
+      money_base::pattern _M_pos_format;
+      money_base::pattern _M_neg_format;
+
+
+
+
+      _CharT _M_atoms[money_base::_S_end];
+
+      bool _M_allocated;
+
+      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
+      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
+      _M_curr_symbol(0), _M_curr_symbol_size(0),
+      _M_positive_sign(0), _M_positive_sign_size(0),
+      _M_negative_sign(0), _M_negative_sign_size(0),
+      _M_frac_digits(0),
+      _M_pos_format(money_base::pattern()),
+      _M_neg_format(money_base::pattern()), _M_allocated(false)
+      { }
+
+      ~__moneypunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __moneypunct_cache&
+      operator=(const __moneypunct_cache&);
+
+      explicit
+      __moneypunct_cache(const __moneypunct_cache&);
+    };
+
+  template<typename _CharT, bool _Intl>
+    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_curr_symbol;
+   delete [] _M_positive_sign;
+   delete [] _M_negative_sign;
+ }
+    }
+
+namespace __cxx11 {
+# 1023 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, bool _Intl>
+    class moneypunct : public locale::facet, public money_base
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+
+    private:
+      __cache_type* _M_data;
+
+    public:
+
+
+      static const bool intl = _Intl;
+
+      static locale::id id;
+# 1052 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      moneypunct(size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_moneypunct(); }
+# 1065 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      moneypunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_moneypunct(); }
+# 1080 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
+      : facet(__refs), _M_data(0)
+      { _M_initialize_moneypunct(__cloc, __s); }
+# 1094 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+# 1107 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+# 1137 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string
+      grouping() const
+      { return this->do_grouping(); }
+# 1150 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string_type
+      curr_symbol() const
+      { return this->do_curr_symbol(); }
+# 1167 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string_type
+      positive_sign() const
+      { return this->do_positive_sign(); }
+# 1184 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string_type
+      negative_sign() const
+      { return this->do_negative_sign(); }
+# 1200 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      int
+      frac_digits() const
+      { return this->do_frac_digits(); }
+# 1236 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      pattern
+      pos_format() const
+      { return this->do_pos_format(); }
+
+      pattern
+      neg_format() const
+      { return this->do_neg_format(); }
+
+
+    protected:
+
+      virtual
+      ~moneypunct();
+# 1258 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+# 1270 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+# 1283 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+# 1296 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_curr_symbol() const
+      { return _M_data->_M_curr_symbol; }
+# 1309 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_positive_sign() const
+      { return _M_data->_M_positive_sign; }
+# 1322 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_negative_sign() const
+      { return _M_data->_M_negative_sign; }
+# 1336 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual int
+      do_frac_digits() const
+      { return _M_data->_M_frac_digits; }
+# 1350 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual pattern
+      do_pos_format() const
+      { return _M_data->_M_pos_format; }
+# 1364 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual pattern
+      do_neg_format() const
+      { return _M_data->_M_neg_format; }
+
+
+       void
+       _M_initialize_moneypunct(__c_locale __cloc = 0,
+    const char* __name = 0);
+    };
+
+  template<typename _CharT, bool _Intl>
+    locale::id moneypunct<_CharT, _Intl>::id;
+
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct<_CharT, _Intl>::intl;
+
+  template<>
+    moneypunct<char, true>::~moneypunct();
+
+  template<>
+    moneypunct<char, false>::~moneypunct();
+
+  template<>
+    void
+    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
+
+  template<>
+    void
+    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
+
+
+  template<>
+    moneypunct<wchar_t, true>::~moneypunct();
+
+  template<>
+    moneypunct<wchar_t, false>::~moneypunct();
+
+  template<>
+    void
+    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
+       const char*);
+
+  template<>
+    void
+    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
+        const char*);
+
+
+
+  template<typename _CharT, bool _Intl>
+    class moneypunct_byname : public moneypunct<_CharT, _Intl>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      static const bool intl = _Intl;
+
+      explicit
+      moneypunct_byname(const char* __s, size_t __refs = 0)
+      : moneypunct<_CharT, _Intl>(__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_moneypunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+
+
+      explicit
+      moneypunct_byname(const string& __s, size_t __refs = 0)
+      : moneypunct_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~moneypunct_byname() { }
+    };
+
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct_byname<_CharT, _Intl>::intl;
+
+}
+
+namespace __cxx11 {
+# 1467 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _InIter>
+    class money_get : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+      typedef basic_string<_CharT> string_type;
+
+
+
+      static locale::id id;
+# 1489 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      money_get(size_t __refs = 0) : facet(__refs) { }
+# 1519 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+   ios_base::iostate& __err, long double& __units) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
+# 1550 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+   ios_base::iostate& __err, string_type& __digits) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }
+
+    protected:
+
+      virtual
+      ~money_get() { }
+# 1574 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+      ios_base::iostate& __err, long double& __units) const;
+# 1586 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+      ios_base::iostate& __err, string_type& __digits) const;
+# 1598 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      template<bool _Intl>
+        iter_type
+        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, string& __digits) const;
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id money_get<_CharT, _InIter>::id;
+# 1620 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _OutIter>
+    class money_put : public locale::facet
+    {
+    public:
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+      typedef basic_string<_CharT> string_type;
+
+
+
+      static locale::id id;
+# 1641 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      money_put(size_t __refs = 0) : facet(__refs) { }
+# 1661 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+   char_type __fill, long double __units) const
+      { return this->do_put(__s, __intl, __io, __fill, __units); }
+# 1684 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+   char_type __fill, const string_type& __digits) const
+      { return this->do_put(__s, __intl, __io, __fill, __digits); }
+
+    protected:
+
+      virtual
+      ~money_put() { }
+# 1719 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+      long double __units) const;
+# 1743 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+      const string_type& __digits) const;
+# 1755 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      template<bool _Intl>
+        iter_type
+        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+    const string_type& __digits) const;
+    };
+
+  template<typename _CharT, typename _OutIter>
+    locale::id money_put<_CharT, _OutIter>::id;
+
+}
+
+
+
+
+
+  struct messages_base
+  {
+    typedef int catalog;
+  };
+
+namespace __cxx11 {
+# 1798 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+  template<typename _CharT>
+    class messages : public locale::facet, public messages_base
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+    protected:
+
+
+      __c_locale _M_c_locale_messages;
+      const char* _M_name_messages;
+
+    public:
+
+      static locale::id id;
+# 1826 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      messages(size_t __refs = 0);
+# 1840 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      explicit
+      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
+# 1853 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      catalog
+      open(const basic_string<char>& __s, const locale& __loc) const
+      { return this->do_open(__s, __loc); }
+# 1871 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      catalog
+      open(const basic_string<char>&, const locale&, const char*) const;
+# 1889 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      string_type
+      get(catalog __c, int __set, int __msgid, const string_type& __s) const
+      { return this->do_get(__c, __set, __msgid, __s); }
+# 1900 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      void
+      close(catalog __c) const
+      { return this->do_close(__c); }
+
+    protected:
+
+      virtual
+      ~messages();
+# 1920 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual catalog
+      do_open(const basic_string<char>&, const locale&) const;
+# 1939 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_get(catalog, int, int, const string_type& __dfault) const;
+
+
+
+
+
+
+      virtual void
+      do_close(catalog) const;
+
+
+      char*
+      _M_convert_to_char(const string_type& __msg) const
+      {
+
+ return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
+      }
+
+
+      string_type
+      _M_convert_from_char(char*) const
+      {
+
+ return string_type();
+      }
+     };
+
+  template<typename _CharT>
+    locale::id messages<_CharT>::id;
+
+
+  template<>
+    string
+    messages<char>::do_get(catalog, int, int, const string&) const;
+
+
+  template<>
+    wstring
+    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
+
+
+
+   template<typename _CharT>
+    class messages_byname : public messages<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      explicit
+      messages_byname(const char* __s, size_t __refs = 0);
+
+
+      explicit
+      messages_byname(const string& __s, size_t __refs = 0)
+      : messages_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~messages_byname()
+      { }
+    };
+
+}
+
+
+}
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 1 3
+# 36 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 3
+# 1 "/usr/include/libintl.h" 1 3 4
+# 34 "/usr/include/libintl.h" 3 4
+extern "C" {
+
+
+
+
+extern char *gettext (const char *__msgid)
+     noexcept (true) __attribute__ ((__format_arg__ (1)));
+
+
+
+extern char *dgettext (const char *__domainname, const char *__msgid)
+     noexcept (true) __attribute__ ((__format_arg__ (2)));
+extern char *__dgettext (const char *__domainname, const char *__msgid)
+     noexcept (true) __attribute__ ((__format_arg__ (2)));
+
+
+
+extern char *dcgettext (const char *__domainname,
+   const char *__msgid, int __category)
+     noexcept (true) __attribute__ ((__format_arg__ (2)));
+extern char *__dcgettext (const char *__domainname,
+     const char *__msgid, int __category)
+     noexcept (true) __attribute__ ((__format_arg__ (2)));
+
+
+
+
+extern char *ngettext (const char *__msgid1, const char *__msgid2,
+         unsigned long int __n)
+     noexcept (true) __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
+
+
+
+extern char *dngettext (const char *__domainname, const char *__msgid1,
+   const char *__msgid2, unsigned long int __n)
+     noexcept (true) __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
+
+
+
+extern char *dcngettext (const char *__domainname, const char *__msgid1,
+    const char *__msgid2, unsigned long int __n,
+    int __category)
+     noexcept (true) __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
+
+
+
+
+
+extern char *textdomain (const char *__domainname) noexcept (true);
+
+
+
+extern char *bindtextdomain (const char *__domainname,
+        const char *__dirname) noexcept (true);
+
+
+
+extern char *bind_textdomain_codeset (const char *__domainname,
+          const char *__codeset) noexcept (true);
+# 121 "/usr/include/libintl.h" 3 4
+}
+# 37 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/messages_members.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _CharT>
+    messages<_CharT>::messages(size_t __refs)
+    : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
+      _M_name_messages(_S_get_c_name())
+    { }
+
+  template<typename _CharT>
+    messages<_CharT>::messages(__c_locale __cloc, const char* __s,
+          size_t __refs)
+    : facet(__refs), _M_c_locale_messages(0), _M_name_messages(0)
+    {
+      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
+ {
+   const size_t __len = __builtin_strlen(__s) + 1;
+   char* __tmp = new char[__len];
+   __builtin_memcpy(__tmp, __s, __len);
+   _M_name_messages = __tmp;
+ }
+      else
+ _M_name_messages = _S_get_c_name();
+
+
+      _M_c_locale_messages = _S_clone_c_locale(__cloc);
+    }
+
+  template<typename _CharT>
+    typename messages<_CharT>::catalog
+    messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
+      const char* __dir) const
+    {
+      bindtextdomain(__s.c_str(), __dir);
+      return this->do_open(__s, __loc);
+    }
+
+
+  template<typename _CharT>
+    messages<_CharT>::~messages()
+    {
+      if (_M_name_messages != _S_get_c_name())
+ delete [] _M_name_messages;
+      _S_destroy_c_locale(_M_c_locale_messages);
+    }
+
+  template<typename _CharT>
+    typename messages<_CharT>::catalog
+    messages<_CharT>::do_open(const basic_string<char>& __s,
+         const locale&) const
+    {
+
+
+      textdomain(__s.c_str());
+      return 0;
+    }
+
+  template<typename _CharT>
+    void
+    messages<_CharT>::do_close(catalog) const
+    { }
+
+
+  template<typename _CharT>
+    messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
+    : messages<_CharT>(__refs)
+    {
+      if (this->_M_name_messages != locale::facet::_S_get_c_name())
+ {
+   delete [] this->_M_name_messages;
+   if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0)
+     {
+       const size_t __len = __builtin_strlen(__s) + 1;
+       char* __tmp = new char[__len];
+       __builtin_memcpy(__tmp, __s, __len);
+       this->_M_name_messages = __tmp;
+     }
+   else
+     this->_M_name_messages = locale::facet::_S_get_c_name();
+ }
+
+      if (__builtin_strcmp(__s, "C") != 0
+   && __builtin_strcmp(__s, "POSIX") != 0)
+ {
+   this->_S_destroy_c_locale(this->_M_c_locale_messages);
+   this->_S_create_c_locale(this->_M_c_locale_messages, __s);
+ }
+    }
+
+
+  template<>
+    typename messages<char>::catalog
+    messages<char>::do_open(const basic_string<char>&,
+       const locale&) const;
+
+  template<>
+    void
+    messages<char>::do_close(catalog) const;
+
+
+  template<>
+    typename messages<wchar_t>::catalog
+    messages<wchar_t>::do_open(const basic_string<char>&,
+          const locale&) const;
+
+  template<>
+    void
+    messages<wchar_t>::do_close(catalog) const;
+
+
+
+}
+# 2011 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 2 3
+
+
+# 1 "/usr/include/c++/10.2.0/bits/codecvt.h" 1 3
+# 39 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+       
+# 40 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  class codecvt_base
+  {
+  public:
+    enum result
+    {
+      ok,
+      partial,
+      error,
+      noconv
+    };
+  };
+# 67 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class __codecvt_abstract_base
+    : public locale::facet, public codecvt_base
+    {
+    public:
+
+      typedef codecvt_base::result result;
+      typedef _InternT intern_type;
+      typedef _ExternT extern_type;
+      typedef _StateT state_type;
+# 115 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+      result
+      out(state_type& __state, const intern_type* __from,
+   const intern_type* __from_end, const intern_type*& __from_next,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const
+      {
+ return this->do_out(__state, __from, __from_end, __from_next,
+       __to, __to_end, __to_next);
+      }
+# 154 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+      result
+      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
+       extern_type*& __to_next) const
+      { return this->do_unshift(__state, __to,__to_end,__to_next); }
+# 195 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+      result
+      in(state_type& __state, const extern_type* __from,
+  const extern_type* __from_end, const extern_type*& __from_next,
+  intern_type* __to, intern_type* __to_end,
+  intern_type*& __to_next) const
+      {
+ return this->do_in(__state, __from, __from_end, __from_next,
+      __to, __to_end, __to_next);
+      }
+
+      int
+      encoding() const throw()
+      { return this->do_encoding(); }
+
+      bool
+      always_noconv() const throw()
+      { return this->do_always_noconv(); }
+
+      int
+      length(state_type& __state, const extern_type* __from,
+      const extern_type* __end, size_t __max) const
+      { return this->do_length(__state, __from, __end, __max); }
+
+      int
+      max_length() const throw()
+      { return this->do_max_length(); }
+
+    protected:
+      explicit
+      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
+
+      virtual
+      ~__codecvt_abstract_base() { }
+# 236 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const = 0;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const = 0;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const = 0;
+
+      virtual int
+      do_encoding() const throw() = 0;
+
+      virtual bool
+      do_always_noconv() const throw() = 0;
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const = 0;
+
+      virtual int
+      do_max_length() const throw() = 0;
+    };
+# 273 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+   template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt
+    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
+    {
+    public:
+
+      typedef codecvt_base::result result;
+      typedef _InternT intern_type;
+      typedef _ExternT extern_type;
+      typedef _StateT state_type;
+
+    protected:
+      __c_locale _M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
+ _M_c_locale_codecvt(0)
+      { }
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt() { }
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const;
+
+      virtual int
+      do_encoding() const throw();
+
+      virtual bool
+      do_always_noconv() const throw();
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    locale::id codecvt<_InternT, _ExternT, _StateT>::id;
+
+
+  template<>
+    class codecvt<char, char, mbstate_t>
+    : public __codecvt_abstract_base<char, char, mbstate_t>
+    {
+      friend class messages<char>;
+
+    public:
+
+      typedef char intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    protected:
+      __c_locale _M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0);
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const;
+
+      virtual int
+      do_encoding() const throw();
+
+      virtual bool
+      do_always_noconv() const throw();
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+  };
+
+
+
+
+
+
+  template<>
+    class codecvt<wchar_t, char, mbstate_t>
+    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
+    {
+      friend class messages<wchar_t>;
+
+    public:
+
+      typedef wchar_t intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    protected:
+      __c_locale _M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0);
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state,
+      const extern_type* __from, const extern_type* __from_end,
+      const extern_type*& __from_next,
+      intern_type* __to, intern_type* __to_end,
+      intern_type*& __to_next) const;
+
+      virtual
+      int do_encoding() const throw();
+
+      virtual
+      bool do_always_noconv() const throw();
+
+      virtual
+      int do_length(state_type&, const extern_type* __from,
+      const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+
+
+
+
+
+
+
+  template<>
+    class codecvt<char16_t, char, mbstate_t>
+    : public __codecvt_abstract_base<char16_t, char, mbstate_t>
+    {
+    public:
+
+      typedef char16_t intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<char16_t, char, mbstate_t>(__refs) { }
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state,
+      const extern_type* __from, const extern_type* __from_end,
+      const extern_type*& __from_next,
+      intern_type* __to, intern_type* __to_end,
+      intern_type*& __to_next) const;
+
+      virtual
+      int do_encoding() const throw();
+
+      virtual
+      bool do_always_noconv() const throw();
+
+      virtual
+      int do_length(state_type&, const extern_type* __from,
+      const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+
+
+
+
+
+  template<>
+    class codecvt<char32_t, char, mbstate_t>
+    : public __codecvt_abstract_base<char32_t, char, mbstate_t>
+    {
+    public:
+
+      typedef char32_t intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<char32_t, char, mbstate_t>(__refs) { }
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state,
+      const extern_type* __from, const extern_type* __from_end,
+      const extern_type*& __from_next,
+      intern_type* __to, intern_type* __to_end,
+      intern_type*& __to_next) const;
+
+      virtual
+      int do_encoding() const throw();
+
+      virtual
+      bool do_always_noconv() const throw();
+
+      virtual
+      int do_length(state_type&, const extern_type* __from,
+      const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+# 695 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
+    {
+    public:
+      explicit
+      codecvt_byname(const char* __s, size_t __refs = 0)
+      : codecvt<_InternT, _ExternT, _StateT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
+     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
+   }
+      }
+
+
+      explicit
+      codecvt_byname(const string& __s, size_t __refs = 0)
+      : codecvt_byname(__s.c_str(), __refs) { }
+
+
+    protected:
+      virtual
+      ~codecvt_byname() { }
+    };
+
+
+  template<>
+    class codecvt_byname<char16_t, char, mbstate_t>
+    : public codecvt<char16_t, char, mbstate_t>
+    {
+    public:
+      explicit
+      codecvt_byname(const char*, size_t __refs = 0)
+      : codecvt<char16_t, char, mbstate_t>(__refs) { }
+
+      explicit
+      codecvt_byname(const string& __s, size_t __refs = 0)
+      : codecvt_byname(__s.c_str(), __refs) { }
+
+    protected:
+      virtual
+      ~codecvt_byname() { }
+    };
+
+  template<>
+    class codecvt_byname<char32_t, char, mbstate_t>
+    : public codecvt<char32_t, char, mbstate_t>
+    {
+    public:
+      explicit
+      codecvt_byname(const char*, size_t __refs = 0)
+      : codecvt<char32_t, char, mbstate_t>(__refs) { }
+
+      explicit
+      codecvt_byname(const string& __s, size_t __refs = 0)
+      : codecvt_byname(__s.c_str(), __refs) { }
+
+    protected:
+      virtual
+      ~codecvt_byname() { }
+    };
+# 802 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+  extern template class codecvt_byname<char, char, mbstate_t>;
+
+  extern template
+    const codecvt<char, char, mbstate_t>&
+    use_facet<codecvt<char, char, mbstate_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<codecvt<char, char, mbstate_t> >(const locale&);
+
+
+  extern template class codecvt_byname<wchar_t, char, mbstate_t>;
+
+  extern template
+    const codecvt<wchar_t, char, mbstate_t>&
+    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+
+
+
+  extern template class codecvt_byname<char16_t, char, mbstate_t>;
+  extern template class codecvt_byname<char32_t, char, mbstate_t>;
+# 837 "/usr/include/c++/10.2.0/bits/codecvt.h" 3
+
+}
+# 2014 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, bool _Intl>
+    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
+    {
+      const __moneypunct_cache<_CharT, _Intl>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
+     try
+       {
+  __tmp = new __moneypunct_cache<_CharT, _Intl>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<
+   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
+      }
+    };
+
+  template<typename _CharT, bool _Intl>
+    void
+    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
+    {
+      const moneypunct<_CharT, _Intl>& __mp =
+ use_facet<moneypunct<_CharT, _Intl> >(__loc);
+
+      _M_decimal_point = __mp.decimal_point();
+      _M_thousands_sep = __mp.thousands_sep();
+      _M_frac_digits = __mp.frac_digits();
+
+      char* __grouping = 0;
+      _CharT* __curr_symbol = 0;
+      _CharT* __positive_sign = 0;
+      _CharT* __negative_sign = 0;
+      try
+ {
+   const string& __g = __mp.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>& __cs = __mp.curr_symbol();
+   _M_curr_symbol_size = __cs.size();
+   __curr_symbol = new _CharT[_M_curr_symbol_size];
+   __cs.copy(__curr_symbol, _M_curr_symbol_size);
+
+   const basic_string<_CharT>& __ps = __mp.positive_sign();
+   _M_positive_sign_size = __ps.size();
+   __positive_sign = new _CharT[_M_positive_sign_size];
+   __ps.copy(__positive_sign, _M_positive_sign_size);
+
+   const basic_string<_CharT>& __ns = __mp.negative_sign();
+   _M_negative_sign_size = __ns.size();
+   __negative_sign = new _CharT[_M_negative_sign_size];
+   __ns.copy(__negative_sign, _M_negative_sign_size);
+
+   _M_pos_format = __mp.pos_format();
+   _M_neg_format = __mp.neg_format();
+
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(money_base::_S_atoms,
+       money_base::_S_atoms + money_base::_S_end, _M_atoms);
+
+   _M_grouping = __grouping;
+   _M_curr_symbol = __curr_symbol;
+   _M_positive_sign = __positive_sign;
+   _M_negative_sign = __negative_sign;
+   _M_allocated = true;
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __curr_symbol;
+   delete [] __positive_sign;
+   delete [] __negative_sign;
+   throw;
+ }
+    }
+
+namespace __cxx11 {
+
+  template<typename _CharT, typename _InIter>
+    template<bool _Intl>
+      _InIter
+      money_get<_CharT, _InIter>::
+      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, string& __units) const
+      {
+ typedef char_traits<_CharT> __traits_type;
+ typedef typename string_type::size_type size_type;
+ typedef money_base::part part;
+ typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+
+ const locale& __loc = __io._M_getloc();
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ __use_cache<__cache_type> __uc;
+ const __cache_type* __lc = __uc(__loc);
+ const char_type* __lit = __lc->_M_atoms;
+
+
+ bool __negative = false;
+
+ size_type __sign_size = 0;
+
+ const bool __mandatory_sign = (__lc->_M_positive_sign_size
+           && __lc->_M_negative_sign_size);
+
+ string __grouping_tmp;
+ if (__lc->_M_use_grouping)
+   __grouping_tmp.reserve(32);
+
+ int __last_pos = 0;
+
+ int __n = 0;
+
+ bool __testvalid = true;
+
+ bool __testdecfound = false;
+
+
+ string __res;
+ __res.reserve(32);
+
+ const char_type* __lit_zero = __lit + money_base::_S_zero;
+ const money_base::pattern __p = __lc->_M_neg_format;
+ for (int __i = 0; __i < 4 && __testvalid; ++__i)
+   {
+     const part __which = static_cast<part>(__p.field[__i]);
+     switch (__which)
+       {
+       case money_base::symbol:
+
+
+
+
+  if (__io.flags() & ios_base::showbase || __sign_size > 1
+      || __i == 0
+      || (__i == 1 && (__mandatory_sign
+         || (static_cast<part>(__p.field[0])
+      == money_base::sign)
+         || (static_cast<part>(__p.field[2])
+      == money_base::space)))
+      || (__i == 2 && ((static_cast<part>(__p.field[3])
+          == money_base::value)
+         || (__mandatory_sign
+      && (static_cast<part>(__p.field[3])
+          == money_base::sign)))))
+    {
+      const size_type __len = __lc->_M_curr_symbol_size;
+      size_type __j = 0;
+      for (; __beg != __end && __j < __len
+      && *__beg == __lc->_M_curr_symbol[__j];
+    ++__beg, (void)++__j);
+      if (__j != __len
+   && (__j || __io.flags() & ios_base::showbase))
+        __testvalid = false;
+    }
+  break;
+       case money_base::sign:
+
+  if (__lc->_M_positive_sign_size && __beg != __end
+      && *__beg == __lc->_M_positive_sign[0])
+    {
+      __sign_size = __lc->_M_positive_sign_size;
+      ++__beg;
+    }
+  else if (__lc->_M_negative_sign_size && __beg != __end
+    && *__beg == __lc->_M_negative_sign[0])
+    {
+      __negative = true;
+      __sign_size = __lc->_M_negative_sign_size;
+      ++__beg;
+    }
+  else if (__lc->_M_positive_sign_size
+    && !__lc->_M_negative_sign_size)
+
+
+    __negative = true;
+  else if (__mandatory_sign)
+    __testvalid = false;
+  break;
+       case money_base::value:
+
+
+  for (; __beg != __end; ++__beg)
+    {
+      const char_type __c = *__beg;
+      const char_type* __q = __traits_type::find(__lit_zero,
+              10, __c);
+      if (__q != 0)
+        {
+   __res += money_base::_S_atoms[__q - __lit];
+   ++__n;
+        }
+      else if (__c == __lc->_M_decimal_point
+        && !__testdecfound)
+        {
+   if (__lc->_M_frac_digits <= 0)
+     break;
+
+   __last_pos = __n;
+   __n = 0;
+   __testdecfound = true;
+        }
+      else if (__lc->_M_use_grouping
+        && __c == __lc->_M_thousands_sep
+        && !__testdecfound)
+        {
+   if (__n)
+     {
+
+       __grouping_tmp += static_cast<char>(__n);
+       __n = 0;
+     }
+   else
+     {
+       __testvalid = false;
+       break;
+     }
+        }
+      else
+        break;
+    }
+  if (__res.empty())
+    __testvalid = false;
+  break;
+       case money_base::space:
+
+  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
+    ++__beg;
+  else
+    __testvalid = false;
+
+       case money_base::none:
+
+  if (__i != 3)
+    for (; __beg != __end
+    && __ctype.is(ctype_base::space, *__beg); ++__beg);
+  break;
+       }
+   }
+
+
+ if (__sign_size > 1 && __testvalid)
+   {
+     const char_type* __sign = __negative ? __lc->_M_negative_sign
+                                          : __lc->_M_positive_sign;
+     size_type __i = 1;
+     for (; __beg != __end && __i < __sign_size
+     && *__beg == __sign[__i]; ++__beg, (void)++__i);
+
+     if (__i != __sign_size)
+       __testvalid = false;
+   }
+
+ if (__testvalid)
+   {
+
+     if (__res.size() > 1)
+       {
+  const size_type __first = __res.find_first_not_of('0');
+  const bool __only_zeros = __first == string::npos;
+  if (__first)
+    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
+       }
+
+
+     if (__negative && __res[0] != '0')
+       __res.insert(__res.begin(), '-');
+
+
+     if (__grouping_tmp.size())
+       {
+
+  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
+                         : __n);
+  if (!std::__verify_grouping(__lc->_M_grouping,
+         __lc->_M_grouping_size,
+         __grouping_tmp))
+    __err |= ios_base::failbit;
+       }
+
+
+     if (__testdecfound && __n != __lc->_M_frac_digits)
+       __testvalid = false;
+   }
+
+
+ if (!__testvalid)
+   __err |= ios_base::failbit;
+ else
+   __units.swap(__res);
+
+
+ if (__beg == __end)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+# 368 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+    ios_base::iostate& __err, long double& __units) const
+    {
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+              : _M_extract<false>(__beg, __end, __io, __err, __str);
+      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+    ios_base::iostate& __err, string_type& __digits) const
+    {
+      typedef typename string::size_type size_type;
+
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+              : _M_extract<false>(__beg, __end, __io, __err, __str);
+      const size_type __len = __str.size();
+      if (__len)
+ {
+   __digits.resize(__len);
+   __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
+ }
+      return __beg;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    template<bool _Intl>
+      _OutIter
+      money_put<_CharT, _OutIter>::
+      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+  const string_type& __digits) const
+      {
+ typedef typename string_type::size_type size_type;
+ typedef money_base::part part;
+ typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+
+ const locale& __loc = __io._M_getloc();
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ __use_cache<__cache_type> __uc;
+ const __cache_type* __lc = __uc(__loc);
+ const char_type* __lit = __lc->_M_atoms;
+
+
+
+ const char_type* __beg = __digits.data();
+
+ money_base::pattern __p;
+ const char_type* __sign;
+ size_type __sign_size;
+ if (!(*__beg == __lit[money_base::_S_minus]))
+   {
+     __p = __lc->_M_pos_format;
+     __sign = __lc->_M_positive_sign;
+     __sign_size = __lc->_M_positive_sign_size;
+   }
+ else
+   {
+     __p = __lc->_M_neg_format;
+     __sign = __lc->_M_negative_sign;
+     __sign_size = __lc->_M_negative_sign_size;
+     if (__digits.size())
+       ++__beg;
+   }
+
+
+ size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
+        __beg + __digits.size()) - __beg;
+ if (__len)
+   {
+
+
+
+     string_type __value;
+     __value.reserve(2 * __len);
+
+
+
+     long __paddec = __len - __lc->_M_frac_digits;
+     if (__paddec > 0)
+         {
+  if (__lc->_M_frac_digits < 0)
+    __paddec = __len;
+    if (__lc->_M_grouping_size)
+      {
+      __value.assign(2 * __paddec, char_type());
+       _CharT* __vend =
+        std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
+       __lc->_M_grouping,
+       __lc->_M_grouping_size,
+       __beg, __beg + __paddec);
+      __value.erase(__vend - &__value[0]);
+      }
+    else
+    __value.assign(__beg, __paddec);
+       }
+
+
+     if (__lc->_M_frac_digits > 0)
+       {
+  __value += __lc->_M_decimal_point;
+  if (__paddec >= 0)
+    __value.append(__beg + __paddec, __lc->_M_frac_digits);
+  else
+    {
+
+      __value.append(-__paddec, __lit[money_base::_S_zero]);
+      __value.append(__beg, __len);
+    }
+         }
+
+
+     const ios_base::fmtflags __f = __io.flags()
+                                    & ios_base::adjustfield;
+     __len = __value.size() + __sign_size;
+     __len += ((__io.flags() & ios_base::showbase)
+        ? __lc->_M_curr_symbol_size : 0);
+
+     string_type __res;
+     __res.reserve(2 * __len);
+
+     const size_type __width = static_cast<size_type>(__io.width());
+     const bool __testipad = (__f == ios_base::internal
+         && __len < __width);
+
+     for (int __i = 0; __i < 4; ++__i)
+       {
+  const part __which = static_cast<part>(__p.field[__i]);
+  switch (__which)
+    {
+    case money_base::symbol:
+      if (__io.flags() & ios_base::showbase)
+        __res.append(__lc->_M_curr_symbol,
+       __lc->_M_curr_symbol_size);
+      break;
+    case money_base::sign:
+
+
+
+      if (__sign_size)
+        __res += __sign[0];
+      break;
+    case money_base::value:
+      __res += __value;
+      break;
+    case money_base::space:
+
+
+
+      if (__testipad)
+        __res.append(__width - __len, __fill);
+      else
+        __res += __fill;
+      break;
+    case money_base::none:
+      if (__testipad)
+        __res.append(__width - __len, __fill);
+      break;
+    }
+       }
+
+
+     if (__sign_size > 1)
+       __res.append(__sign + 1, __sign_size - 1);
+
+
+     __len = __res.size();
+     if (__width > __len)
+       {
+  if (__f == ios_base::left)
+
+    __res.append(__width - __len, __fill);
+  else
+
+    __res.insert(0, __width - __len, __fill);
+  __len = __width;
+       }
+
+
+     __s = std::__write(__s, __res.data(), __len);
+   }
+ __io.width(0);
+ return __s;
+      }
+# 574 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+    long double __units) const
+    {
+      const locale __loc = __io.getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+
+      int __cs_size = 64;
+      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+
+
+      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     "%.*Lf", 0, __units);
+
+      if (__len >= __cs_size)
+ {
+   __cs_size = __len + 1;
+   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     "%.*Lf", 0, __units);
+ }
+# 606 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.tcc" 3
+      string_type __digits(__len, char_type());
+      __ctype.widen(__cs, __cs + __len, &__digits[0]);
+      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+             : _M_insert<false>(__s, __io, __fill, __digits);
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+    const string_type& __digits) const
+    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+             : _M_insert<false>(__s, __io, __fill, __digits); }
+
+}
+
+
+
+
+  template<typename _CharT, typename _InIter>
+    time_base::dateorder
+    time_get<_CharT, _InIter>::do_date_order() const
+    { return time_base::no_order; }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, tm* __tm,
+     const _CharT* __format) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const size_t __len = char_traits<_CharT>::length(__format);
+
+      ios_base::iostate __tmperr = ios_base::goodbit;
+      size_t __i = 0;
+      for (; __beg != __end && __i < __len && !__tmperr; ++__i)
+ {
+   if (__ctype.narrow(__format[__i], 0) == '%')
+     {
+
+       char __c = __ctype.narrow(__format[++__i], 0);
+       int __mem = 0;
+       if (__c == 'E' || __c == 'O')
+  __c = __ctype.narrow(__format[++__i], 0);
+       switch (__c)
+  {
+    const char* __cs;
+    _CharT __wcs[10];
+  case 'a':
+
+    const char_type* __days1[7];
+    __tp._M_days_abbreviated(__days1);
+    __beg = _M_extract_name(__beg, __end, __mem, __days1,
+       7, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_wday = __mem;
+    break;
+  case 'A':
+
+    const char_type* __days2[7];
+    __tp._M_days(__days2);
+    __beg = _M_extract_name(__beg, __end, __mem, __days2,
+       7, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_wday = __mem;
+    break;
+  case 'h':
+  case 'b':
+
+    const char_type* __months1[12];
+    __tp._M_months_abbreviated(__months1);
+    __beg = _M_extract_name(__beg, __end, __mem,
+       __months1, 12, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mon = __mem;
+    break;
+  case 'B':
+
+    const char_type* __months2[12];
+    __tp._M_months(__months2);
+    __beg = _M_extract_name(__beg, __end, __mem,
+       __months2, 12, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mon = __mem;
+    break;
+  case 'c':
+
+    const char_type* __dt[2];
+    __tp._M_date_time_formats(__dt);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __dt[0]);
+    break;
+  case 'd':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 1, 31, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mday = __mem;
+    break;
+  case 'e':
+
+
+    if (__ctype.is(ctype_base::space, *__beg))
+      __beg = _M_extract_num(++__beg, __end, __mem, 1, 9,
+        1, __io, __tmperr);
+    else
+      __beg = _M_extract_num(__beg, __end, __mem, 10, 31,
+        2, __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mday = __mem;
+    break;
+  case 'D':
+
+    __cs = "%m/%d/%y";
+    __ctype.widen(__cs, __cs + 9, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'H':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 23, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_hour = __mem;
+    break;
+  case 'I':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_hour = __mem;
+    break;
+  case 'm':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mon = __mem - 1;
+    break;
+  case 'M':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 59, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_min = __mem;
+    break;
+  case 'n':
+    if (__ctype.narrow(*__beg, 0) == '\n')
+      ++__beg;
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  case 'R':
+
+    __cs = "%H:%M";
+    __ctype.widen(__cs, __cs + 6, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'S':
+
+
+
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 60, 2,
+
+
+
+      __io, __tmperr);
+    if (!__tmperr)
+    __tm->tm_sec = __mem;
+    break;
+  case 't':
+    if (__ctype.narrow(*__beg, 0) == '\t')
+      ++__beg;
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  case 'T':
+
+    __cs = "%H:%M:%S";
+    __ctype.widen(__cs, __cs + 9, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'x':
+
+    const char_type* __dates[2];
+    __tp._M_date_formats(__dates);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __dates[0]);
+    break;
+  case 'X':
+
+    const char_type* __times[2];
+    __tp._M_time_formats(__times);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __times[0]);
+    break;
+  case 'y':
+  case 'C':
+
+  case 'Y':
+
+
+
+
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
+    break;
+  case 'Z':
+
+    if (__ctype.is(ctype_base::upper, *__beg))
+      {
+        int __tmp;
+        __beg = _M_extract_name(__beg, __end, __tmp,
+           __timepunct_cache<_CharT>::_S_timezones,
+           14, __io, __tmperr);
+
+
+        if (__beg != __end && !__tmperr && __tmp == 0
+     && (*__beg == __ctype.widen('-')
+         || *__beg == __ctype.widen('+')))
+   {
+     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
+       __io, __tmperr);
+     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
+       __io, __tmperr);
+   }
+      }
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  default:
+
+    __tmperr |= ios_base::failbit;
+  }
+     }
+   else
+     {
+
+       if (__format[__i] == *__beg)
+  ++__beg;
+       else
+  __tmperr |= ios_base::failbit;
+     }
+ }
+
+      if (__tmperr || __i != __len)
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+     int __min, int __max, size_t __len,
+     ios_base& __io, ios_base::iostate& __err) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+
+      int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
+
+      ++__min;
+      size_t __i = 0;
+      int __value = 0;
+      for (; __beg != __end && __i < __len; ++__beg, (void)++__i)
+ {
+   const char __c = __ctype.narrow(*__beg, '*');
+   if (__c >= '0' && __c <= '9')
+     {
+       __value = __value * 10 + (__c - '0');
+       const int __valuec = __value * __mult;
+       if (__valuec > __max || __valuec + __mult < __min)
+  break;
+       __mult /= 10;
+     }
+   else
+     break;
+ }
+      if (__i == __len)
+ __member = __value;
+
+      else if (__len == 4 && __i == 2)
+ __member = __value - 100;
+      else
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+      const _CharT** __names, size_t __indexlen,
+      ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
+         * __indexlen));
+      size_t __nmatches = 0;
+      size_t __pos = 0;
+      bool __testvalid = true;
+      const char_type* __name;
+
+
+
+
+
+      if (__beg != __end)
+ {
+   const char_type __c = *__beg;
+   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
+     if (__c == __names[__i1][0]
+  || __c == __ctype.toupper(__names[__i1][0]))
+       __matches[__nmatches++] = __i1;
+ }
+
+      while (__nmatches > 1)
+ {
+
+   size_t __minlen = __traits_type::length(__names[__matches[0]]);
+   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
+     __minlen = std::min(__minlen,
+         __traits_type::length(__names[__matches[__i2]]));
+   ++__beg;
+   ++__pos;
+   if (__pos < __minlen && __beg != __end)
+     for (size_t __i3 = 0; __i3 < __nmatches;)
+       {
+  __name = __names[__matches[__i3]];
+  if (!(__name[__pos] == *__beg))
+    __matches[__i3] = __matches[--__nmatches];
+  else
+    ++__i3;
+       }
+   else
+     break;
+ }
+
+      if (__nmatches == 1)
+ {
+
+   ++__beg;
+   ++__pos;
+   __name = __names[__matches[0]];
+   const size_t __len = __traits_type::length(__name);
+   while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
+     ++__beg, (void)++__pos;
+
+   if (__len == __pos)
+     __member = __matches[0];
+   else
+     __testvalid = false;
+ }
+      else
+ __testvalid = false;
+      if (!__testvalid)
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+        const _CharT** __names, size_t __indexlen,
+        ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
+         * __indexlen));
+      size_t __nmatches = 0;
+      size_t* __matches_lengths = 0;
+      size_t __pos = 0;
+
+      if (__beg != __end)
+ {
+   const char_type __c = *__beg;
+   for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
+     if (__c == __names[__i][0]
+  || __c == __ctype.toupper(__names[__i][0]))
+       __matches[__nmatches++] = __i;
+ }
+
+      if (__nmatches)
+ {
+   ++__beg;
+   ++__pos;
+
+   __matches_lengths
+     = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
+          * __nmatches));
+   for (size_t __i = 0; __i < __nmatches; ++__i)
+     __matches_lengths[__i]
+       = __traits_type::length(__names[__matches[__i]]);
+ }
+
+      for (; __beg != __end; ++__beg, (void)++__pos)
+ {
+   size_t __nskipped = 0;
+   const char_type __c = *__beg;
+   for (size_t __i = 0; __i < __nmatches;)
+     {
+       const char_type* __name = __names[__matches[__i]];
+       if (__pos >= __matches_lengths[__i])
+  ++__nskipped, ++__i;
+       else if (!(__name[__pos] == __c))
+  {
+    --__nmatches;
+    __matches[__i] = __matches[__nmatches];
+    __matches_lengths[__i] = __matches_lengths[__nmatches];
+  }
+       else
+  ++__i;
+     }
+   if (__nskipped == __nmatches)
+     break;
+ }
+
+      if ((__nmatches == 1 && __matches_lengths[0] == __pos)
+   || (__nmatches == 2 && (__matches_lengths[0] == __pos
+      || __matches_lengths[1] == __pos)))
+ __member = (__matches[0] >= __indexlen
+      ? __matches[0] - __indexlen : __matches[0]);
+      else
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __times[2];
+      __tp._M_time_formats(__times);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err,
+        __tm, __times[0]);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __dates[2];
+      __tp._M_date_formats(__dates);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err,
+        __tm, __dates[0]);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __days[14];
+      __tp._M_days_abbreviated(__days);
+      __tp._M_days(__days + 7);
+      int __tmpwday;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
+           __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_wday = __tmpwday;
+      else
+ __err |= ios_base::failbit;
+
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+     }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_monthname(iter_type __beg, iter_type __end,
+                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __months[24];
+      __tp._M_months_abbreviated(__months);
+      __tp._M_months(__months + 12);
+      int __tmpmon;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
+           __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_mon = __tmpmon;
+      else
+ __err |= ios_base::failbit;
+
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      int __tmpyear;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
+        __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
+      else
+ __err |= ios_base::failbit;
+
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+
+  template<typename _CharT, typename _InIter>
+    inline
+    _InIter
+    time_get<_CharT, _InIter>::
+    get(iter_type __s, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
+        const char_type* __fmtend) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      __err = ios_base::goodbit;
+      while (__fmt != __fmtend &&
+             __err == ios_base::goodbit)
+        {
+          if (__s == __end)
+            {
+              __err = ios_base::eofbit | ios_base::failbit;
+              break;
+            }
+          else if (__ctype.narrow(*__fmt, 0) == '%')
+            {
+              char __format;
+              char __mod = 0;
+              if (++__fmt == __fmtend)
+                {
+                  __err = ios_base::failbit;
+                  break;
+                }
+              const char __c = __ctype.narrow(*__fmt, 0);
+              if (__c != 'E' && __c != 'O')
+                __format = __c;
+              else if (++__fmt != __fmtend)
+                {
+                  __mod = __c;
+                  __format = __ctype.narrow(*__fmt, 0);
+                }
+              else
+                {
+                  __err = ios_base::failbit;
+                  break;
+                }
+              __s = this->do_get(__s, __end, __io, __err, __tm, __format,
+     __mod);
+              ++__fmt;
+            }
+          else if (__ctype.is(ctype_base::space, *__fmt))
+            {
+              ++__fmt;
+              while (__fmt != __fmtend &&
+                     __ctype.is(ctype_base::space, *__fmt))
+                ++__fmt;
+
+              while (__s != __end &&
+                     __ctype.is(ctype_base::space, *__s))
+                ++__s;
+            }
+
+          else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) ||
+                   __ctype.toupper(*__s) == __ctype.toupper(*__fmt))
+            {
+              ++__s;
+              ++__fmt;
+            }
+          else
+            {
+              __err = ios_base::failbit;
+              break;
+            }
+        }
+      return __s;
+    }
+
+  template<typename _CharT, typename _InIter>
+    inline
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, tm* __tm,
+           char __format, char __mod) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      __err = ios_base::goodbit;
+
+      char_type __fmt[4];
+      __fmt[0] = __ctype.widen('%');
+      if (!__mod)
+        {
+          __fmt[1] = __format;
+          __fmt[2] = char_type();
+        }
+      else
+        {
+          __fmt[1] = __mod;
+          __fmt[2] = __format;
+          __fmt[3] = char_type();
+        }
+
+      __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+ const _CharT* __beg, const _CharT* __end) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      for (; __beg != __end; ++__beg)
+ if (__ctype.narrow(*__beg, 0) != '%')
+   {
+     *__s = *__beg;
+     ++__s;
+   }
+ else if (++__beg != __end)
+   {
+     char __format;
+     char __mod = 0;
+     const char __c = __ctype.narrow(*__beg, 0);
+     if (__c != 'E' && __c != 'O')
+       __format = __c;
+     else if (++__beg != __end)
+       {
+  __mod = __c;
+  __format = __ctype.narrow(*__beg, 0);
+       }
+     else
+       break;
+     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
+   }
+ else
+   break;
+      return __s;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
+    char __format, char __mod) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
+
+
+
+      const size_t __maxlen = 128;
+      char_type __res[__maxlen];
+
+
+
+
+
+
+      char_type __fmt[4];
+      __fmt[0] = __ctype.widen('%');
+      if (!__mod)
+ {
+   __fmt[1] = __format;
+   __fmt[2] = char_type();
+ }
+      else
+ {
+   __fmt[1] = __mod;
+   __fmt[2] = __format;
+   __fmt[3] = char_type();
+ }
+
+      __tp._M_put(__res, __maxlen, __fmt, __tm);
+
+
+      return std::__write(__s, __res, char_traits<char_type>::length(__res));
+    }
+
+
+
+
+
+  extern template class moneypunct<char, false>;
+  extern template class moneypunct<char, true>;
+  extern template class moneypunct_byname<char, false>;
+  extern template class moneypunct_byname<char, true>;
+  extern template class __cxx11:: money_get<char>;
+  extern template class __cxx11:: money_put<char>;
+  extern template class __timepunct<char>;
+  extern template class time_put<char>;
+  extern template class time_put_byname<char>;
+  extern template class time_get<char>;
+  extern template class time_get_byname<char>;
+  extern template class messages<char>;
+  extern template class messages_byname<char>;
+
+  extern template
+    const moneypunct<char, true>&
+    use_facet<moneypunct<char, true> >(const locale&);
+
+  extern template
+    const moneypunct<char, false>&
+    use_facet<moneypunct<char, false> >(const locale&);
+
+  extern template
+    const money_put<char>&
+    use_facet<money_put<char> >(const locale&);
+
+  extern template
+    const money_get<char>&
+    use_facet<money_get<char> >(const locale&);
+
+  extern template
+    const __timepunct<char>&
+    use_facet<__timepunct<char> >(const locale&);
+
+  extern template
+    const time_put<char>&
+    use_facet<time_put<char> >(const locale&);
+
+  extern template
+    const time_get<char>&
+    use_facet<time_get<char> >(const locale&);
+
+  extern template
+    const messages<char>&
+    use_facet<messages<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<moneypunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<__timepunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<messages<char> >(const locale&);
+
+
+  extern template class moneypunct<wchar_t, false>;
+  extern template class moneypunct<wchar_t, true>;
+  extern template class moneypunct_byname<wchar_t, false>;
+  extern template class moneypunct_byname<wchar_t, true>;
+  extern template class __cxx11:: money_get<wchar_t>;
+  extern template class __cxx11:: money_put<wchar_t>;
+  extern template class __timepunct<wchar_t>;
+  extern template class time_put<wchar_t>;
+  extern template class time_put_byname<wchar_t>;
+  extern template class time_get<wchar_t>;
+  extern template class time_get_byname<wchar_t>;
+  extern template class messages<wchar_t>;
+  extern template class messages_byname<wchar_t>;
+
+  extern template
+    const moneypunct<wchar_t, true>&
+    use_facet<moneypunct<wchar_t, true> >(const locale&);
+
+  extern template
+    const moneypunct<wchar_t, false>&
+    use_facet<moneypunct<wchar_t, false> >(const locale&);
+
+  extern template
+    const money_put<wchar_t>&
+    use_facet<money_put<wchar_t> >(const locale&);
+
+  extern template
+    const money_get<wchar_t>&
+    use_facet<money_get<wchar_t> >(const locale&);
+
+  extern template
+    const __timepunct<wchar_t>&
+    use_facet<__timepunct<wchar_t> >(const locale&);
+
+  extern template
+    const time_put<wchar_t>&
+    use_facet<time_put<wchar_t> >(const locale&);
+
+  extern template
+    const time_get<wchar_t>&
+    use_facet<time_get<wchar_t> >(const locale&);
+
+  extern template
+    const messages<wchar_t>&
+    use_facet<messages<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<moneypunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_get<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<__timepunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_get<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<messages<wchar_t> >(const locale&);
+
+
+
+
+}
+# 2016 "/usr/include/c++/10.2.0/bits/locale_facets_nonio.h" 2 3
+# 42 "/usr/include/c++/10.2.0/locale" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/locale_conv.h" 1 3
+# 43 "/usr/include/c++/10.2.0/bits/locale_conv.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+  template<typename _OutStr, typename _InChar, typename _Codecvt,
+    typename _State, typename _Fn>
+    bool
+    __do_str_codecvt(const _InChar* __first, const _InChar* __last,
+       _OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
+       size_t& __count, _Fn __fn)
+    {
+      if (__first == __last)
+ {
+   __outstr.clear();
+   __count = 0;
+   return true;
+ }
+
+      size_t __outchars = 0;
+      auto __next = __first;
+      const auto __maxlen = __cvt.max_length() + 1;
+
+      codecvt_base::result __result;
+      do
+ {
+   __outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
+   auto __outnext = &__outstr.front() + __outchars;
+   auto const __outlast = &__outstr.back() + 1;
+   __result = (__cvt.*__fn)(__state, __next, __last, __next,
+     __outnext, __outlast, __outnext);
+   __outchars = __outnext - &__outstr.front();
+ }
+      while (__result == codecvt_base::partial && __next != __last
+      && (__outstr.size() - __outchars) < __maxlen);
+
+      if (__result == codecvt_base::error)
+ {
+   __count = __next - __first;
+   return false;
+ }
+
+
+
+      if (is_same<typename _Codecvt::intern_type,
+           typename _Codecvt::extern_type>())
+ if (__result == codecvt_base::noconv)
+   {
+     __outstr.assign(__first, __last);
+     __count = __last - __first;
+     return true;
+   }
+
+      __outstr.resize(__outchars);
+      __count = __next - __first;
+      return true;
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_in(const char* __first, const char* __last,
+       basic_string<_CharT, _Traits, _Alloc>& __outstr,
+       const codecvt<_CharT, char, _State>& __cvt,
+       _State& __state, size_t& __count)
+    {
+      using _Codecvt = codecvt<_CharT, char, _State>;
+      using _ConvFn
+ = codecvt_base::result
+   (_Codecvt::*)(_State&, const char*, const char*, const char*&,
+   _CharT*, _CharT*, _CharT*&) const;
+      _ConvFn __fn = &codecvt<_CharT, char, _State>::in;
+      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
+         __count, __fn);
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_in(const char* __first, const char* __last,
+       basic_string<_CharT, _Traits, _Alloc>& __outstr,
+       const codecvt<_CharT, char, _State>& __cvt)
+    {
+      _State __state = {};
+      size_t __n;
+      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_in_all(const char* __first, const char* __last,
+    basic_string<_CharT, _Traits, _Alloc>& __outstr,
+    const codecvt<_CharT, char, _State>& __cvt)
+    {
+      _State __state = {};
+      size_t __n;
+      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n)
+ && (__n == (__last - __first));
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
+        basic_string<char, _Traits, _Alloc>& __outstr,
+        const codecvt<_CharT, char, _State>& __cvt,
+        _State& __state, size_t& __count)
+    {
+      using _Codecvt = codecvt<_CharT, char, _State>;
+      using _ConvFn
+ = codecvt_base::result
+   (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
+   char*, char*, char*&) const;
+      _ConvFn __fn = &codecvt<_CharT, char, _State>::out;
+      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
+         __count, __fn);
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
+        basic_string<char, _Traits, _Alloc>& __outstr,
+        const codecvt<_CharT, char, _State>& __cvt)
+    {
+      _State __state = {};
+      size_t __n;
+      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
+    inline bool
+    __str_codecvt_out_all(const _CharT* __first, const _CharT* __last,
+     basic_string<char, _Traits, _Alloc>& __outstr,
+     const codecvt<_CharT, char, _State>& __cvt)
+    {
+      _State __state = {};
+      size_t __n;
+      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n)
+ && (__n == (__last - __first));
+    }
+# 226 "/usr/include/c++/10.2.0/bits/locale_conv.h" 3
+namespace __cxx11 {
+
+
+  template<typename _Codecvt, typename _Elem = wchar_t,
+    typename _Wide_alloc = allocator<_Elem>,
+    typename _Byte_alloc = allocator<char>>
+    class wstring_convert
+    {
+    public:
+      typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
+      typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
+      typedef typename _Codecvt::state_type state_type;
+      typedef typename wide_string::traits_type::int_type int_type;
+
+
+      wstring_convert() : _M_cvt(new _Codecvt()) { }
+
+
+
+
+
+
+
+      explicit
+      wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt)
+      {
+ if (!_M_cvt)
+   __throw_logic_error("wstring_convert");
+      }
+# 264 "/usr/include/c++/10.2.0/bits/locale_conv.h" 3
+      wstring_convert(_Codecvt* __pcvt, state_type __state)
+      : _M_cvt(__pcvt), _M_state(__state), _M_with_cvtstate(true)
+      {
+ if (!_M_cvt)
+   __throw_logic_error("wstring_convert");
+      }
+
+
+
+
+
+
+      explicit
+      wstring_convert(const byte_string& __byte_err,
+        const wide_string& __wide_err = wide_string())
+      : _M_cvt(new _Codecvt),
+ _M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
+ _M_with_strings(true)
+      {
+ if (!_M_cvt)
+   __throw_logic_error("wstring_convert");
+      }
+
+      ~wstring_convert() = default;
+
+
+
+      wstring_convert(const wstring_convert&) = delete;
+      wstring_convert& operator=(const wstring_convert&) = delete;
+
+
+      wide_string
+      from_bytes(char __byte)
+      {
+ char __bytes[2] = { __byte };
+ return from_bytes(__bytes, __bytes+1);
+      }
+
+      wide_string
+      from_bytes(const char* __ptr)
+      { return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }
+
+      wide_string
+      from_bytes(const byte_string& __str)
+      {
+ auto __ptr = __str.data();
+ return from_bytes(__ptr, __ptr + __str.size());
+      }
+
+      wide_string
+      from_bytes(const char* __first, const char* __last)
+      {
+ if (!_M_with_cvtstate)
+   _M_state = state_type();
+ wide_string __out{ _M_wide_err_string.get_allocator() };
+ if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
+        _M_count))
+   return __out;
+ if (_M_with_strings)
+   return _M_wide_err_string;
+ __throw_range_error("wstring_convert::from_bytes");
+      }
+
+
+
+      byte_string
+      to_bytes(_Elem __wchar)
+      {
+ _Elem __wchars[2] = { __wchar };
+ return to_bytes(__wchars, __wchars+1);
+      }
+
+      byte_string
+      to_bytes(const _Elem* __ptr)
+      {
+ return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
+      }
+
+      byte_string
+      to_bytes(const wide_string& __wstr)
+      {
+ auto __ptr = __wstr.data();
+ return to_bytes(__ptr, __ptr + __wstr.size());
+      }
+
+      byte_string
+      to_bytes(const _Elem* __first, const _Elem* __last)
+      {
+ if (!_M_with_cvtstate)
+   _M_state = state_type();
+ byte_string __out{ _M_byte_err_string.get_allocator() };
+ if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
+         _M_count))
+   return __out;
+ if (_M_with_strings)
+   return _M_byte_err_string;
+ __throw_range_error("wstring_convert::to_bytes");
+      }
+
+
+
+
+
+      size_t converted() const noexcept { return _M_count; }
+
+
+      state_type state() const { return _M_state; }
+
+    private:
+      unique_ptr<_Codecvt> _M_cvt;
+      byte_string _M_byte_err_string;
+      wide_string _M_wide_err_string;
+      state_type _M_state = state_type();
+      size_t _M_count = 0;
+      bool _M_with_cvtstate = false;
+      bool _M_with_strings = false;
+    };
+
+}
+
+
+  template<typename _Codecvt, typename _Elem = wchar_t,
+    typename _Tr = char_traits<_Elem>>
+    class wbuffer_convert : public basic_streambuf<_Elem, _Tr>
+    {
+      typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;
+
+    public:
+      typedef typename _Codecvt::state_type state_type;
+
+
+      wbuffer_convert() : wbuffer_convert(nullptr) { }
+# 405 "/usr/include/c++/10.2.0/bits/locale_conv.h" 3
+      explicit
+      wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt,
+        state_type __state = state_type())
+      : _M_buf(__bytebuf), _M_cvt(__pcvt), _M_state(__state)
+      {
+ if (!_M_cvt)
+   __throw_logic_error("wbuffer_convert");
+
+ _M_always_noconv = _M_cvt->always_noconv();
+
+ if (_M_buf)
+   {
+     this->setp(_M_put_area, _M_put_area + _S_buffer_length);
+     this->setg(_M_get_area + _S_putback_length,
+         _M_get_area + _S_putback_length,
+         _M_get_area + _S_putback_length);
+   }
+      }
+
+      ~wbuffer_convert() = default;
+
+
+
+      wbuffer_convert(const wbuffer_convert&) = delete;
+      wbuffer_convert& operator=(const wbuffer_convert&) = delete;
+
+      streambuf* rdbuf() const noexcept { return _M_buf; }
+
+      streambuf*
+      rdbuf(streambuf *__bytebuf) noexcept
+      {
+ auto __prev = _M_buf;
+ _M_buf = __bytebuf;
+ return __prev;
+      }
+
+
+      state_type state() const noexcept { return _M_state; }
+
+    protected:
+      int
+      sync()
+      { return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }
+
+      typename _Wide_streambuf::int_type
+      overflow(typename _Wide_streambuf::int_type __out)
+      {
+ if (!_M_buf || !_M_conv_put())
+   return _Tr::eof();
+ else if (!_Tr::eq_int_type(__out, _Tr::eof()))
+   return this->sputc(__out);
+ return _Tr::not_eof(__out);
+      }
+
+      typename _Wide_streambuf::int_type
+      underflow()
+      {
+ if (!_M_buf)
+   return _Tr::eof();
+
+ if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
+   return _Tr::to_int_type(*this->gptr());
+ else
+   return _Tr::eof();
+      }
+
+      streamsize
+      xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
+      {
+ if (!_M_buf || __n == 0)
+   return 0;
+ streamsize __done = 0;
+ do
+ {
+   auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
+        __n - __done);
+   _Tr::copy(this->pptr(), __s + __done, __nn);
+   this->pbump(__nn);
+   __done += __nn;
+ } while (__done < __n && _M_conv_put());
+ return __done;
+      }
+
+    private:
+
+      bool
+      _M_conv_get()
+      {
+ const streamsize __pb1 = this->gptr() - this->eback();
+ const streamsize __pb2 = _S_putback_length;
+ const streamsize __npb = std::min(__pb1, __pb2);
+
+ _Tr::move(_M_get_area + _S_putback_length - __npb,
+    this->gptr() - __npb, __npb);
+
+ streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
+ __nbytes = std::min(__nbytes, _M_buf->in_avail());
+ if (__nbytes < 1)
+   __nbytes = 1;
+ __nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
+ if (__nbytes < 1)
+   return false;
+ __nbytes += _M_unconv;
+
+
+
+ _Elem* __outbuf = _M_get_area + _S_putback_length;
+ _Elem* __outnext = __outbuf;
+ const char* __bnext = _M_get_buf;
+
+ codecvt_base::result __result;
+ if (_M_always_noconv)
+   __result = codecvt_base::noconv;
+ else
+   {
+     _Elem* __outend = _M_get_area + _S_buffer_length;
+
+     __result = _M_cvt->in(_M_state,
+      __bnext, __bnext + __nbytes, __bnext,
+      __outbuf, __outend, __outnext);
+   }
+
+ if (__result == codecvt_base::noconv)
+   {
+
+     auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
+     _Tr::copy(__outbuf, __get_buf, __nbytes);
+     _M_unconv = 0;
+     return true;
+   }
+
+ if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
+   char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);
+
+ this->setg(__outbuf, __outbuf, __outnext);
+
+ return __result != codecvt_base::error;
+      }
+
+
+      bool
+      _M_put(...)
+      { return false; }
+
+      bool
+      _M_put(const char* __p, streamsize __n)
+      {
+ if (_M_buf->sputn(__p, __n) < __n)
+   return false;
+ return true;
+      }
+
+
+      bool
+      _M_conv_put()
+      {
+ _Elem* const __first = this->pbase();
+ const _Elem* const __last = this->pptr();
+ const streamsize __pending = __last - __first;
+
+ if (_M_always_noconv)
+   return _M_put(__first, __pending);
+
+ char __outbuf[2 * _S_buffer_length];
+
+ const _Elem* __next = __first;
+ const _Elem* __start;
+ do
+   {
+     __start = __next;
+     char* __outnext = __outbuf;
+     char* const __outlast = __outbuf + sizeof(__outbuf);
+     auto __result = _M_cvt->out(_M_state, __next, __last, __next,
+     __outnext, __outlast, __outnext);
+     if (__result == codecvt_base::error)
+       return false;
+     else if (__result == codecvt_base::noconv)
+       return _M_put(__next, __pending);
+
+     if (!_M_put(__outbuf, __outnext - __outbuf))
+       return false;
+   }
+ while (__next != __last && __next != __start);
+
+ if (__next != __last)
+   _Tr::move(__first, __next, __last - __next);
+
+ this->pbump(__first - __next);
+ return __next != __first;
+      }
+
+      streambuf* _M_buf;
+      unique_ptr<_Codecvt> _M_cvt;
+      state_type _M_state;
+
+      static const streamsize _S_buffer_length = 32;
+      static const streamsize _S_putback_length = 3;
+      _Elem _M_put_area[_S_buffer_length];
+      _Elem _M_get_area[_S_buffer_length];
+      streamsize _M_unconv = 0;
+      char _M_get_buf[_S_buffer_length-_S_putback_length];
+      bool _M_always_noconv;
+    };
+
+
+
+
+
+
+}
+# 44 "/usr/include/c++/10.2.0/locale" 2 3
+# 44 "/usr/include/c++/10.2.0/iomanip" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/quoted_string.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/quoted_string.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/quoted_string.h" 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/sstream" 1 3
+# 36 "/usr/include/c++/10.2.0/sstream" 3
+       
+# 37 "/usr/include/c++/10.2.0/sstream" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+namespace __cxx11 {
+# 64 "/usr/include/c++/10.2.0/sstream" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
+    {
+      struct __xfer_bufptrs;
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_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;
+      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+
+    protected:
+
+      ios_base::openmode _M_mode;
+
+
+      __string_type _M_string;
+
+    public:
+# 99 "/usr/include/c++/10.2.0/sstream" 3
+      basic_stringbuf()
+      : __streambuf_type(), _M_mode(ios_base::in | ios_base::out), _M_string()
+      { }
+# 110 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_stringbuf(ios_base::openmode __mode)
+      : __streambuf_type(), _M_mode(__mode), _M_string()
+      { }
+# 123 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_stringbuf(const __string_type& __str,
+        ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(),
+ _M_string(__str.data(), __str.size(), __str.get_allocator())
+      { _M_stringbuf_init(__mode); }
+
+
+      basic_stringbuf(const basic_stringbuf&) = delete;
+
+      basic_stringbuf(basic_stringbuf&& __rhs)
+      : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
+      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }
+
+
+
+      basic_stringbuf&
+      operator=(const basic_stringbuf&) = delete;
+
+      basic_stringbuf&
+      operator=(basic_stringbuf&& __rhs)
+      {
+ __xfer_bufptrs __st{__rhs, this};
+ const __streambuf_type& __base = __rhs;
+ __streambuf_type::operator=(__base);
+ this->pubimbue(__rhs.getloc());
+ _M_mode = __rhs._M_mode;
+ _M_string = std::move(__rhs._M_string);
+ __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
+ return *this;
+      }
+
+      void
+      swap(basic_stringbuf& __rhs)
+      {
+ __xfer_bufptrs __l_st{*this, std::__addressof(__rhs)};
+ __xfer_bufptrs __r_st{__rhs, this};
+ __streambuf_type& __base = __rhs;
+ __streambuf_type::swap(__base);
+ __rhs.pubimbue(this->pubimbue(__rhs.getloc()));
+ std::swap(_M_mode, __rhs._M_mode);
+ std::swap(_M_string, __rhs._M_string);
+      }
+# 177 "/usr/include/c++/10.2.0/sstream" 3
+      __string_type
+      str() const
+      {
+ __string_type __ret(_M_string.get_allocator());
+ if (this->pptr())
+   {
+
+     if (this->pptr() > this->egptr())
+       __ret.assign(this->pbase(), this->pptr());
+     else
+       __ret.assign(this->pbase(), this->egptr());
+   }
+ else
+   __ret = _M_string;
+ return __ret;
+      }
+# 201 "/usr/include/c++/10.2.0/sstream" 3
+      void
+      str(const __string_type& __s)
+      {
+
+
+ _M_string.assign(__s.data(), __s.size());
+ _M_stringbuf_init(_M_mode);
+      }
+
+    protected:
+
+      void
+      _M_stringbuf_init(ios_base::openmode __mode)
+      {
+ _M_mode = __mode;
+ __size_type __len = 0;
+ if (_M_mode & (ios_base::ate | ios_base::app))
+   __len = _M_string.size();
+ _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
+      }
+
+      virtual streamsize
+      showmanyc()
+      {
+ streamsize __ret = -1;
+ if (_M_mode & ios_base::in)
+   {
+     _M_update_egptr();
+     __ret = this->egptr() - this->gptr();
+   }
+ return __ret;
+      }
+
+      virtual int_type
+      underflow();
+
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof());
+
+      virtual int_type
+      overflow(int_type __c = traits_type::eof());
+# 254 "/usr/include/c++/10.2.0/sstream" 3
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n)
+      {
+ if (__s && __n >= 0)
+   {
+
+
+
+
+
+
+     _M_string.clear();
+
+
+     _M_sync(__s, __n, 0);
+   }
+ return this;
+      }
+
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      virtual pos_type
+      seekpos(pos_type __sp,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+
+
+
+      void
+      _M_sync(char_type* __base, __size_type __i, __size_type __o);
+
+
+
+      void
+      _M_update_egptr()
+      {
+ const bool __testin = _M_mode & ios_base::in;
+ if (this->pptr() && this->pptr() > this->egptr())
+   {
+     if (__testin)
+       this->setg(this->eback(), this->gptr(), this->pptr());
+     else
+       this->setg(this->pptr(), this->pptr(), this->pptr());
+   }
+      }
+
+
+
+      void
+      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);
+
+    private:
+
+
+
+
+      struct __xfer_bufptrs
+      {
+ __xfer_bufptrs(const basic_stringbuf& __from, basic_stringbuf* __to)
+ : _M_to{__to}, _M_goff{-1, -1, -1}, _M_poff{-1, -1, -1}
+ {
+   const _CharT* const __str = __from._M_string.data();
+   const _CharT* __end = nullptr;
+   if (__from.eback())
+     {
+       _M_goff[0] = __from.eback() - __str;
+       _M_goff[1] = __from.gptr() - __str;
+       _M_goff[2] = __from.egptr() - __str;
+       __end = __from.egptr();
+     }
+   if (__from.pbase())
+     {
+       _M_poff[0] = __from.pbase() - __str;
+       _M_poff[1] = __from.pptr() - __from.pbase();
+       _M_poff[2] = __from.epptr() - __str;
+       if (__from.pptr() > __end)
+  __end = __from.pptr();
+     }
+
+
+   if (__end)
+     {
+
+
+       auto& __mut_from = const_cast<basic_stringbuf&>(__from);
+       __mut_from._M_string._M_length(__end - __str);
+     }
+ }
+
+ ~__xfer_bufptrs()
+ {
+   char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
+   if (_M_goff[0] != -1)
+     _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
+   if (_M_poff[0] != -1)
+     _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
+ }
+
+ basic_stringbuf* _M_to;
+ off_type _M_goff[3];
+ off_type _M_poff[3];
+      };
+# 368 "/usr/include/c++/10.2.0/sstream" 3
+      basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
+      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
+      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
+      { }
+
+    };
+# 391 "/usr/include/c++/10.2.0/sstream" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_istringstream : public basic_istream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_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_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_istream<char_type, traits_type> __istream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 425 "/usr/include/c++/10.2.0/sstream" 3
+      basic_istringstream()
+      : __istream_type(), _M_stringbuf(ios_base::in)
+      { this->init(&_M_stringbuf); }
+# 441 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_istringstream(ios_base::openmode __mode)
+      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+# 459 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_istringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_istringstream()
+      { }
+
+
+      basic_istringstream(const basic_istringstream&) = delete;
+
+      basic_istringstream(basic_istringstream&& __rhs)
+      : __istream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __istream_type::set_rdbuf(&_M_stringbuf); }
+
+
+
+      basic_istringstream&
+      operator=(const basic_istringstream&) = delete;
+
+      basic_istringstream&
+      operator=(basic_istringstream&& __rhs)
+      {
+ __istream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+
+      void
+      swap(basic_istringstream& __rhs)
+      {
+ __istream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+# 510 "/usr/include/c++/10.2.0/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+# 549 "/usr/include/c++/10.2.0/sstream" 3
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_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_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_ostream<char_type, traits_type> __ostream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 583 "/usr/include/c++/10.2.0/sstream" 3
+      basic_ostringstream()
+      : __ostream_type(), _M_stringbuf(ios_base::out)
+      { this->init(&_M_stringbuf); }
+# 599 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_ostringstream(ios_base::openmode __mode)
+      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+# 617 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_ostringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_ostringstream()
+      { }
+
+
+      basic_ostringstream(const basic_ostringstream&) = delete;
+
+      basic_ostringstream(basic_ostringstream&& __rhs)
+      : __ostream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __ostream_type::set_rdbuf(&_M_stringbuf); }
+
+
+
+      basic_ostringstream&
+      operator=(const basic_ostringstream&) = delete;
+
+      basic_ostringstream&
+      operator=(basic_ostringstream&& __rhs)
+      {
+ __ostream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+
+      void
+      swap(basic_ostringstream& __rhs)
+      {
+ __ostream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+# 668 "/usr/include/c++/10.2.0/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+# 707 "/usr/include/c++/10.2.0/sstream" 3
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringstream : public basic_iostream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_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_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_iostream<char_type, traits_type> __iostream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 741 "/usr/include/c++/10.2.0/sstream" 3
+      basic_stringstream()
+      : __iostream_type(), _M_stringbuf(ios_base::out | ios_base::in)
+      { this->init(&_M_stringbuf); }
+# 755 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_stringstream(ios_base::openmode __m)
+      : __iostream_type(), _M_stringbuf(__m)
+      { this->init(&_M_stringbuf); }
+# 771 "/usr/include/c++/10.2.0/sstream" 3
+      explicit
+      basic_stringstream(const __string_type& __str,
+    ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__str, __m)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_stringstream()
+      { }
+
+
+      basic_stringstream(const basic_stringstream&) = delete;
+
+      basic_stringstream(basic_stringstream&& __rhs)
+      : __iostream_type(std::move(__rhs)),
+      _M_stringbuf(std::move(__rhs._M_stringbuf))
+      { __iostream_type::set_rdbuf(&_M_stringbuf); }
+
+
+
+      basic_stringstream&
+      operator=(const basic_stringstream&) = delete;
+
+      basic_stringstream&
+      operator=(basic_stringstream&& __rhs)
+      {
+ __iostream_type::operator=(std::move(__rhs));
+ _M_stringbuf = std::move(__rhs._M_stringbuf);
+ return *this;
+      }
+
+      void
+      swap(basic_stringstream& __rhs)
+      {
+ __iostream_type::swap(__rhs);
+ _M_stringbuf.swap(__rhs._M_stringbuf);
+      }
+# 822 "/usr/include/c++/10.2.0/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
+  basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_istringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits, class _Allocator>
+    inline void
+    swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
+  basic_stringstream<_CharT, _Traits, _Allocator>& __y)
+    { __x.swap(__y); }
+
+
+}
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/sstream.tcc" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/sstream.tcc" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/sstream.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    pbackfail(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      if (this->eback() < this->gptr())
+ {
+
+
+   const bool __testeof = traits_type::eq_int_type(__c, __ret);
+   if (!__testeof)
+     {
+       const bool __testeq = traits_type::eq(traits_type::
+          to_char_type(__c),
+          this->gptr()[-1]);
+       const bool __testout = this->_M_mode & ios_base::out;
+       if (__testeq || __testout)
+  {
+    this->gbump(-1);
+    if (!__testeq)
+      *this->gptr() = traits_type::to_char_type(__c);
+    __ret = __c;
+  }
+     }
+   else
+     {
+       this->gbump(-1);
+       __ret = traits_type::not_eof(__c);
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    overflow(int_type __c)
+    {
+      const bool __testout = this->_M_mode & ios_base::out;
+      if (__builtin_expect(!__testout, false))
+ return traits_type::eof();
+
+      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
+      if (__builtin_expect(__testeof, false))
+ return traits_type::not_eof(__c);
+
+      const __size_type __capacity = _M_string.capacity();
+
+
+      if ((this->epptr() - this->pbase()) < __capacity)
+ {
+
+   char_type* __base = const_cast<char_type*>(_M_string.data());
+   _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase());
+   if (_M_mode & ios_base::in)
+     {
+       const __size_type __nget = this->gptr() - this->eback();
+       const __size_type __eget = this->egptr() - this->eback();
+       this->setg(__base, __base + __nget, __base + __eget + 1);
+     }
+   *this->pptr() = traits_type::to_char_type(__c);
+   this->pbump(1);
+   return __c;
+ }
+
+
+      const __size_type __max_size = _M_string.max_size();
+      const bool __testput = this->pptr() < this->epptr();
+      if (__builtin_expect(!__testput && __capacity == __max_size, false))
+ return traits_type::eof();
+
+
+
+      const char_type __conv = traits_type::to_char_type(__c);
+      if (!__testput)
+ {
+# 129 "/usr/include/c++/10.2.0/bits/sstream.tcc" 3
+   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
+       __size_type(512));
+   const __size_type __len = std::min(__opt_len, __max_size);
+   __string_type __tmp(_M_string.get_allocator());
+   __tmp.reserve(__len);
+   if (this->pbase())
+     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
+   __tmp.push_back(__conv);
+   _M_string.swap(__tmp);
+   _M_sync(const_cast<char_type*>(_M_string.data()),
+    this->gptr() - this->eback(), this->pptr() - this->pbase());
+ }
+      else
+ *this->pptr() = __conv;
+      this->pbump(1);
+      return __c;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = this->_M_mode & ios_base::in;
+      if (__testin)
+ {
+
+   _M_update_egptr();
+
+   if (this->gptr() < this->egptr())
+     __ret = traits_type::to_int_type(*this->gptr());
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+      const bool __testboth = __testin && __testout && __way != ios_base::cur;
+      __testin &= !(__mode & ios_base::out);
+      __testout &= !(__mode & ios_base::in);
+
+
+
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !__off) && (__testin || __testout || __testboth))
+ {
+   _M_update_egptr();
+
+   off_type __newoffi = __off;
+   off_type __newoffo = __newoffi;
+   if (__way == ios_base::cur)
+     {
+       __newoffi += this->gptr() - __beg;
+       __newoffo += this->pptr() - __beg;
+     }
+   else if (__way == ios_base::end)
+     __newoffo = __newoffi += this->egptr() - __beg;
+
+   if ((__testin || __testboth)
+       && __newoffi >= 0
+       && this->egptr() - __beg >= __newoffi)
+     {
+       this->setg(this->eback(), this->eback() + __newoffi,
+    this->egptr());
+       __ret = pos_type(__newoffi);
+     }
+   if ((__testout || __testboth)
+       && __newoffo >= 0
+       && this->egptr() - __beg >= __newoffo)
+     {
+       _M_pbump(this->pbase(), this->epptr(), __newoffo);
+       __ret = pos_type(__newoffo);
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekpos(pos_type __sp, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !off_type(__sp)) && (__testin || __testout))
+ {
+   _M_update_egptr();
+
+   const off_type __pos(__sp);
+   const bool __testpos = (0 <= __pos
+      && __pos <= this->egptr() - __beg);
+   if (__testpos)
+     {
+       if (__testin)
+  this->setg(this->eback(), this->eback() + __pos,
+      this->egptr());
+       if (__testout)
+  _M_pbump(this->pbase(), this->epptr(), __pos);
+       __ret = __sp;
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_sync(char_type* __base, __size_type __i, __size_type __o)
+    {
+      const bool __testin = _M_mode & ios_base::in;
+      const bool __testout = _M_mode & ios_base::out;
+      char_type* __endg = __base + _M_string.size();
+      char_type* __endp = __base + _M_string.capacity();
+
+      if (__base != _M_string.data())
+ {
+
+   __endg += __i;
+   __i = 0;
+   __endp = __endg;
+ }
+
+      if (__testin)
+ this->setg(__base, __base + __i, __endg);
+      if (__testout)
+ {
+   _M_pbump(__base, __endp, __o);
+
+
+
+   if (!__testin)
+     this->setg(__endg, __endg, __endg);
+ }
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
+    {
+      this->setp(__pbeg, __pend);
+      while (__off > __gnu_cxx::__numeric_traits<int>::__max)
+ {
+   this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
+   __off -= __gnu_cxx::__numeric_traits<int>::__max;
+ }
+      this->pbump(__off);
+    }
+
+
+
+
+  extern template class basic_stringbuf<char>;
+  extern template class basic_istringstream<char>;
+  extern template class basic_ostringstream<char>;
+  extern template class basic_stringstream<char>;
+
+
+  extern template class basic_stringbuf<wchar_t>;
+  extern template class basic_istringstream<wchar_t>;
+  extern template class basic_ostringstream<wchar_t>;
+  extern template class basic_stringstream<wchar_t>;
+
+
+
+
+}
+# 880 "/usr/include/c++/10.2.0/sstream" 2 3
+# 39 "/usr/include/c++/10.2.0/bits/quoted_string.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  namespace __detail {
+
+
+
+    template<typename _String, typename _CharT>
+      struct _Quoted_string
+      {
+ static_assert(is_reference<_String>::value
+     || is_pointer<_String>::value,
+        "String type must be pointer or reference");
+
+ _Quoted_string(_String __str, _CharT __del, _CharT __esc)
+ : _M_string(__str), _M_delim{__del}, _M_escape{__esc}
+ { }
+
+ _Quoted_string&
+ operator=(_Quoted_string&) = delete;
+
+ _String _M_string;
+ _CharT _M_delim;
+ _CharT _M_escape;
+      };
+# 91 "/usr/include/c++/10.2.0/bits/quoted_string.h" 3
+    template<typename _CharT, typename _Traits>
+      std::basic_ostream<_CharT, _Traits>&
+      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+   const _Quoted_string<const _CharT*, _CharT>& __str)
+      {
+ std::basic_ostringstream<_CharT, _Traits> __ostr;
+ __ostr << __str._M_delim;
+ for (const _CharT* __c = __str._M_string; *__c; ++__c)
+   {
+     if (*__c == __str._M_delim || *__c == __str._M_escape)
+       __ostr << __str._M_escape;
+     __ostr << *__c;
+   }
+ __ostr << __str._M_delim;
+
+ return __os << __ostr.str();
+      }
+
+
+
+
+
+
+
+    template<typename _CharT, typename _Traits, typename _String>
+      std::basic_ostream<_CharT, _Traits>&
+      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+   const _Quoted_string<_String, _CharT>& __str)
+      {
+ std::basic_ostringstream<_CharT, _Traits> __ostr;
+ __ostr << __str._M_delim;
+ for (auto __c : __str._M_string)
+   {
+     if (__c == __str._M_delim || __c == __str._M_escape)
+       __ostr << __str._M_escape;
+     __ostr << __c;
+   }
+ __ostr << __str._M_delim;
+
+ return __os << __ostr.str();
+      }
+
+
+
+
+
+    template<typename _CharT, typename _Traits, typename _Alloc>
+      std::basic_istream<_CharT, _Traits>&
+      operator>>(std::basic_istream<_CharT, _Traits>& __is,
+   const _Quoted_string<basic_string<_CharT, _Traits, _Alloc>&,
+          _CharT>& __str)
+      {
+ _CharT __c;
+ __is >> __c;
+ if (!__is.good())
+   return __is;
+ if (__c != __str._M_delim)
+   {
+     __is.unget();
+     __is >> __str._M_string;
+     return __is;
+   }
+ __str._M_string.clear();
+ std::ios_base::fmtflags __flags
+   = __is.flags(__is.flags() & ~std::ios_base::skipws);
+ do
+   {
+     __is >> __c;
+     if (!__is.good())
+       break;
+     if (__c == __str._M_escape)
+       {
+  __is >> __c;
+  if (!__is.good())
+    break;
+       }
+     else if (__c == __str._M_delim)
+       break;
+     __str._M_string += __c;
+   }
+ while (true);
+ __is.setf(__flags);
+
+ return __is;
+      }
+  }
+
+
+}
+# 46 "/usr/include/c++/10.2.0/iomanip" 2 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+  struct _Resetiosflags { ios_base::fmtflags _M_mask; };
+# 65 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Resetiosflags
+  resetiosflags(ios_base::fmtflags __mask)
+  { return { __mask }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
+    {
+      __is.setf(ios_base::fmtflags(0), __f._M_mask);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
+    {
+      __os.setf(ios_base::fmtflags(0), __f._M_mask);
+      return __os;
+    }
+
+
+  struct _Setiosflags { ios_base::fmtflags _M_mask; };
+# 95 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Setiosflags
+  setiosflags(ios_base::fmtflags __mask)
+  { return { __mask }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
+    {
+      __is.setf(__f._M_mask);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
+    {
+      __os.setf(__f._M_mask);
+      return __os;
+    }
+
+
+  struct _Setbase { int _M_base; };
+# 126 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Setbase
+  setbase(int __base)
+  { return { __base }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
+    {
+      __is.setf(__f._M_base == 8 ? ios_base::oct :
+  __f._M_base == 10 ? ios_base::dec :
+  __f._M_base == 16 ? ios_base::hex :
+  ios_base::fmtflags(0), ios_base::basefield);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
+    {
+      __os.setf(__f._M_base == 8 ? ios_base::oct :
+  __f._M_base == 10 ? ios_base::dec :
+  __f._M_base == 16 ? ios_base::hex :
+  ios_base::fmtflags(0), ios_base::basefield);
+      return __os;
+    }
+
+
+  template<typename _CharT>
+    struct _Setfill { _CharT _M_c; };
+# 163 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _CharT>
+    inline _Setfill<_CharT>
+    setfill(_CharT __c)
+    { return { __c }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
+    {
+      __is.fill(__f._M_c);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
+    {
+      __os.fill(__f._M_c);
+      return __os;
+    }
+
+
+  struct _Setprecision { int _M_n; };
+# 194 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Setprecision
+  setprecision(int __n)
+  { return { __n }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
+    {
+      __is.precision(__f._M_n);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
+    {
+      __os.precision(__f._M_n);
+      return __os;
+    }
+
+
+  struct _Setw { int _M_n; };
+# 224 "/usr/include/c++/10.2.0/iomanip" 3
+  inline _Setw
+  setw(int __n)
+  { return { __n }; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
+    {
+      __is.width(__f._M_n);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
+    {
+      __os.width(__f._M_n);
+      return __os;
+    }
+
+
+
+  template<typename _MoneyT>
+    struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
+# 257 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _MoneyT>
+    inline _Get_money<_MoneyT>
+    get_money(_MoneyT& __mon, bool __intl = false)
+    { return { __mon, __intl }; }
+
+  template<typename _CharT, typename _Traits, typename _MoneyT>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f)
+    {
+      typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       typedef istreambuf_iterator<_CharT, _Traits> _Iter;
+       typedef money_get<_CharT, _Iter> _MoneyGet;
+
+       const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc());
+       __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl,
+         __is, __err, __f._M_mon);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __is._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __is._M_setstate(ios_base::badbit); }
+   if (__err)
+     __is.setstate(__err);
+ }
+      return __is;
+    }
+
+
+  template<typename _MoneyT>
+    struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
+# 304 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _MoneyT>
+    inline _Put_money<_MoneyT>
+    put_money(const _MoneyT& __mon, bool __intl = false)
+    { return { __mon, __intl }; }
+
+  template<typename _CharT, typename _Traits, typename _MoneyT>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
+    {
+      typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
+       typedef money_put<_CharT, _Iter> _MoneyPut;
+
+       const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc());
+       if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os,
+      __os.fill(), __f._M_mon).failed())
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __os._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __os._M_setstate(ios_base::badbit); }
+   if (__err)
+     __os.setstate(__err);
+ }
+      return __os;
+    }
+
+  template<typename _CharT>
+    struct _Put_time
+    {
+      const std::tm* _M_tmb;
+      const _CharT* _M_fmt;
+    };
+# 356 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _CharT>
+    inline _Put_time<_CharT>
+    put_time(const std::tm* __tmb, const _CharT* __fmt)
+    { return { __tmb, __fmt }; }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_time<_CharT> __f)
+    {
+      typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
+      if (__cerb)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
+              typedef time_put<_CharT, _Iter> _TimePut;
+
+              const _CharT* const __fmt_end = __f._M_fmt +
+                _Traits::length(__f._M_fmt);
+
+              const _TimePut& __mp = use_facet<_TimePut>(__os.getloc());
+              if (__mp.put(_Iter(__os.rdbuf()), __os, __os.fill(),
+                           __f._M_tmb, __f._M_fmt, __fmt_end).failed())
+                __err |= ios_base::badbit;
+            }
+          catch(__cxxabiv1::__forced_unwind&)
+            {
+              __os._M_setstate(ios_base::badbit);
+              throw;
+            }
+          catch(...)
+            { __os._M_setstate(ios_base::badbit); }
+          if (__err)
+            __os.setstate(__err);
+        }
+      return __os;
+    }
+
+  template<typename _CharT>
+    struct _Get_time
+    {
+      std::tm* _M_tmb;
+      const _CharT* _M_fmt;
+    };
+# 411 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _CharT>
+    inline _Get_time<_CharT>
+    get_time(std::tm* __tmb, const _CharT* __fmt)
+    { return { __tmb, __fmt }; }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Get_time<_CharT> __f)
+    {
+      typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
+      if (__cerb)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              typedef istreambuf_iterator<_CharT, _Traits> _Iter;
+              typedef time_get<_CharT, _Iter> _TimeGet;
+
+              const _CharT* const __fmt_end = __f._M_fmt +
+                _Traits::length(__f._M_fmt);
+
+              const _TimeGet& __mg = use_facet<_TimeGet>(__is.getloc());
+              __mg.get(_Iter(__is.rdbuf()), _Iter(), __is,
+                       __err, __f._M_tmb, __f._M_fmt, __fmt_end);
+            }
+          catch(__cxxabiv1::__forced_unwind&)
+            {
+              __is._M_setstate(ios_base::badbit);
+              throw;
+            }
+          catch(...)
+            { __is._M_setstate(ios_base::badbit); }
+          if (__err)
+            __is.setstate(__err);
+        }
+      return __is;
+    }
+# 459 "/usr/include/c++/10.2.0/iomanip" 3
+  template<typename _CharT>
+    inline auto
+    quoted(const _CharT* __string,
+    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<const _CharT*, _CharT>(__string, __delim,
+            __escape);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline auto
+    quoted(const basic_string<_CharT, _Traits, _Alloc>& __string,
+    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<
+ const basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
+     __string, __delim, __escape);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline auto
+    quoted(basic_string<_CharT, _Traits, _Alloc>& __string,
+    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
+    {
+      return __detail::_Quoted_string<
+ basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
+     __string, __delim, __escape);
+    }
+# 508 "/usr/include/c++/10.2.0/iomanip" 3
+  extern template ostream& operator<<(ostream&, _Setfill<char>);
+  extern template ostream& operator<<(ostream&, _Setiosflags);
+  extern template ostream& operator<<(ostream&, _Resetiosflags);
+  extern template ostream& operator<<(ostream&, _Setbase);
+  extern template ostream& operator<<(ostream&, _Setprecision);
+  extern template ostream& operator<<(ostream&, _Setw);
+  extern template istream& operator>>(istream&, _Setfill<char>);
+  extern template istream& operator>>(istream&, _Setiosflags);
+  extern template istream& operator>>(istream&, _Resetiosflags);
+  extern template istream& operator>>(istream&, _Setbase);
+  extern template istream& operator>>(istream&, _Setprecision);
+  extern template istream& operator>>(istream&, _Setw);
+
+
+  extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
+  extern template wostream& operator<<(wostream&, _Setiosflags);
+  extern template wostream& operator<<(wostream&, _Resetiosflags);
+  extern template wostream& operator<<(wostream&, _Setbase);
+  extern template wostream& operator<<(wostream&, _Setprecision);
+  extern template wostream& operator<<(wostream&, _Setw);
+  extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
+  extern template wistream& operator>>(wistream&, _Setiosflags);
+  extern template wistream& operator>>(wistream&, _Resetiosflags);
+  extern template wistream& operator>>(wistream&, _Setbase);
+  extern template wistream& operator>>(wistream&, _Setprecision);
+  extern template wistream& operator>>(wistream&, _Setw);
+
+
+
+
+}
+# 28 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+# 1 "/usr/include/c++/10.2.0/iostream" 1 3
+# 36 "/usr/include/c++/10.2.0/iostream" 3
+       
+# 37 "/usr/include/c++/10.2.0/iostream" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 60 "/usr/include/c++/10.2.0/iostream" 3
+  extern istream cin;
+  extern ostream cout;
+  extern ostream cerr;
+  extern ostream clog;
+
+
+  extern wistream wcin;
+  extern wostream wcout;
+  extern wostream wcerr;
+  extern wostream wclog;
+
+
+
+
+  static ios_base::Init __ioinit;
+
+
+}
+# 29 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h" 2
+
+
+
+
+# 32 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiserTraits.h"
+template<typename T> struct DataSerializerTraits_t
+{
+    static void encode(OpenRCT2::IStream* stream, const T& v) = delete;
+    static void decode(OpenRCT2::IStream* stream, T& val) = delete;
+    static void log(OpenRCT2::IStream* stream, const T& val) = delete;
+};
+
+template<typename T> struct DataSerializerTraits_enum
+{
+    static void encode(OpenRCT2::IStream* stream, const T& val)
+    {
+        stream->Write(&val);
+    }
+    static void decode(OpenRCT2::IStream* stream, T& val)
+    {
+        stream->Read(&val);
+    }
+    static void log(OpenRCT2::IStream* stream, const T& val)
+    {
+        using underlying = std::underlying_type_t<T>;
+        std::stringstream ss;
+        ss << std::hex << std::setw(sizeof(underlying) * 2) << std::setfill('0') << static_cast<underlying>(val);
+
+        std::string str = ss.str();
+        stream->Write(str.c_str(), str.size());
+    }
+};
+
+template<typename T>
+using DataSerializerTraits = std::conditional_t<std::is_enum_v<T>, DataSerializerTraits_enum<T>, DataSerializerTraits_t<T>>;
+
+template<typename T> struct DataSerializerTraitsIntegral
+{
+    static void encode(OpenRCT2::IStream* stream, const T& val)
+    {
+        T temp = ByteSwapBE(val);
+        stream->Write(&temp);
+    }
+    static void decode(OpenRCT2::IStream* stream, T& val)
+    {
+        T temp;
+        stream->Read(&temp);
+        val = ByteSwapBE(temp);
+    }
+    static void log(OpenRCT2::IStream* stream, const T& val)
+    {
+        std::stringstream ss;
+        ss << std::hex << std::setw(sizeof(T) * 2) << std::setfill('0') << +val;
+
+        std::string str = ss.str();
+        stream->Write(str.c_str(), str.size());
+    }
+};
+
+template<> struct DataSerializerTraits_t<bool>
+{
+    static void encode(OpenRCT2::IStream* stream, const bool& val)
+    {
+        stream->Write(&val);
+    }
+    static void decode(OpenRCT2::IStream* stream, bool& val)
+    {
+        stream->Read(&val);
+    }
+    static void log(OpenRCT2::IStream* stream, const bool& val)
+    {
+        if (val)
+            stream->Write("true", 4);
+        else
+            stream->Write("false", 5);
+    }
+};
+
+template<> struct DataSerializerTraits_t<uint8_t> : public DataSerializerTraitsIntegral<uint8_t>
+{
+};
+
+template<> struct DataSerializerTraits_t<int8_t> : public DataSerializerTraitsIntegral<int8_t>
+{
+};
+
+template<> struct DataSerializerTraits_t<utf8> : public DataSerializerTraitsIntegral<utf8>
+{
+};
+
+template<> struct DataSerializerTraits_t<uint16_t> : public DataSerializerTraitsIntegral<uint16_t>
+{
+};
+
+template<> struct DataSerializerTraits_t<int16_t> : public DataSerializerTraitsIntegral<int16_t>
+{
+};
+
+template<> struct DataSerializerTraits_t<uint32_t> : public DataSerializerTraitsIntegral<uint32_t>
+{
+};
+
+template<> struct DataSerializerTraits_t<int32_t> : public DataSerializerTraitsIntegral<int32_t>
+{
+};
+
+template<> struct DataSerializerTraits_t<uint64_t> : public DataSerializerTraitsIntegral<uint64_t>
+{
+};
+
+template<> struct DataSerializerTraits_t<int64_t> : public DataSerializerTraitsIntegral<int64_t>
+{
+};
+
+template<> struct DataSerializerTraits_t<std::string>
+{
+    static void encode(OpenRCT2::IStream* stream, const std::string& str)
+    {
+        uint16_t len = static_cast<uint16_t>(str.size());
+        uint16_t swapped = ByteSwapBE(len);
+        stream->Write(&swapped);
+        if (len == 0)
+        {
+            return;
+        }
+        stream->WriteArray(str.c_str(), len);
+    }
+    static void decode(OpenRCT2::IStream* stream, std::string& res)
+    {
+        uint16_t len;
+        stream->Read(&len);
+        len = ByteSwapBE(len);
+        if (len == 0)
+        {
+            res = "";
+            return;
+        }
+        auto str = stream->ReadArray<char>(len);
+        res.assign(str.get(), len);
+    }
+    static void log(OpenRCT2::IStream* stream, const std::string& str)
+    {
+        stream->Write("\"", 1);
+        if (str.size() != 0)
+        {
+            stream->Write(str.data(), str.size());
+        }
+        stream->Write("\"", 1);
+    }
+};
+
+template<> struct DataSerializerTraits_t<NetworkPlayerId_t>
+{
+    static void encode(OpenRCT2::IStream* stream, const NetworkPlayerId_t& val)
+    {
+        uint32_t temp = static_cast<uint32_t>(val.id);
+        temp = ByteSwapBE(temp);
+        stream->Write(&temp);
+    }
+    static void decode(OpenRCT2::IStream* stream, NetworkPlayerId_t& val)
+    {
+        uint32_t temp;
+        stream->Read(&temp);
+        val.id = static_cast<decltype(val.id)>(ByteSwapBE(temp));
+    }
+    static void log(OpenRCT2::IStream* stream, const NetworkPlayerId_t& val)
+    {
+        char playerId[28] = {};
+        snprintf(playerId, sizeof(playerId), "%u", val.id);
+
+        stream->Write(playerId, strlen(playerId));
+
+        int32_t playerIndex = network_get_player_index(val.id);
+        if (playerIndex != -1)
+        {
+            const char* playerName = network_get_player_name(playerIndex);
+            if (playerName != nullptr)
+            {
+                stream->Write(" \"", 2);
+                stream->Write(playerName, strlen(playerName));
+                stream->Write("\"", 1);
+            }
+        }
+    }
+};
+
+template<> struct DataSerializerTraits_t<NetworkRideId_t>
+{
+    static void encode(OpenRCT2::IStream* stream, const NetworkRideId_t& val)
+    {
+        uint32_t temp = static_cast<uint32_t>(val.id);
+        temp = ByteSwapBE(temp);
+        stream->Write(&temp);
+    }
+    static void decode(OpenRCT2::IStream* stream, NetworkRideId_t& val)
+    {
+        uint32_t temp;
+        stream->Read(&temp);
+        val.id = static_cast<decltype(val.id)>(ByteSwapBE(temp));
+    }
+    static void log(OpenRCT2::IStream* stream, const NetworkRideId_t& val)
+    {
+        char rideId[28] = {};
+        snprintf(rideId, sizeof(rideId), "%u", val.id);
+
+        stream->Write(rideId, strlen(rideId));
+
+        auto ride = get_ride(val.id);
+        if (ride != nullptr)
+        {
+            auto rideName = ride->GetName();
+
+            stream->Write(" \"", 2);
+            stream->Write(rideName.c_str(), rideName.size());
+            stream->Write("\"", 1);
+        }
+    }
+};
+
+template<typename T> struct DataSerializerTraits_t<DataSerialiserTag<T>>
+{
+    static void encode(OpenRCT2::IStream* stream, const DataSerialiserTag<T>& tag)
+    {
+        DataSerializerTraits<T> s;
+        s.encode(stream, tag.Data());
+    }
+    static void decode(OpenRCT2::IStream* stream, DataSerialiserTag<T>& tag)
+    {
+        DataSerializerTraits<T> s;
+        s.decode(stream, tag.Data());
+    }
+    static void log(OpenRCT2::IStream* stream, const DataSerialiserTag<T>& tag)
+    {
+        const char* name = tag.Name();
+        stream->Write(name, strlen(name));
+        stream->Write(" = ", 3);
+
+        DataSerializerTraits<T> s;
+        s.log(stream, tag.Data());
+
+        stream->Write("; ", 2);
+    }
+};
+
+template<> struct DataSerializerTraits_t<OpenRCT2::MemoryStream>
+{
+    static void encode(OpenRCT2::IStream* stream, const OpenRCT2::MemoryStream& val)
+    {
+        DataSerializerTraits<uint32_t> s;
+        s.encode(stream, val.GetLength());
+
+        stream->Write(val.GetData(), val.GetLength());
+    }
+    static void decode(OpenRCT2::IStream* stream, OpenRCT2::MemoryStream& val)
+    {
+        DataSerializerTraits<uint32_t> s;
+
+        uint32_t length = 0;
+        s.decode(stream, length);
+
+        std::unique_ptr<uint8_t[]> buf(new uint8_t[length]);
+        stream->Read(buf.get(), length);
+
+        val.Write(buf.get(), length);
+    }
+    static void log(OpenRCT2::IStream* stream, const OpenRCT2::MemoryStream& tag)
+    {
+    }
+};
+
+template<typename _Ty, size_t _Size> struct DataSerializerTraitsPODArray
+{
+    static void encode(OpenRCT2::IStream* stream, const _Ty (&val)[_Size])
+    {
+        uint16_t len = static_cast<uint16_t>(_Size);
+        uint16_t swapped = ByteSwapBE(len);
+        stream->Write(&swapped);
+
+        DataSerializerTraits<uint8_t> s;
+        for (auto&& sub : val)
+        {
+            s.encode(stream, sub);
+        }
+    }
+    static void decode(OpenRCT2::IStream* stream, _Ty (&val)[_Size])
+    {
+        uint16_t len;
+        stream->Read(&len);
+        len = ByteSwapBE(len);
+
+        if (len != _Size)
+            throw std::runtime_error("Invalid size, can't decode");
+
+        DataSerializerTraits<_Ty> s;
+        for (auto&& sub : val)
+        {
+            s.decode(stream, sub);
+        }
+    }
+    static void log(OpenRCT2::IStream* stream, const _Ty (&val)[_Size])
+    {
+        stream->Write("{", 1);
+        DataSerializerTraits<_Ty> s;
+        for (auto&& sub : val)
+        {
+            s.log(stream, sub);
+            stream->Write("; ", 2);
+        }
+        stream->Write("}", 1);
+    }
+};
+
+template<size_t _Size> struct DataSerializerTraits_t<uint8_t[_Size]> : public DataSerializerTraitsPODArray<uint8_t, _Size>
+{
+};
+
+template<size_t _Size> struct DataSerializerTraits_t<utf8[_Size]> : public DataSerializerTraitsPODArray<utf8, _Size>
+{
+};
+
+template<size_t _Size> struct DataSerializerTraits_t<uint16_t[_Size]> : public DataSerializerTraitsPODArray<uint16_t, _Size>
+{
+};
+
+template<size_t _Size> struct DataSerializerTraits_t<uint32_t[_Size]> : public DataSerializerTraitsPODArray<uint32_t, _Size>
+{
+};
+
+template<size_t _Size> struct DataSerializerTraits_t<uint64_t[_Size]> : public DataSerializerTraitsPODArray<uint64_t, _Size>
+{
+};
+
+template<typename _Ty, size_t _Size> struct DataSerializerTraits_t<std::array<_Ty, _Size>>
+{
+    static void encode(OpenRCT2::IStream* stream, const std::array<_Ty, _Size>& val)
+    {
+        uint16_t len = static_cast<uint16_t>(_Size);
+        uint16_t swapped = ByteSwapBE(len);
+        stream->Write(&swapped);
+
+        DataSerializerTraits<_Ty> s;
+        for (auto&& sub : val)
+        {
+            s.encode(stream, sub);
+        }
+    }
+    static void decode(OpenRCT2::IStream* stream, std::array<_Ty, _Size>& val)
+    {
+        uint16_t len;
+        stream->Read(&len);
+        len = ByteSwapBE(len);
+
+        if (len != _Size)
+            throw std::runtime_error("Invalid size, can't decode");
+
+        DataSerializerTraits<_Ty> s;
+        for (auto&& sub : val)
+        {
+            s.decode(stream, sub);
+        }
+    }
+    static void log(OpenRCT2::IStream* stream, const std::array<_Ty, _Size>& val)
+    {
+        stream->Write("{", 1);
+        DataSerializerTraits<_Ty> s;
+        for (auto&& sub : val)
+        {
+            s.log(stream, sub);
+            stream->Write("; ", 2);
+        }
+        stream->Write("}", 1);
+    }
+};
+
+template<typename _Ty> struct DataSerializerTraits_t<std::vector<_Ty>>
+{
+    static void encode(OpenRCT2::IStream* stream, const std::vector<_Ty>& val)
+    {
+        uint16_t len = static_cast<uint16_t>(val.size());
+        uint16_t swapped = ByteSwapBE(len);
+        stream->Write(&swapped);
+
+        DataSerializerTraits<_Ty> s;
+        for (auto&& sub : val)
+        {
+            s.encode(stream, sub);
+        }
+    }
+    static void decode(OpenRCT2::IStream* stream, std::vector<_Ty>& val)
+    {
+        uint16_t len;
+        stream->Read(&len);
+        len = ByteSwapBE(len);
+
+        DataSerializerTraits<_Ty> s;
+        for (auto i = 0; i < len; ++i)
+        {
+            _Ty sub{};
+            s.decode(stream, sub);
+            val.push_back(std::move(sub));
+        }
+    }
+    static void log(OpenRCT2::IStream* stream, const std::vector<_Ty>& val)
+    {
+        stream->Write("{", 1);
+        DataSerializerTraits<_Ty> s;
+        for (auto&& sub : val)
+        {
+            s.log(stream, sub);
+            stream->Write("; ", 2);
+        }
+        stream->Write("}", 1);
+    }
+};
+
+template<> struct DataSerializerTraits_t<MapRange>
+{
+    static void encode(OpenRCT2::IStream* stream, const MapRange& v)
+    {
+        stream->WriteValue(ByteSwapBE(v.GetLeft()));
+        stream->WriteValue(ByteSwapBE(v.GetTop()));
+        stream->WriteValue(ByteSwapBE(v.GetRight()));
+        stream->WriteValue(ByteSwapBE(v.GetBottom()));
+    }
+    static void decode(OpenRCT2::IStream* stream, MapRange& v)
+    {
+        auto l = ByteSwapBE(stream->ReadValue<int32_t>());
+        auto t = ByteSwapBE(stream->ReadValue<int32_t>());
+        auto r = ByteSwapBE(stream->ReadValue<int32_t>());
+        auto b = ByteSwapBE(stream->ReadValue<int32_t>());
+        v = MapRange(l, t, r, b);
+    }
+    static void log(OpenRCT2::IStream* stream, const MapRange& v)
+    {
+        char coords[128] = {};
+        snprintf(
+            coords, sizeof(coords), "MapRange(l = %d, t = %d, r = %d, b = %d)", v.GetLeft(), v.GetTop(), v.GetRight(),
+            v.GetBottom());
+
+        stream->Write(coords, strlen(coords));
+    }
+};
+
+template<> struct DataSerializerTraits_t<TileElement>
+{
+    static void encode(OpenRCT2::IStream* stream, const TileElement& tileElement)
+    {
+        stream->WriteValue(tileElement.type);
+        stream->WriteValue(tileElement.Flags);
+        stream->WriteValue(tileElement.base_height);
+        stream->WriteValue(tileElement.clearance_height);
+        stream->WriteValue(tileElement.owner);
+        for (int i = 0; i < 3; ++i)
+        {
+            stream->WriteValue(tileElement.pad_05[i]);
+        }
+        for (int i = 0; i < 8; ++i)
+        {
+            stream->WriteValue(tileElement.pad_08[i]);
+        }
+    }
+    static void decode(OpenRCT2::IStream* stream, TileElement& tileElement)
+    {
+        tileElement.type = stream->ReadValue<uint8_t>();
+        tileElement.Flags = stream->ReadValue<uint8_t>();
+        tileElement.base_height = stream->ReadValue<uint8_t>();
+        tileElement.clearance_height = stream->ReadValue<uint8_t>();
+        tileElement.owner = stream->ReadValue<uint8_t>();
+        for (int i = 0; i < 3; ++i)
+        {
+            tileElement.pad_05[i] = stream->ReadValue<uint8_t>();
+        }
+        for (int i = 0; i < 8; ++i)
+        {
+            tileElement.pad_08[i] = stream->ReadValue<uint8_t>();
+        }
+    }
+    static void log(OpenRCT2::IStream* stream, const TileElement& tileElement)
+    {
+        char msg[128] = {};
+        snprintf(
+            msg, sizeof(msg), "TileElement(type = %u, flags = %u, base_height = %u)", tileElement.type, tileElement.Flags,
+            tileElement.base_height);
+        stream->Write(msg, strlen(msg));
+    }
+};
+
+template<> struct DataSerializerTraits_t<CoordsXY>
+{
+    static void encode(OpenRCT2::IStream* stream, const CoordsXY& coords)
+    {
+        stream->WriteValue(ByteSwapBE(coords.x));
+        stream->WriteValue(ByteSwapBE(coords.y));
+    }
+    static void decode(OpenRCT2::IStream* stream, CoordsXY& coords)
+    {
+        auto x = ByteSwapBE(stream->ReadValue<int32_t>());
+        auto y = ByteSwapBE(stream->ReadValue<int32_t>());
+        coords = CoordsXY{ x, y };
+    }
+    static void log(OpenRCT2::IStream* stream, const CoordsXY& coords)
+    {
+        char msg[128] = {};
+        snprintf(msg, sizeof(msg), "CoordsXY(x = %d, y = %d)", coords.x, coords.y);
+        stream->Write(msg, strlen(msg));
+    }
+};
+
+template<> struct DataSerializerTraits_t<CoordsXYZ>
+{
+    static void encode(OpenRCT2::IStream* stream, const CoordsXYZ& coord)
+    {
+        stream->WriteValue(ByteSwapBE(coord.x));
+        stream->WriteValue(ByteSwapBE(coord.y));
+        stream->WriteValue(ByteSwapBE(coord.z));
+    }
+
+    static void decode(OpenRCT2::IStream* stream, CoordsXYZ& coord)
+    {
+        auto x = ByteSwapBE(stream->ReadValue<int32_t>());
+        auto y = ByteSwapBE(stream->ReadValue<int32_t>());
+        auto z = ByteSwapBE(stream->ReadValue<int32_t>());
+        coord = CoordsXYZ{ x, y, z };
+    }
+
+    static void log(OpenRCT2::IStream* stream, const CoordsXYZ& coord)
+    {
+        char msg[128] = {};
+        snprintf(msg, sizeof(msg), "CoordsXYZ(x = %d, y = %d, z = %d)", coord.x, coord.y, coord.z);
+        stream->Write(msg, strlen(msg));
+    }
+};
+
+template<> struct DataSerializerTraits_t<CoordsXYZD>
+{
+    static void encode(OpenRCT2::IStream* stream, const CoordsXYZD& coord)
+    {
+        stream->WriteValue(ByteSwapBE(coord.x));
+        stream->WriteValue(ByteSwapBE(coord.y));
+        stream->WriteValue(ByteSwapBE(coord.z));
+        stream->WriteValue(ByteSwapBE(coord.direction));
+    }
+
+    static void decode(OpenRCT2::IStream* stream, CoordsXYZD& coord)
+    {
+        auto x = ByteSwapBE(stream->ReadValue<int32_t>());
+        auto y = ByteSwapBE(stream->ReadValue<int32_t>());
+        auto z = ByteSwapBE(stream->ReadValue<int32_t>());
+        auto d = ByteSwapBE(stream->ReadValue<uint8_t>());
+        coord = CoordsXYZD{ x, y, z, d };
+    }
+
+    static void log(OpenRCT2::IStream* stream, const CoordsXYZD& coord)
+    {
+        char msg[128] = {};
+        snprintf(
+            msg, sizeof(msg), "CoordsXYZD(x = %d, y = %d, z = %d, direction = %d)", coord.x, coord.y, coord.z, coord.direction);
+        stream->Write(msg, strlen(msg));
+    }
+};
+
+template<> struct DataSerializerTraits_t<NetworkCheatType_t>
+{
+    static void encode(OpenRCT2::IStream* stream, const NetworkCheatType_t& val)
+    {
+        uint32_t temp = ByteSwapBE(val.id);
+        stream->Write(&temp);
+    }
+    static void decode(OpenRCT2::IStream* stream, NetworkCheatType_t& val)
+    {
+        uint32_t temp;
+        stream->Read(&temp);
+        val.id = ByteSwapBE(temp);
+    }
+    static void log(OpenRCT2::IStream* stream, const NetworkCheatType_t& val)
+    {
+        const char* cheatName = CheatsGetName(static_cast<CheatType>(val.id));
+        stream->Write(cheatName, strlen(cheatName));
+    }
+};
+
+template<> struct DataSerializerTraits_t<rct_object_entry>
+{
+    static void encode(OpenRCT2::IStream* stream, const rct_object_entry& val)
+    {
+        uint32_t temp = ByteSwapBE(val.flags);
+        stream->Write(&temp);
+        stream->WriteArray(val.nameWOC, 12);
+    }
+    static void decode(OpenRCT2::IStream* stream, rct_object_entry& val)
+    {
+        uint32_t temp;
+        stream->Read(&temp);
+        val.flags = ByteSwapBE(temp);
+        auto str = stream->ReadArray<char>(12);
+        memcpy(val.nameWOC, str.get(), 12);
+    }
+    static void log(OpenRCT2::IStream* stream, const rct_object_entry& val)
+    {
+        stream->WriteArray(val.name, 8);
+    }
+};
+
+template<> struct DataSerializerTraits_t<TrackDesignTrackElement>
+{
+    static void encode(OpenRCT2::IStream* stream, const TrackDesignTrackElement& val)
+    {
+        stream->Write(&val.flags);
+        stream->Write(&val.type);
+    }
+    static void decode(OpenRCT2::IStream* stream, TrackDesignTrackElement& val)
+    {
+        stream->Read(&val.flags);
+        stream->Read(&val.type);
+    }
+    static void log(OpenRCT2::IStream* stream, const TrackDesignTrackElement& val)
+    {
+        char msg[128] = {};
+        snprintf(msg, sizeof(msg), "TrackDesignTrackElement(type = %d, flags = %d)", val.type, val.flags);
+        stream->Write(msg, strlen(msg));
+    }
+};
+
+template<> struct DataSerializerTraits_t<TrackDesignMazeElement>
+{
+    static void encode(OpenRCT2::IStream* stream, const TrackDesignMazeElement& val)
+    {
+        uint32_t temp = ByteSwapBE(val.all);
+        stream->Write(&temp);
+    }
+    static void decode(OpenRCT2::IStream* stream, TrackDesignMazeElement& val)
+    {
+        uint32_t temp;
+        stream->Read(&temp);
+        val.all = ByteSwapBE(temp);
+    }
+    static void log(OpenRCT2::IStream* stream, const TrackDesignMazeElement& val)
+    {
+        char msg[128] = {};
+        snprintf(msg, sizeof(msg), "TrackDesignMazeElement(all = %d)", val.all);
+        stream->Write(msg, strlen(msg));
+    }
+};
+
+template<> struct DataSerializerTraits_t<TrackDesignEntranceElement>
+{
+    static void encode(OpenRCT2::IStream* stream, const TrackDesignEntranceElement& val)
+    {
+        stream->Write(&val.x);
+        stream->Write(&val.y);
+        stream->Write(&val.z);
+        stream->Write(&val.direction);
+        stream->Write(&val.isExit);
+    }
+    static void decode(OpenRCT2::IStream* stream, TrackDesignEntranceElement& val)
+    {
+        stream->Read(&val.x);
+        stream->Read(&val.y);
+        stream->Read(&val.z);
+        stream->Read(&val.direction);
+        stream->Read(&val.isExit);
+    }
+    static void log(OpenRCT2::IStream* stream, const TrackDesignEntranceElement& val)
+    {
+        char msg[128] = {};
+        snprintf(
+            msg, sizeof(msg), "TrackDesignEntranceElement(x = %d, y = %d, z = %d, dir = %d, isExit = %d)", val.x, val.y, val.z,
+            val.direction, val.isExit);
+        stream->Write(msg, strlen(msg));
+    }
+};
+
+template<> struct DataSerializerTraits_t<TrackDesignSceneryElement>
+{
+    static void encode(OpenRCT2::IStream* stream, const TrackDesignSceneryElement& val)
+    {
+        stream->Write(&val.x);
+        stream->Write(&val.y);
+        stream->Write(&val.z);
+        stream->Write(&val.flags);
+        stream->Write(&val.primary_colour);
+        stream->Write(&val.secondary_colour);
+        DataSerializerTraits<rct_object_entry> s;
+        s.encode(stream, val.scenery_object);
+    }
+    static void decode(OpenRCT2::IStream* stream, TrackDesignSceneryElement& val)
+    {
+        stream->Read(&val.x);
+        stream->Read(&val.y);
+        stream->Read(&val.z);
+        stream->Read(&val.flags);
+        stream->Read(&val.primary_colour);
+        stream->Read(&val.secondary_colour);
+        DataSerializerTraits<rct_object_entry> s;
+        s.decode(stream, val.scenery_object);
+    }
+    static void log(OpenRCT2::IStream* stream, const TrackDesignSceneryElement& val)
+    {
+        char msg[128] = {};
+        snprintf(
+            msg, sizeof(msg), "TrackDesignSceneryElement(x = %d, y = %d, z = %d, flags = %d, colour1 = %d, colour2 = %d)",
+            val.x, val.y, val.z, val.flags, val.primary_colour, val.secondary_colour);
+        stream->Write(msg, strlen(msg));
+        stream->WriteArray(val.scenery_object.name, 8);
+    }
+};
+
+template<> struct DataSerializerTraits_t<rct_vehicle_colour>
+{
+    static void encode(OpenRCT2::IStream* stream, const rct_vehicle_colour& val)
+    {
+        stream->Write(&val.body_colour);
+        stream->Write(&val.trim_colour);
+    }
+    static void decode(OpenRCT2::IStream* stream, rct_vehicle_colour& val)
+    {
+        stream->Read(&val.body_colour);
+        stream->Read(&val.trim_colour);
+    }
+    static void log(OpenRCT2::IStream* stream, const rct_vehicle_colour& val)
+    {
+        char msg[128] = {};
+        snprintf(msg, sizeof(msg), "rct_vehicle_colour(body_colour = %d, trim_colour = %d)", val.body_colour, val.trim_colour);
+        stream->Write(msg, strlen(msg));
+    }
+};
+
+template<> struct DataSerializerTraits_t<ObjectEntryDescriptor>
+{
+    static void encode(OpenRCT2::IStream* stream, const ObjectEntryDescriptor& val)
+    {
+        stream->Write(&val.Generation);
+        if (val.Generation == ObjectGeneration::DAT)
+        {
+            DataSerializerTraits<rct_object_entry> s;
+            s.encode(stream, val.Entry);
+        }
+        else
+        {
+            DataSerializerTraits<std::string> s;
+            s.encode(stream, val.Identifier);
+        }
+    }
+    static void decode(OpenRCT2::IStream* stream, ObjectEntryDescriptor& val)
+    {
+        ObjectGeneration generation;
+        stream->Read(&generation);
+        if (generation == ObjectGeneration::DAT)
+        {
+            rct_object_entry obj;
+            DataSerializerTraits<rct_object_entry> s;
+            s.decode(stream, obj);
+            val = ObjectEntryDescriptor(obj);
+        }
+        else
+        {
+            std::string id;
+            DataSerializerTraits<std::string> s;
+            s.decode(stream, id);
+            val = ObjectEntryDescriptor(id);
+        }
+    }
+    static void log(OpenRCT2::IStream* stream, const ObjectEntryDescriptor& val)
+    {
+        char msg[128] = {};
+        snprintf(msg, sizeof(msg), "ObjectEntryDescriptor (Generation = %d)", static_cast<int32_t>(val.Generation));
+        stream->Write(msg, strlen(msg));
+    }
+};
+# 13 "/home/ted/dev/openrct2/src/openrct2/core/DataSerialiser.h" 2
+
+
+
+
+class DataSerialiser
+{
+private:
+    OpenRCT2::MemoryStream _stream;
+    OpenRCT2::IStream& _activeStream;
+    bool _isSaving = false;
+    bool _isLogging = false;
+
+public:
+    DataSerialiser(bool isSaving)
+        : _activeStream(_stream)
+        , _isSaving(isSaving)
+        , _isLogging(false)
+    {
+    }
+
+    DataSerialiser(bool isSaving, OpenRCT2::IStream& stream, bool isLogging = false)
+        : _activeStream(stream)
+        , _isSaving(isSaving)
+        , _isLogging(isLogging)
+    {
+    }
+
+    bool IsSaving() const
+    {
+        return _isSaving;
+    }
+
+    bool IsLoading() const
+    {
+        return !_isSaving;
+    }
+
+    bool IsLogging() const
+    {
+        return _isLogging;
+    }
+
+    OpenRCT2::IStream& GetStream()
+    {
+        return _activeStream;
+    }
+
+    template<typename T> DataSerialiser& operator<<(const T& data)
+    {
+        if (!_isLogging)
+        {
+            if (_isSaving)
+                DataSerializerTraits<T>::encode(&_activeStream, data);
+            else
+                DataSerializerTraits<T>::decode(&_activeStream, const_cast<T&>(data));
+        }
+        else
+        {
+            DataSerializerTraits<T>::log(&_activeStream, data);
+        }
+
+        return *this;
+    }
+
+    template<typename T> DataSerialiser& operator<<(DataSerialiserTag<T> data)
+    {
+        if (!_isLogging)
+        {
+            if (_isSaving)
+                DataSerializerTraits<DataSerialiserTag<T>>::encode(&_activeStream, data);
+            else
+                DataSerializerTraits<DataSerialiserTag<T>>::decode(&_activeStream, data);
+        }
+        else
+        {
+            DataSerializerTraits<DataSerialiserTag<T>>::log(&_activeStream, data);
+        }
+
+        return *this;
+    }
+};
+# 20 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/OrcaStream.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/OrcaStream.hpp"
+       
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/core/FileStream.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/core/FileStream.h"
+       
+
+
+
+
+
+namespace OpenRCT2
+{
+    enum
+    {
+        FILE_MODE_OPEN,
+        FILE_MODE_WRITE,
+        FILE_MODE_APPEND,
+    };
+
+
+
+
+    class FileStream final : public IStream
+    {
+    private:
+        FILE* _file = nullptr;
+        bool _ownsFilePtr = false;
+        bool _canRead = false;
+        bool _canWrite = false;
+        bool _disposed = false;
+        uint64_t _fileSize = 0;
+
+    public:
+        FileStream(const fs::path& path, int32_t fileMode);
+        FileStream(const std::string& path, int32_t fileMode);
+        FileStream(const utf8* path, int32_t fileMode);
+        ~FileStream() override;
+
+        bool CanRead() const override;
+        bool CanWrite() const override;
+
+        uint64_t GetLength() const override;
+        uint64_t GetPosition() const override;
+
+        void SetPosition(uint64_t position) override;
+        void Seek(int64_t offset, int32_t origin) override;
+        void Read(void* buffer, uint64_t length) override;
+        void Write(const void* buffer, uint64_t length) override;
+        uint64_t TryRead(void* buffer, uint64_t length) override;
+        const void* GetData() const override;
+    };
+
+}
+# 14 "/home/ted/dev/openrct2/src/openrct2/core/OrcaStream.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/fstream" 1 3
+# 36 "/usr/include/c++/10.2.0/fstream" 3
+       
+# 37 "/usr/include/c++/10.2.0/fstream" 3
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdio" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 42 "/usr/include/c++/10.2.0/fstream" 2 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/basic_file.h" 1 3
+# 37 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/basic_file.h" 3
+       
+# 38 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/basic_file.h" 3
+
+
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++io.h" 1 3
+# 35 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++io.h" 3
+# 1 "/usr/include/c++/10.2.0/cstdio" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdio" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdio" 3
+# 36 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++io.h" 2 3
+
+
+
+# 38 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/c++io.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  typedef __gthread_mutex_t __c_lock;
+
+
+  typedef FILE __c_file;
+
+
+}
+# 41 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/basic_file.h" 2 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+  template<typename _CharT>
+    class __basic_file;
+
+
+  template<>
+    class __basic_file<char>
+    {
+
+      __c_file* _M_cfile;
+
+
+      bool _M_cfile_created;
+
+    public:
+      __basic_file(__c_lock* __lock = 0) throw ();
+
+
+      __basic_file(__basic_file&& __rv, __c_lock* = 0) noexcept
+      : _M_cfile(__rv._M_cfile), _M_cfile_created(__rv._M_cfile_created)
+      {
+ __rv._M_cfile = nullptr;
+ __rv._M_cfile_created = false;
+      }
+
+      __basic_file& operator=(const __basic_file&) = delete;
+      __basic_file& operator=(__basic_file&&) = delete;
+
+      void
+      swap(__basic_file& __f) noexcept
+      {
+ std::swap(_M_cfile, __f._M_cfile);
+ std::swap(_M_cfile_created, __f._M_cfile_created);
+      }
+
+
+      __basic_file*
+      open(const char* __name, ios_base::openmode __mode, int __prot = 0664);
+
+
+
+
+
+
+      __basic_file*
+      sys_open(__c_file* __file, ios_base::openmode);
+
+      __basic_file*
+      sys_open(int __fd, ios_base::openmode __mode) throw ();
+
+      __basic_file*
+      close();
+
+      __attribute__ ((__pure__)) bool
+      is_open() const throw ();
+
+      __attribute__ ((__pure__)) int
+      fd() throw ();
+
+      __attribute__ ((__pure__)) __c_file*
+      file() throw ();
+
+      ~__basic_file();
+
+      streamsize
+      xsputn(const char* __s, streamsize __n);
+
+      streamsize
+      xsputn_2(const char* __s1, streamsize __n1,
+        const char* __s2, streamsize __n2);
+
+      streamsize
+      xsgetn(char* __s, streamsize __n);
+
+      streamoff
+      seekoff(streamoff __off, ios_base::seekdir __way) throw ();
+
+      int
+      sync();
+
+      streamsize
+      showmanyc();
+    };
+
+
+}
+# 43 "/usr/include/c++/10.2.0/fstream" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 79 "/usr/include/c++/10.2.0/fstream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_filebuf : public basic_streambuf<_CharT, _Traits>
+    {
+
+      template<typename _Tp>
+ using __chk_state = __and_<is_copy_assignable<_Tp>,
+       is_copy_constructible<_Tp>,
+       is_default_constructible<_Tp>>;
+
+      static_assert(__chk_state<typename _Traits::state_type>::value,
+      "state_type must be CopyAssignable, CopyConstructible"
+      " and DefaultConstructible");
+
+      static_assert(is_same<typename _Traits::pos_type,
+       fpos<typename _Traits::state_type>>::value,
+      "pos_type must be fpos<state_type>");
+
+    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;
+      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
+      typedef __basic_file<char> __file_type;
+      typedef typename traits_type::state_type __state_type;
+      typedef codecvt<char_type, char, __state_type> __codecvt_type;
+
+      friend class ios_base;
+
+    protected:
+
+
+      __c_lock _M_lock;
+
+
+      __file_type _M_file;
+
+
+      ios_base::openmode _M_mode;
+
+
+      __state_type _M_state_beg;
+
+
+
+
+      __state_type _M_state_cur;
+
+
+
+      __state_type _M_state_last;
+
+
+      char_type* _M_buf;
+
+
+
+
+
+
+      size_t _M_buf_size;
+
+
+      bool _M_buf_allocated;
+# 155 "/usr/include/c++/10.2.0/fstream" 3
+      bool _M_reading;
+      bool _M_writing;
+
+
+
+
+
+
+
+      char_type _M_pback;
+      char_type* _M_pback_cur_save;
+      char_type* _M_pback_end_save;
+      bool _M_pback_init;
+
+
+
+      const __codecvt_type* _M_codecvt;
+
+
+
+
+
+
+      char* _M_ext_buf;
+
+
+
+
+      streamsize _M_ext_buf_size;
+
+
+
+
+
+
+      const char* _M_ext_next;
+      char* _M_ext_end;
+
+
+
+
+
+
+      void
+      _M_create_pback()
+      {
+ if (!_M_pback_init)
+   {
+     _M_pback_cur_save = this->gptr();
+     _M_pback_end_save = this->egptr();
+     this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
+     _M_pback_init = true;
+   }
+      }
+
+
+
+
+
+
+      void
+      _M_destroy_pback() throw()
+      {
+ if (_M_pback_init)
+   {
+
+     _M_pback_cur_save += this->gptr() != this->eback();
+     this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save);
+     _M_pback_init = false;
+   }
+      }
+
+    public:
+
+
+
+
+
+
+
+      basic_filebuf();
+
+
+      basic_filebuf(const basic_filebuf&) = delete;
+      basic_filebuf(basic_filebuf&&);
+
+
+
+
+
+      virtual
+      ~basic_filebuf()
+      {
+ try
+   { this->close(); }
+ catch(...)
+   { }
+      }
+
+
+      basic_filebuf& operator=(const basic_filebuf&) = delete;
+      basic_filebuf& operator=(basic_filebuf&&);
+      void swap(basic_filebuf&);
+
+
+
+
+
+
+      bool
+      is_open() const throw()
+      { return _M_file.is_open(); }
+# 309 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      open(const char* __s, ios_base::openmode __mode);
+# 330 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      open(const std::string& __s, ios_base::openmode __mode)
+      { return open(__s.c_str(), __mode); }
+# 360 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      close();
+
+    protected:
+      void
+      _M_allocate_internal_buffer();
+
+      void
+      _M_destroy_internal_buffer() throw();
+
+
+      virtual streamsize
+      showmanyc();
+
+
+
+
+
+
+      virtual int_type
+      underflow();
+
+      virtual int_type
+      pbackfail(int_type __c = _Traits::eof());
+# 392 "/usr/include/c++/10.2.0/fstream" 3
+      virtual int_type
+      overflow(int_type __c = _Traits::eof());
+
+
+
+      bool
+      _M_convert_to_external(char_type*, streamsize);
+# 412 "/usr/include/c++/10.2.0/fstream" 3
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n);
+
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      virtual pos_type
+      seekpos(pos_type __pos,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+
+      pos_type
+      _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);
+
+      int
+      _M_get_ext_pos(__state_type &__state);
+
+      virtual int
+      sync();
+
+      virtual void
+      imbue(const locale& __loc);
+
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+
+
+      bool
+      _M_terminate_output();
+# 458 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      _M_set_buffer(streamsize __off)
+      {
+ const bool __testin = _M_mode & ios_base::in;
+ const bool __testout = (_M_mode & ios_base::out
+    || _M_mode & ios_base::app);
+
+ if (__testin && __off > 0)
+   this->setg(_M_buf, _M_buf, _M_buf + __off);
+ else
+   this->setg(_M_buf, _M_buf, _M_buf);
+
+ if (__testout && __off == 0 && _M_buf_size > 1 )
+   this->setp(_M_buf, _M_buf + _M_buf_size - 1);
+ else
+   this->setp(0, 0);
+      }
+    };
+# 491 "/usr/include/c++/10.2.0/fstream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ifstream : public basic_istream<_CharT, _Traits>
+    {
+    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_filebuf<char_type, traits_type> __filebuf_type;
+      typedef basic_istream<char_type, traits_type> __istream_type;
+
+    private:
+      __filebuf_type _M_filebuf;
+
+    public:
+# 518 "/usr/include/c++/10.2.0/fstream" 3
+      basic_ifstream() : __istream_type(), _M_filebuf()
+      { this->init(&_M_filebuf); }
+# 528 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 561 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_ifstream(const std::string& __s,
+       ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 585 "/usr/include/c++/10.2.0/fstream" 3
+      basic_ifstream(const basic_ifstream&) = delete;
+
+      basic_ifstream(basic_ifstream&& __rhs)
+      : __istream_type(std::move(__rhs)),
+      _M_filebuf(std::move(__rhs._M_filebuf))
+      { __istream_type::set_rdbuf(&_M_filebuf); }
+# 599 "/usr/include/c++/10.2.0/fstream" 3
+      ~basic_ifstream()
+      { }
+
+
+
+
+      basic_ifstream&
+      operator=(const basic_ifstream&) = delete;
+
+      basic_ifstream&
+      operator=(basic_ifstream&& __rhs)
+      {
+ __istream_type::operator=(std::move(__rhs));
+ _M_filebuf = std::move(__rhs._M_filebuf);
+ return *this;
+      }
+
+      void
+      swap(basic_ifstream& __rhs)
+      {
+ __istream_type::swap(__rhs);
+ _M_filebuf.swap(__rhs._M_filebuf);
+      }
+# 631 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      rdbuf() const
+      { return const_cast<__filebuf_type*>(&_M_filebuf); }
+
+
+
+
+
+      bool
+      is_open()
+      { return _M_filebuf.is_open(); }
+
+
+
+      bool
+      is_open() const
+      { return _M_filebuf.is_open(); }
+# 657 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const char* __s, ios_base::openmode __mode = ios_base::in)
+      {
+ if (!_M_filebuf.open(__s, __mode | ios_base::in))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 696 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const std::string& __s, ios_base::openmode __mode = ios_base::in)
+      {
+ if (!_M_filebuf.open(__s, __mode | ios_base::in))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 729 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      close()
+      {
+ if (!_M_filebuf.close())
+   this->setstate(ios_base::failbit);
+      }
+    };
+# 752 "/usr/include/c++/10.2.0/fstream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ofstream : public basic_ostream<_CharT,_Traits>
+    {
+    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_filebuf<char_type, traits_type> __filebuf_type;
+      typedef basic_ostream<char_type, traits_type> __ostream_type;
+
+    private:
+      __filebuf_type _M_filebuf;
+
+    public:
+# 779 "/usr/include/c++/10.2.0/fstream" 3
+      basic_ofstream(): __ostream_type(), _M_filebuf()
+      { this->init(&_M_filebuf); }
+# 789 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_ofstream(const char* __s,
+       ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 824 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_ofstream(const std::string& __s,
+       ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 848 "/usr/include/c++/10.2.0/fstream" 3
+      basic_ofstream(const basic_ofstream&) = delete;
+
+      basic_ofstream(basic_ofstream&& __rhs)
+      : __ostream_type(std::move(__rhs)),
+      _M_filebuf(std::move(__rhs._M_filebuf))
+      { __ostream_type::set_rdbuf(&_M_filebuf); }
+# 862 "/usr/include/c++/10.2.0/fstream" 3
+      ~basic_ofstream()
+      { }
+
+
+
+
+      basic_ofstream&
+      operator=(const basic_ofstream&) = delete;
+
+      basic_ofstream&
+      operator=(basic_ofstream&& __rhs)
+      {
+ __ostream_type::operator=(std::move(__rhs));
+ _M_filebuf = std::move(__rhs._M_filebuf);
+ return *this;
+      }
+
+      void
+      swap(basic_ofstream& __rhs)
+      {
+ __ostream_type::swap(__rhs);
+ _M_filebuf.swap(__rhs._M_filebuf);
+      }
+# 894 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      rdbuf() const
+      { return const_cast<__filebuf_type*>(&_M_filebuf); }
+
+
+
+
+
+      bool
+      is_open()
+      { return _M_filebuf.is_open(); }
+
+
+
+      bool
+      is_open() const
+      { return _M_filebuf.is_open(); }
+# 920 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const char* __s, ios_base::openmode __mode = ios_base::out)
+      {
+ if (!_M_filebuf.open(__s, __mode | ios_base::out))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 959 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const std::string& __s, ios_base::openmode __mode = ios_base::out)
+      {
+ if (!_M_filebuf.open(__s, __mode | ios_base::out))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 992 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      close()
+      {
+ if (!_M_filebuf.close())
+   this->setstate(ios_base::failbit);
+      }
+    };
+# 1015 "/usr/include/c++/10.2.0/fstream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_fstream : public basic_iostream<_CharT, _Traits>
+    {
+    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_filebuf<char_type, traits_type> __filebuf_type;
+      typedef basic_ios<char_type, traits_type> __ios_type;
+      typedef basic_iostream<char_type, traits_type> __iostream_type;
+
+    private:
+      __filebuf_type _M_filebuf;
+
+    public:
+# 1043 "/usr/include/c++/10.2.0/fstream" 3
+      basic_fstream()
+      : __iostream_type(), _M_filebuf()
+      { this->init(&_M_filebuf); }
+
+
+
+
+
+
+      explicit
+      basic_fstream(const char* __s,
+      ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __iostream_type(0), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 1082 "/usr/include/c++/10.2.0/fstream" 3
+      explicit
+      basic_fstream(const std::string& __s,
+      ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __iostream_type(0), _M_filebuf()
+      {
+ this->init(&_M_filebuf);
+ this->open(__s, __mode);
+      }
+# 1104 "/usr/include/c++/10.2.0/fstream" 3
+      basic_fstream(const basic_fstream&) = delete;
+
+      basic_fstream(basic_fstream&& __rhs)
+      : __iostream_type(std::move(__rhs)),
+      _M_filebuf(std::move(__rhs._M_filebuf))
+      { __iostream_type::set_rdbuf(&_M_filebuf); }
+# 1118 "/usr/include/c++/10.2.0/fstream" 3
+      ~basic_fstream()
+      { }
+
+
+
+
+      basic_fstream&
+      operator=(const basic_fstream&) = delete;
+
+      basic_fstream&
+      operator=(basic_fstream&& __rhs)
+      {
+ __iostream_type::operator=(std::move(__rhs));
+ _M_filebuf = std::move(__rhs._M_filebuf);
+ return *this;
+      }
+
+      void
+      swap(basic_fstream& __rhs)
+      {
+ __iostream_type::swap(__rhs);
+ _M_filebuf.swap(__rhs._M_filebuf);
+      }
+# 1150 "/usr/include/c++/10.2.0/fstream" 3
+      __filebuf_type*
+      rdbuf() const
+      { return const_cast<__filebuf_type*>(&_M_filebuf); }
+
+
+
+
+
+      bool
+      is_open()
+      { return _M_filebuf.is_open(); }
+
+
+
+      bool
+      is_open() const
+      { return _M_filebuf.is_open(); }
+# 1176 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const char* __s,
+    ios_base::openmode __mode = ios_base::in | ios_base::out)
+      {
+ if (!_M_filebuf.open(__s, __mode))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 1217 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      open(const std::string& __s,
+    ios_base::openmode __mode = ios_base::in | ios_base::out)
+      {
+ if (!_M_filebuf.open(__s, __mode))
+   this->setstate(ios_base::failbit);
+ else
+
+
+   this->clear();
+      }
+# 1252 "/usr/include/c++/10.2.0/fstream" 3
+      void
+      close()
+      {
+ if (!_M_filebuf.close())
+   this->setstate(ios_base::failbit);
+      }
+    };
+
+
+
+  template <class _CharT, class _Traits>
+    inline void
+    swap(basic_filebuf<_CharT, _Traits>& __x,
+  basic_filebuf<_CharT, _Traits>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits>
+    inline void
+    swap(basic_ifstream<_CharT, _Traits>& __x,
+  basic_ifstream<_CharT, _Traits>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits>
+    inline void
+    swap(basic_ofstream<_CharT, _Traits>& __x,
+  basic_ofstream<_CharT, _Traits>& __y)
+    { __x.swap(__y); }
+
+
+  template <class _CharT, class _Traits>
+    inline void
+    swap(basic_fstream<_CharT, _Traits>& __x,
+  basic_fstream<_CharT, _Traits>& __y)
+    { __x.swap(__y); }
+
+
+
+}
+
+# 1 "/usr/include/c++/10.2.0/bits/fstream.tcc" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/fstream.tcc" 3
+       
+# 38 "/usr/include/c++/10.2.0/bits/fstream.tcc" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/cerrno" 1 3
+# 39 "/usr/include/c++/10.2.0/cerrno" 3
+       
+# 40 "/usr/include/c++/10.2.0/cerrno" 3
+# 42 "/usr/include/c++/10.2.0/bits/fstream.tcc" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    _M_allocate_internal_buffer()
+    {
+
+
+      if (!_M_buf_allocated && !_M_buf)
+ {
+   _M_buf = new char_type[_M_buf_size];
+   _M_buf_allocated = true;
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    _M_destroy_internal_buffer() throw()
+    {
+      if (_M_buf_allocated)
+ {
+   delete [] _M_buf;
+   _M_buf = 0;
+   _M_buf_allocated = false;
+ }
+      delete [] _M_ext_buf;
+      _M_ext_buf = 0;
+      _M_ext_buf_size = 0;
+      _M_ext_next = 0;
+      _M_ext_end = 0;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_filebuf<_CharT, _Traits>::
+    basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
+    _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
+    _M_state_last(), _M_buf(0), _M_buf_size(8192),
+    _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(),
+    _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
+    _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
+    _M_ext_end(0)
+    {
+      if (has_facet<__codecvt_type>(this->_M_buf_locale))
+ _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale);
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_filebuf<_CharT, _Traits>::
+    basic_filebuf(basic_filebuf&& __rhs)
+    : __streambuf_type(__rhs),
+    _M_lock(), _M_file(std::move(__rhs._M_file), &_M_lock),
+    _M_mode(std::__exchange(__rhs._M_mode, ios_base::openmode(0))),
+    _M_state_beg(std::move(__rhs._M_state_beg)),
+    _M_state_cur(std::move(__rhs._M_state_cur)),
+    _M_state_last(std::move(__rhs._M_state_last)),
+    _M_buf(std::__exchange(__rhs._M_buf, nullptr)),
+    _M_buf_size(std::__exchange(__rhs._M_buf_size, 1)),
+    _M_buf_allocated(std::__exchange(__rhs._M_buf_allocated, false)),
+    _M_reading(std::__exchange(__rhs._M_reading, false)),
+    _M_writing(std::__exchange(__rhs._M_writing, false)),
+    _M_pback(__rhs._M_pback),
+    _M_pback_cur_save(std::__exchange(__rhs._M_pback_cur_save, nullptr)),
+    _M_pback_end_save(std::__exchange(__rhs._M_pback_end_save, nullptr)),
+    _M_pback_init(std::__exchange(__rhs._M_pback_init, false)),
+    _M_codecvt(__rhs._M_codecvt),
+    _M_ext_buf(std::__exchange(__rhs._M_ext_buf, nullptr)),
+    _M_ext_buf_size(std::__exchange(__rhs._M_ext_buf_size, 0)),
+    _M_ext_next(std::__exchange(__rhs._M_ext_next, nullptr)),
+    _M_ext_end(std::__exchange(__rhs._M_ext_end, nullptr))
+    {
+      __rhs._M_set_buffer(-1);
+      __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_filebuf<_CharT, _Traits>&
+    basic_filebuf<_CharT, _Traits>::
+    operator=(basic_filebuf&& __rhs)
+    {
+      this->close();
+      __streambuf_type::operator=(__rhs);
+      _M_file.swap(__rhs._M_file);
+      _M_mode = std::__exchange(__rhs._M_mode, ios_base::openmode(0));
+      _M_state_beg = std::move(__rhs._M_state_beg);
+      _M_state_cur = std::move(__rhs._M_state_cur);
+      _M_state_last = std::move(__rhs._M_state_last);
+      _M_buf = std::__exchange(__rhs._M_buf, nullptr);
+      _M_buf_size = std::__exchange(__rhs._M_buf_size, 1);
+      _M_buf_allocated = std::__exchange(__rhs._M_buf_allocated, false);
+      _M_ext_buf = std::__exchange(__rhs._M_ext_buf, nullptr);
+      _M_ext_buf_size = std::__exchange(__rhs._M_ext_buf_size, 0);
+      _M_ext_next = std::__exchange(__rhs._M_ext_next, nullptr);
+      _M_ext_end = std::__exchange(__rhs._M_ext_end, nullptr);
+      _M_reading = std::__exchange(__rhs._M_reading, false);
+      _M_writing = std::__exchange(__rhs._M_writing, false);
+      _M_pback_cur_save = std::__exchange(__rhs._M_pback_cur_save, nullptr);
+      _M_pback_end_save = std::__exchange(__rhs._M_pback_end_save, nullptr);
+      _M_pback_init = std::__exchange(__rhs._M_pback_init, false);
+      __rhs._M_set_buffer(-1);
+      __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    swap(basic_filebuf& __rhs)
+    {
+      __streambuf_type::swap(__rhs);
+      _M_file.swap(__rhs._M_file);
+      std::swap(_M_mode, __rhs._M_mode);
+      std::swap(_M_state_beg, __rhs._M_state_beg);
+      std::swap(_M_state_cur, __rhs._M_state_cur);
+      std::swap(_M_state_last, __rhs._M_state_last);
+      std::swap(_M_buf, __rhs._M_buf);
+      std::swap(_M_buf_size, __rhs._M_buf_size);
+      std::swap(_M_buf_allocated, __rhs._M_buf_allocated);
+      std::swap(_M_ext_buf, __rhs._M_ext_buf);
+      std::swap(_M_ext_buf_size, __rhs._M_ext_buf_size);
+      std::swap(_M_ext_next, __rhs._M_ext_next);
+      std::swap(_M_ext_end, __rhs._M_ext_end);
+      std::swap(_M_reading, __rhs._M_reading);
+      std::swap(_M_writing, __rhs._M_writing);
+      std::swap(_M_pback_cur_save, __rhs._M_pback_cur_save);
+      std::swap(_M_pback_end_save, __rhs._M_pback_end_save);
+      std::swap(_M_pback_init, __rhs._M_pback_init);
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
+    basic_filebuf<_CharT, _Traits>::
+    open(const char* __s, ios_base::openmode __mode)
+    {
+      __filebuf_type *__ret = 0;
+      if (!this->is_open())
+ {
+   _M_file.open(__s, __mode);
+   if (this->is_open())
+     {
+       _M_allocate_internal_buffer();
+       _M_mode = __mode;
+
+
+       _M_reading = false;
+       _M_writing = false;
+       _M_set_buffer(-1);
+
+
+       _M_state_last = _M_state_cur = _M_state_beg;
+
+
+       if ((__mode & ios_base::ate)
+    && this->seekoff(0, ios_base::end, __mode)
+    == pos_type(off_type(-1)))
+  this->close();
+       else
+  __ret = this;
+     }
+ }
+      return __ret;
+    }
+# 247 "/usr/include/c++/10.2.0/bits/fstream.tcc" 3
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
+    basic_filebuf<_CharT, _Traits>::
+    close()
+    {
+      if (!this->is_open())
+ return 0;
+
+      bool __testfail = false;
+      {
+
+ struct __close_sentry
+ {
+   basic_filebuf *__fb;
+   __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { }
+   ~__close_sentry ()
+   {
+     __fb->_M_mode = ios_base::openmode(0);
+     __fb->_M_pback_init = false;
+     __fb->_M_destroy_internal_buffer();
+     __fb->_M_reading = false;
+     __fb->_M_writing = false;
+     __fb->_M_set_buffer(-1);
+     __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg;
+   }
+ } __cs (this);
+
+ try
+   {
+     if (!_M_terminate_output())
+       __testfail = true;
+   }
+ catch(...)
+   {
+     _M_file.close();
+     throw;
+   }
+      }
+
+      if (!_M_file.close())
+ __testfail = true;
+
+      if (__testfail)
+ return 0;
+      else
+ return this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_filebuf<_CharT, _Traits>::
+    showmanyc()
+    {
+      streamsize __ret = -1;
+      const bool __testin = _M_mode & ios_base::in;
+      if (__testin && this->is_open())
+ {
+
+
+   __ret = this->egptr() - this->gptr();
+
+
+
+
+
+
+
+   if (__check_facet(_M_codecvt).encoding() >= 0)
+
+     __ret += _M_file.showmanyc() / _M_codecvt->max_length();
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::int_type
+    basic_filebuf<_CharT, _Traits>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = _M_mode & ios_base::in;
+      if (__testin)
+ {
+   if (_M_writing)
+     {
+       if (overflow() == traits_type::eof())
+  return __ret;
+       _M_set_buffer(-1);
+       _M_writing = false;
+     }
+
+
+
+   _M_destroy_pback();
+
+   if (this->gptr() < this->egptr())
+     return traits_type::to_int_type(*this->gptr());
+
+
+   const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
+
+
+   bool __got_eof = false;
+
+   streamsize __ilen = 0;
+   codecvt_base::result __r = codecvt_base::ok;
+   if (__check_facet(_M_codecvt).always_noconv())
+     {
+       __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
+          __buflen);
+       if (__ilen == 0)
+  __got_eof = true;
+     }
+   else
+     {
+
+
+       const int __enc = _M_codecvt->encoding();
+       streamsize __blen;
+       streamsize __rlen;
+       if (__enc > 0)
+  __blen = __rlen = __buflen * __enc;
+       else
+  {
+    __blen = __buflen + _M_codecvt->max_length() - 1;
+    __rlen = __buflen;
+  }
+       const streamsize __remainder = _M_ext_end - _M_ext_next;
+       __rlen = __rlen > __remainder ? __rlen - __remainder : 0;
+
+
+
+       if (_M_reading && this->egptr() == this->eback() && __remainder)
+  __rlen = 0;
+
+
+
+       if (_M_ext_buf_size < __blen)
+  {
+    char* __buf = new char[__blen];
+    if (__remainder)
+      __builtin_memcpy(__buf, _M_ext_next, __remainder);
+
+    delete [] _M_ext_buf;
+    _M_ext_buf = __buf;
+    _M_ext_buf_size = __blen;
+  }
+       else if (__remainder)
+  __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
+
+       _M_ext_next = _M_ext_buf;
+       _M_ext_end = _M_ext_buf + __remainder;
+       _M_state_last = _M_state_cur;
+
+       do
+  {
+    if (__rlen > 0)
+      {
+
+
+
+        if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size)
+   {
+     __throw_ios_failure(("basic_filebuf::underflow " "codecvt::max_length() " "is not valid")
+
+                          );
+   }
+        streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen);
+        if (__elen == 0)
+   __got_eof = true;
+        else if (__elen == -1)
+   break;
+        _M_ext_end += __elen;
+      }
+
+    char_type* __iend = this->eback();
+    if (_M_ext_next < _M_ext_end)
+      __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
+      _M_ext_end, _M_ext_next,
+      this->eback(),
+      this->eback() + __buflen, __iend);
+    if (__r == codecvt_base::noconv)
+      {
+        size_t __avail = _M_ext_end - _M_ext_buf;
+        __ilen = std::min(__avail, __buflen);
+        traits_type::copy(this->eback(),
+     reinterpret_cast<char_type*>
+     (_M_ext_buf), __ilen);
+        _M_ext_next = _M_ext_buf + __ilen;
+      }
+    else
+      __ilen = __iend - this->eback();
+
+
+
+
+    if (__r == codecvt_base::error)
+      break;
+
+    __rlen = 1;
+  }
+       while (__ilen == 0 && !__got_eof);
+     }
+
+   if (__ilen > 0)
+     {
+       _M_set_buffer(__ilen);
+       _M_reading = true;
+       __ret = traits_type::to_int_type(*this->gptr());
+     }
+   else if (__got_eof)
+     {
+
+
+
+       _M_set_buffer(-1);
+       _M_reading = false;
+
+
+       if (__r == codecvt_base::partial)
+  __throw_ios_failure(("basic_filebuf::underflow " "incomplete character in file")
+                                       );
+     }
+   else if (__r == codecvt_base::error)
+     __throw_ios_failure(("basic_filebuf::underflow " "invalid byte sequence in file")
+                                    );
+   else
+     __throw_ios_failure(("basic_filebuf::underflow " "error reading the file")
+                             , (*__errno_location ()));
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::int_type
+    basic_filebuf<_CharT, _Traits>::
+    pbackfail(int_type __i)
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = _M_mode & ios_base::in;
+      if (__testin)
+ {
+   if (_M_writing)
+     {
+       if (overflow() == traits_type::eof())
+  return __ret;
+       _M_set_buffer(-1);
+       _M_writing = false;
+     }
+
+
+   const bool __testpb = _M_pback_init;
+   const bool __testeof = traits_type::eq_int_type(__i, __ret);
+   int_type __tmp;
+   if (this->eback() < this->gptr())
+     {
+       this->gbump(-1);
+       __tmp = traits_type::to_int_type(*this->gptr());
+     }
+   else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1)))
+     {
+       __tmp = this->underflow();
+       if (traits_type::eq_int_type(__tmp, __ret))
+  return __ret;
+     }
+   else
+     {
+
+
+
+
+
+       return __ret;
+     }
+
+
+
+   if (!__testeof && traits_type::eq_int_type(__i, __tmp))
+     __ret = __i;
+   else if (__testeof)
+     __ret = traits_type::not_eof(__i);
+   else if (!__testpb)
+     {
+       _M_create_pback();
+       _M_reading = true;
+       *this->gptr() = traits_type::to_char_type(__i);
+       __ret = __i;
+     }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::int_type
+    basic_filebuf<_CharT, _Traits>::
+    overflow(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testeof = traits_type::eq_int_type(__c, __ret);
+      const bool __testout = (_M_mode & ios_base::out
+         || _M_mode & ios_base::app);
+      if (__testout)
+ {
+          if (_M_reading)
+            {
+              _M_destroy_pback();
+              const int __gptr_off = _M_get_ext_pos(_M_state_last);
+              if (_M_seek(__gptr_off, ios_base::cur, _M_state_last)
+                  == pos_type(off_type(-1)))
+                return __ret;
+            }
+   if (this->pbase() < this->pptr())
+     {
+
+       if (!__testeof)
+  {
+    *this->pptr() = traits_type::to_char_type(__c);
+    this->pbump(1);
+  }
+
+
+
+       if (_M_convert_to_external(this->pbase(),
+      this->pptr() - this->pbase()))
+  {
+    _M_set_buffer(0);
+    __ret = traits_type::not_eof(__c);
+  }
+     }
+   else if (_M_buf_size > 1)
+     {
+
+
+
+       _M_set_buffer(0);
+       _M_writing = true;
+       if (!__testeof)
+  {
+    *this->pptr() = traits_type::to_char_type(__c);
+    this->pbump(1);
+  }
+       __ret = traits_type::not_eof(__c);
+     }
+   else
+     {
+
+       char_type __conv = traits_type::to_char_type(__c);
+       if (__testeof || _M_convert_to_external(&__conv, 1))
+  {
+    _M_writing = true;
+    __ret = traits_type::not_eof(__c);
+  }
+     }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    basic_filebuf<_CharT, _Traits>::
+    _M_convert_to_external(_CharT* __ibuf, streamsize __ilen)
+    {
+
+      streamsize __elen;
+      streamsize __plen;
+      if (__check_facet(_M_codecvt).always_noconv())
+ {
+   __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
+   __plen = __ilen;
+ }
+      else
+ {
+
+
+   streamsize __blen = __ilen * _M_codecvt->max_length();
+   char* __buf = static_cast<char*>(__builtin_alloca(__blen));
+
+   char* __bend;
+   const char_type* __iend;
+   codecvt_base::result __r;
+   __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
+    __iend, __buf, __buf + __blen, __bend);
+
+   if (__r == codecvt_base::ok || __r == codecvt_base::partial)
+     __blen = __bend - __buf;
+   else if (__r == codecvt_base::noconv)
+     {
+
+       __buf = reinterpret_cast<char*>(__ibuf);
+       __blen = __ilen;
+     }
+   else
+     __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error")
+                           );
+
+   __elen = _M_file.xsputn(__buf, __blen);
+   __plen = __blen;
+
+
+   if (__r == codecvt_base::partial && __elen == __plen)
+     {
+       const char_type* __iresume = __iend;
+       streamsize __rlen = this->pptr() - __iend;
+       __r = _M_codecvt->out(_M_state_cur, __iresume,
+        __iresume + __rlen, __iend, __buf,
+        __buf + __blen, __bend);
+       if (__r != codecvt_base::error)
+  {
+    __rlen = __bend - __buf;
+    __elen = _M_file.xsputn(__buf, __rlen);
+    __plen = __rlen;
+  }
+       else
+  __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error")
+                        );
+     }
+ }
+      return __elen == __plen;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_filebuf<_CharT, _Traits>::
+    xsgetn(_CharT* __s, streamsize __n)
+    {
+
+      streamsize __ret = 0;
+      if (_M_pback_init)
+ {
+   if (__n > 0 && this->gptr() == this->eback())
+     {
+       *__s++ = *this->gptr();
+       this->gbump(1);
+       __ret = 1;
+       --__n;
+     }
+   _M_destroy_pback();
+ }
+      else if (_M_writing)
+ {
+   if (overflow() == traits_type::eof())
+     return __ret;
+   _M_set_buffer(-1);
+   _M_writing = false;
+ }
+
+
+
+
+      const bool __testin = _M_mode & ios_base::in;
+      const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;
+
+      if (__n > __buflen && __check_facet(_M_codecvt).always_noconv()
+   && __testin)
+ {
+
+   const streamsize __avail = this->egptr() - this->gptr();
+   if (__avail != 0)
+     {
+       traits_type::copy(__s, this->gptr(), __avail);
+       __s += __avail;
+       this->setg(this->eback(), this->gptr() + __avail, this->egptr());
+       __ret += __avail;
+       __n -= __avail;
+     }
+
+
+
+   streamsize __len;
+   for (;;)
+     {
+       __len = _M_file.xsgetn(reinterpret_cast<char*>(__s), __n);
+       if (__len == -1)
+  __throw_ios_failure(("basic_filebuf::xsgetn " "error reading the file")
+                              , (*__errno_location ()));
+       if (__len == 0)
+  break;
+
+       __n -= __len;
+       __ret += __len;
+       if (__n == 0)
+  break;
+
+       __s += __len;
+     }
+
+   if (__n == 0)
+     {
+
+       _M_reading = true;
+     }
+   else if (__len == 0)
+     {
+
+
+
+       _M_set_buffer(-1);
+       _M_reading = false;
+     }
+ }
+      else
+ __ret += __streambuf_type::xsgetn(__s, __n);
+
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_filebuf<_CharT, _Traits>::
+    xsputn(const _CharT* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+
+
+
+      const bool __testout = (_M_mode & ios_base::out
+         || _M_mode & ios_base::app);
+      if (__check_facet(_M_codecvt).always_noconv()
+   && __testout && !_M_reading)
+ {
+
+   const streamsize __chunk = 1ul << 10;
+   streamsize __bufavail = this->epptr() - this->pptr();
+
+
+   if (!_M_writing && _M_buf_size > 1)
+     __bufavail = _M_buf_size - 1;
+
+   const streamsize __limit = std::min(__chunk, __bufavail);
+   if (__n >= __limit)
+     {
+       const streamsize __buffill = this->pptr() - this->pbase();
+       const char* __buf = reinterpret_cast<const char*>(this->pbase());
+       __ret = _M_file.xsputn_2(__buf, __buffill,
+           reinterpret_cast<const char*>(__s),
+           __n);
+       if (__ret == __buffill + __n)
+  {
+    _M_set_buffer(0);
+    _M_writing = true;
+  }
+       if (__ret > __buffill)
+  __ret -= __buffill;
+       else
+  __ret = 0;
+     }
+   else
+     __ret = __streambuf_type::xsputn(__s, __n);
+ }
+       else
+  __ret = __streambuf_type::xsputn(__s, __n);
+       return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
+    basic_filebuf<_CharT, _Traits>::
+    setbuf(char_type* __s, streamsize __n)
+    {
+      if (!this->is_open())
+ {
+   if (__s == 0 && __n == 0)
+     _M_buf_size = 1;
+   else if (__s && __n > 0)
+     {
+# 820 "/usr/include/c++/10.2.0/bits/fstream.tcc" 3
+       _M_buf = __s;
+       _M_buf_size = __n;
+     }
+ }
+      return this;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::pos_type
+    basic_filebuf<_CharT, _Traits>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode)
+    {
+      int __width = 0;
+      if (_M_codecvt)
+ __width = _M_codecvt->encoding();
+      if (__width < 0)
+ __width = 0;
+
+      pos_type __ret = pos_type(off_type(-1));
+      const bool __testfail = __off != 0 && __width <= 0;
+      if (this->is_open() && !__testfail)
+ {
+
+
+
+
+   bool __no_movement = __way == ios_base::cur && __off == 0
+     && (!_M_writing || _M_codecvt->always_noconv());
+
+
+   if (!__no_movement)
+     _M_destroy_pback();
+
+
+
+
+
+
+   __state_type __state = _M_state_beg;
+   off_type __computed_off = __off * __width;
+   if (_M_reading && __way == ios_base::cur)
+     {
+       __state = _M_state_last;
+       __computed_off += _M_get_ext_pos(__state);
+     }
+   if (!__no_movement)
+     __ret = _M_seek(__computed_off, __way, __state);
+   else
+     {
+       if (_M_writing)
+  __computed_off = this->pptr() - this->pbase();
+
+       off_type __file_off = _M_file.seekoff(0, ios_base::cur);
+       if (__file_off != off_type(-1))
+  {
+    __ret = __file_off + __computed_off;
+    __ret.state(__state);
+  }
+     }
+ }
+      return __ret;
+    }
+
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::pos_type
+    basic_filebuf<_CharT, _Traits>::
+    seekpos(pos_type __pos, ios_base::openmode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      if (this->is_open())
+ {
+
+   _M_destroy_pback();
+   __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state());
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_filebuf<_CharT, _Traits>::pos_type
+    basic_filebuf<_CharT, _Traits>::
+    _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      if (_M_terminate_output())
+ {
+   off_type __file_off = _M_file.seekoff(__off, __way);
+   if (__file_off != off_type(-1))
+     {
+       _M_reading = false;
+       _M_writing = false;
+       _M_ext_next = _M_ext_end = _M_ext_buf;
+       _M_set_buffer(-1);
+       _M_state_cur = __state;
+       __ret = __file_off;
+       __ret.state(_M_state_cur);
+     }
+ }
+      return __ret;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    int basic_filebuf<_CharT, _Traits>::
+    _M_get_ext_pos(__state_type& __state)
+    {
+      if (_M_codecvt->always_noconv())
+        return this->gptr() - this->egptr();
+      else
+        {
+
+
+
+          const int __gptr_off =
+            _M_codecvt->length(__state, _M_ext_buf, _M_ext_next,
+                               this->gptr() - this->eback());
+          return _M_ext_buf + __gptr_off - _M_ext_end;
+        }
+    }
+
+  template<typename _CharT, typename _Traits>
+    bool
+    basic_filebuf<_CharT, _Traits>::
+    _M_terminate_output()
+    {
+
+      bool __testvalid = true;
+      if (this->pbase() < this->pptr())
+ {
+   const int_type __tmp = this->overflow();
+   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
+     __testvalid = false;
+ }
+
+
+      if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
+   && __testvalid)
+ {
+
+
+
+   const size_t __blen = 128;
+   char __buf[__blen];
+   codecvt_base::result __r;
+   streamsize __ilen = 0;
+
+   do
+     {
+       char* __next;
+       __r = _M_codecvt->unshift(_M_state_cur, __buf,
+     __buf + __blen, __next);
+       if (__r == codecvt_base::error)
+  __testvalid = false;
+       else if (__r == codecvt_base::ok ||
+         __r == codecvt_base::partial)
+  {
+    __ilen = __next - __buf;
+    if (__ilen > 0)
+      {
+        const streamsize __elen = _M_file.xsputn(__buf, __ilen);
+        if (__elen != __ilen)
+   __testvalid = false;
+      }
+  }
+     }
+   while (__r == codecvt_base::partial && __ilen > 0 && __testvalid);
+
+   if (__testvalid)
+     {
+
+
+
+
+       const int_type __tmp = this->overflow();
+       if (traits_type::eq_int_type(__tmp, traits_type::eof()))
+  __testvalid = false;
+     }
+ }
+      return __testvalid;
+    }
+
+  template<typename _CharT, typename _Traits>
+    int
+    basic_filebuf<_CharT, _Traits>::
+    sync()
+    {
+
+
+      int __ret = 0;
+      if (this->pbase() < this->pptr())
+ {
+   const int_type __tmp = this->overflow();
+   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
+     __ret = -1;
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_filebuf<_CharT, _Traits>::
+    imbue(const locale& __loc)
+    {
+      bool __testvalid = true;
+
+      const __codecvt_type* _M_codecvt_tmp = 0;
+      if (__builtin_expect(has_facet<__codecvt_type>(__loc), true))
+ _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc);
+
+      if (this->is_open())
+ {
+
+   if ((_M_reading || _M_writing)
+       && __check_facet(_M_codecvt).encoding() == -1)
+     __testvalid = false;
+   else
+     {
+       if (_M_reading)
+  {
+    if (__check_facet(_M_codecvt).always_noconv())
+      {
+        if (_M_codecvt_tmp
+     && !__check_facet(_M_codecvt_tmp).always_noconv())
+   __testvalid = this->seekoff(0, ios_base::cur, _M_mode)
+                 != pos_type(off_type(-1));
+      }
+    else
+      {
+
+        _M_ext_next = _M_ext_buf
+   + _M_codecvt->length(_M_state_last, _M_ext_buf,
+          _M_ext_next,
+          this->gptr() - this->eback());
+        const streamsize __remainder = _M_ext_end - _M_ext_next;
+        if (__remainder)
+   __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);
+
+        _M_ext_next = _M_ext_buf;
+        _M_ext_end = _M_ext_buf + __remainder;
+        _M_set_buffer(-1);
+        _M_state_last = _M_state_cur = _M_state_beg;
+      }
+  }
+       else if (_M_writing && (__testvalid = _M_terminate_output()))
+  _M_set_buffer(-1);
+     }
+ }
+
+      if (__testvalid)
+ _M_codecvt = _M_codecvt_tmp;
+      else
+ _M_codecvt = 0;
+    }
+
+
+
+
+  extern template class basic_filebuf<char>;
+  extern template class basic_ifstream<char>;
+  extern template class basic_ofstream<char>;
+  extern template class basic_fstream<char>;
+
+
+  extern template class basic_filebuf<wchar_t>;
+  extern template class basic_ifstream<wchar_t>;
+  extern template class basic_ofstream<wchar_t>;
+  extern template class basic_fstream<wchar_t>;
+
+
+
+
+}
+# 1294 "/usr/include/c++/10.2.0/fstream" 2 3
+# 20 "/home/ted/dev/openrct2/src/openrct2/core/OrcaStream.hpp" 2
+
+# 1 "/usr/include/c++/10.2.0/stack" 1 3
+# 58 "/usr/include/c++/10.2.0/stack" 3
+       
+# 59 "/usr/include/c++/10.2.0/stack" 3
+
+# 1 "/usr/include/c++/10.2.0/deque" 1 3
+# 58 "/usr/include/c++/10.2.0/deque" 3
+       
+# 59 "/usr/include/c++/10.2.0/deque" 3
+# 67 "/usr/include/c++/10.2.0/deque" 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_deque.h" 1 3
+# 72 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+# 95 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+  constexpr inline size_t
+  __deque_buf_size(size_t __size)
+  { return (__size < 512
+     ? size_t(512 / __size) : size_t(1)); }
+# 112 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Ref, typename _Ptr>
+    struct _Deque_iterator
+    {
+
+
+
+
+
+
+    private:
+      template<typename _CvTp>
+ using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_rebind<_Ptr, _CvTp>>;
+    public:
+      typedef __iter<_Tp> iterator;
+      typedef __iter<const _Tp> const_iterator;
+      typedef __ptr_rebind<_Ptr, _Tp> _Elt_pointer;
+      typedef __ptr_rebind<_Ptr, _Elt_pointer> _Map_pointer;
+
+
+      static size_t _S_buffer_size() noexcept
+      { return __deque_buf_size(sizeof(_Tp)); }
+
+      typedef std::random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef _Ptr pointer;
+      typedef _Ref reference;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Deque_iterator _Self;
+
+      _Elt_pointer _M_cur;
+      _Elt_pointer _M_first;
+      _Elt_pointer _M_last;
+      _Map_pointer _M_node;
+
+      _Deque_iterator(_Elt_pointer __x, _Map_pointer __y) noexcept
+      : _M_cur(__x), _M_first(*__y),
+ _M_last(*__y + _S_buffer_size()), _M_node(__y) { }
+
+      _Deque_iterator() noexcept
+      : _M_cur(), _M_first(), _M_last(), _M_node() { }
+# 161 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      template<typename _Iter,
+        typename = _Require<is_same<_Self, const_iterator>,
+       is_same<_Iter, iterator>>>
+       _Deque_iterator(const _Iter& __x) noexcept
+       : _M_cur(__x._M_cur), _M_first(__x._M_first),
+  _M_last(__x._M_last), _M_node(__x._M_node) { }
+
+      _Deque_iterator(const _Deque_iterator& __x) noexcept
+       : _M_cur(__x._M_cur), _M_first(__x._M_first),
+  _M_last(__x._M_last), _M_node(__x._M_node) { }
+
+      _Deque_iterator& operator=(const _Deque_iterator&) = default;
+
+
+      iterator
+      _M_const_cast() const noexcept
+      { return iterator(_M_cur, _M_node); }
+
+      reference
+      operator*() const noexcept
+      { return *_M_cur; }
+
+      pointer
+      operator->() const noexcept
+      { return _M_cur; }
+
+      _Self&
+      operator++() noexcept
+      {
+ ++_M_cur;
+ if (_M_cur == _M_last)
+   {
+     _M_set_node(_M_node + 1);
+     _M_cur = _M_first;
+   }
+ return *this;
+      }
+
+      _Self
+      operator++(int) noexcept
+      {
+ _Self __tmp = *this;
+ ++*this;
+ return __tmp;
+      }
+
+      _Self&
+      operator--() noexcept
+      {
+ if (_M_cur == _M_first)
+   {
+     _M_set_node(_M_node - 1);
+     _M_cur = _M_last;
+   }
+ --_M_cur;
+ return *this;
+      }
+
+      _Self
+      operator--(int) noexcept
+      {
+ _Self __tmp = *this;
+ --*this;
+ return __tmp;
+      }
+
+      _Self&
+      operator+=(difference_type __n) noexcept
+      {
+ const difference_type __offset = __n + (_M_cur - _M_first);
+ if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
+   _M_cur += __n;
+ else
+   {
+     const difference_type __node_offset =
+       __offset > 0 ? __offset / difference_type(_S_buffer_size())
+      : -difference_type((-__offset - 1)
+           / _S_buffer_size()) - 1;
+     _M_set_node(_M_node + __node_offset);
+     _M_cur = _M_first + (__offset - __node_offset
+     * difference_type(_S_buffer_size()));
+   }
+ return *this;
+      }
+
+      _Self&
+      operator-=(difference_type __n) noexcept
+      { return *this += -__n; }
+
+      reference
+      operator[](difference_type __n) const noexcept
+      { return *(*this + __n); }
+
+
+
+
+
+
+      void
+      _M_set_node(_Map_pointer __new_node) noexcept
+      {
+ _M_node = __new_node;
+ _M_first = *__new_node;
+ _M_last = _M_first + difference_type(_S_buffer_size());
+      }
+
+      friend bool
+      operator==(const _Self& __x, const _Self& __y) noexcept
+      { return __x._M_cur == __y._M_cur; }
+
+
+
+
+      template<typename _RefR, typename _PtrR>
+ friend bool
+ operator==(const _Self& __x,
+     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ noexcept
+ { return __x._M_cur == __y._M_cur; }
+# 290 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      friend bool
+      operator!=(const _Self& __x, const _Self& __y) noexcept
+      { return !(__x == __y); }
+
+      template<typename _RefR, typename _PtrR>
+ friend bool
+ operator!=(const _Self& __x,
+     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ noexcept
+ { return !(__x == __y); }
+
+      friend bool
+      operator<(const _Self& __x, const _Self& __y) noexcept
+      {
+ return (__x._M_node == __y._M_node)
+   ? (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
+      }
+
+      template<typename _RefR, typename _PtrR>
+ friend bool
+ operator<(const _Self& __x,
+    const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ noexcept
+ {
+   return (__x._M_node == __y._M_node)
+     ? (__x._M_cur < __y._M_cur) : (__x._M_node < __y._M_node);
+ }
+
+      friend bool
+      operator>(const _Self& __x, const _Self& __y) noexcept
+      { return __y < __x; }
+
+      template<typename _RefR, typename _PtrR>
+ friend bool
+ operator>(const _Self& __x,
+    const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ noexcept
+ { return __y < __x; }
+
+      friend bool
+      operator<=(const _Self& __x, const _Self& __y) noexcept
+      { return !(__y < __x); }
+
+      template<typename _RefR, typename _PtrR>
+ friend bool
+ operator<=(const _Self& __x,
+     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ noexcept
+ { return !(__y < __x); }
+
+      friend bool
+      operator>=(const _Self& __x, const _Self& __y) noexcept
+      { return !(__x < __y); }
+
+      template<typename _RefR, typename _PtrR>
+ friend bool
+ operator>=(const _Self& __x,
+     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
+ noexcept
+ { return !(__x < __y); }
+
+
+      friend difference_type
+      operator-(const _Self& __x, const _Self& __y) noexcept
+      {
+ return difference_type(_S_buffer_size())
+   * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+   + (__y._M_last - __y._M_cur);
+      }
+
+
+
+
+
+      template<typename _RefR, typename _PtrR>
+ friend difference_type
+ operator-(const _Self& __x,
+    const _Deque_iterator<_Tp, _RefR, _PtrR>& __y) noexcept
+ {
+   return difference_type(_S_buffer_size())
+     * (__x._M_node - __y._M_node - 1) + (__x._M_cur - __x._M_first)
+     + (__y._M_last - __y._M_cur);
+ }
+
+      friend _Self
+      operator+(const _Self& __x, difference_type __n) noexcept
+      {
+ _Self __tmp = __x;
+ __tmp += __n;
+ return __tmp;
+      }
+
+      friend _Self
+      operator-(const _Self& __x, difference_type __n) noexcept
+      {
+ _Self __tmp = __x;
+ __tmp -= __n;
+ return __tmp;
+      }
+
+      friend _Self
+      operator+(difference_type __n, const _Self& __x) noexcept
+      { return __x + __n; }
+    };
+# 405 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc>
+    class _Deque_base
+    {
+    protected:
+      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
+ rebind<_Tp>::other _Tp_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
+
+
+
+
+
+      typedef typename _Alloc_traits::pointer _Ptr;
+      typedef typename _Alloc_traits::const_pointer _Ptr_const;
+
+
+      typedef typename _Alloc_traits::template rebind<_Ptr>::other
+ _Map_alloc_type;
+      typedef __gnu_cxx::__alloc_traits<_Map_alloc_type> _Map_alloc_traits;
+
+      typedef _Alloc allocator_type;
+
+      allocator_type
+      get_allocator() const noexcept
+      { return allocator_type(_M_get_Tp_allocator()); }
+
+      typedef _Deque_iterator<_Tp, _Tp&, _Ptr> iterator;
+      typedef _Deque_iterator<_Tp, const _Tp&, _Ptr_const> const_iterator;
+
+      _Deque_base()
+      : _M_impl()
+      { _M_initialize_map(0); }
+
+      _Deque_base(size_t __num_elements)
+      : _M_impl()
+      { _M_initialize_map(__num_elements); }
+
+      _Deque_base(const allocator_type& __a, size_t __num_elements)
+      : _M_impl(__a)
+      { _M_initialize_map(__num_elements); }
+
+      _Deque_base(const allocator_type& __a)
+      : _M_impl(__a)
+      { }
+
+
+      _Deque_base(_Deque_base&& __x)
+      : _M_impl(std::move(__x._M_get_Tp_allocator()))
+      {
+ _M_initialize_map(0);
+ if (__x._M_impl._M_map)
+   this->_M_impl._M_swap_data(__x._M_impl);
+      }
+
+      _Deque_base(_Deque_base&& __x, const allocator_type& __a)
+      : _M_impl(std::move(__x._M_impl), _Tp_alloc_type(__a))
+      { __x._M_initialize_map(0); }
+
+      _Deque_base(_Deque_base&& __x, const allocator_type& __a, size_t __n)
+      : _M_impl(__a)
+      {
+ if (__x.get_allocator() == __a)
+   {
+     if (__x._M_impl._M_map)
+       {
+  _M_initialize_map(0);
+  this->_M_impl._M_swap_data(__x._M_impl);
+       }
+   }
+ else
+   {
+     _M_initialize_map(__n);
+   }
+      }
+
+
+      ~_Deque_base() noexcept;
+
+      typedef typename iterator::_Map_pointer _Map_pointer;
+
+      struct _Deque_impl_data
+      {
+ _Map_pointer _M_map;
+ size_t _M_map_size;
+ iterator _M_start;
+ iterator _M_finish;
+
+ _Deque_impl_data() noexcept
+ : _M_map(), _M_map_size(), _M_start(), _M_finish()
+ { }
+
+
+ _Deque_impl_data(const _Deque_impl_data&) = default;
+ _Deque_impl_data&
+ operator=(const _Deque_impl_data&) = default;
+
+ _Deque_impl_data(_Deque_impl_data&& __x) noexcept
+ : _Deque_impl_data(__x)
+ { __x = _Deque_impl_data(); }
+
+
+ void
+ _M_swap_data(_Deque_impl_data& __x) noexcept
+ {
+
+
+   std::swap(*this, __x);
+ }
+      };
+
+
+
+
+      struct _Deque_impl
+      : public _Tp_alloc_type, public _Deque_impl_data
+      {
+ _Deque_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value)
+
+ : _Tp_alloc_type()
+ { }
+
+ _Deque_impl(const _Tp_alloc_type& __a) noexcept
+ : _Tp_alloc_type(__a)
+ { }
+
+
+ _Deque_impl(_Deque_impl&&) = default;
+
+ _Deque_impl(_Tp_alloc_type&& __a) noexcept
+ : _Tp_alloc_type(std::move(__a))
+ { }
+
+ _Deque_impl(_Deque_impl&& __d, _Tp_alloc_type&& __a)
+ : _Tp_alloc_type(std::move(__a)), _Deque_impl_data(std::move(__d))
+ { }
+
+      };
+
+      _Tp_alloc_type&
+      _M_get_Tp_allocator() noexcept
+      { return this->_M_impl; }
+
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const noexcept
+      { return this->_M_impl; }
+
+      _Map_alloc_type
+      _M_get_map_allocator() const noexcept
+      { return _Map_alloc_type(_M_get_Tp_allocator()); }
+
+      _Ptr
+      _M_allocate_node()
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
+ return _Traits::allocate(_M_impl, __deque_buf_size(sizeof(_Tp)));
+      }
+
+      void
+      _M_deallocate_node(_Ptr __p) noexcept
+      {
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Traits;
+ _Traits::deallocate(_M_impl, __p, __deque_buf_size(sizeof(_Tp)));
+      }
+
+      _Map_pointer
+      _M_allocate_map(size_t __n)
+      {
+ _Map_alloc_type __map_alloc = _M_get_map_allocator();
+ return _Map_alloc_traits::allocate(__map_alloc, __n);
+      }
+
+      void
+      _M_deallocate_map(_Map_pointer __p, size_t __n) noexcept
+      {
+ _Map_alloc_type __map_alloc = _M_get_map_allocator();
+ _Map_alloc_traits::deallocate(__map_alloc, __p, __n);
+      }
+
+      void _M_initialize_map(size_t);
+      void _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish);
+      void _M_destroy_nodes(_Map_pointer __nstart,
+       _Map_pointer __nfinish) noexcept;
+      enum { _S_initial_map_size = 8 };
+
+      _Deque_impl _M_impl;
+    };
+
+  template<typename _Tp, typename _Alloc>
+    _Deque_base<_Tp, _Alloc>::
+    ~_Deque_base() noexcept
+    {
+      if (this->_M_impl._M_map)
+ {
+   _M_destroy_nodes(this->_M_impl._M_start._M_node,
+      this->_M_impl._M_finish._M_node + 1);
+   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+ }
+    }
+# 612 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_initialize_map(size_t __num_elements)
+    {
+      const size_t __num_nodes = (__num_elements / __deque_buf_size(sizeof(_Tp))
+      + 1);
+
+      this->_M_impl._M_map_size = std::max((size_t) _S_initial_map_size,
+        size_t(__num_nodes + 2));
+      this->_M_impl._M_map = _M_allocate_map(this->_M_impl._M_map_size);
+
+
+
+
+
+
+      _Map_pointer __nstart = (this->_M_impl._M_map
+          + (this->_M_impl._M_map_size - __num_nodes) / 2);
+      _Map_pointer __nfinish = __nstart + __num_nodes;
+
+      try
+ { _M_create_nodes(__nstart, __nfinish); }
+      catch(...)
+ {
+   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+   this->_M_impl._M_map = _Map_pointer();
+   this->_M_impl._M_map_size = 0;
+   throw;
+ }
+
+      this->_M_impl._M_start._M_set_node(__nstart);
+      this->_M_impl._M_finish._M_set_node(__nfinish - 1);
+      this->_M_impl._M_start._M_cur = _M_impl._M_start._M_first;
+      this->_M_impl._M_finish._M_cur = (this->_M_impl._M_finish._M_first
+     + __num_elements
+     % __deque_buf_size(sizeof(_Tp)));
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_create_nodes(_Map_pointer __nstart, _Map_pointer __nfinish)
+    {
+      _Map_pointer __cur;
+      try
+ {
+   for (__cur = __nstart; __cur < __nfinish; ++__cur)
+     *__cur = this->_M_allocate_node();
+ }
+      catch(...)
+ {
+   _M_destroy_nodes(__nstart, __cur);
+   throw;
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _Deque_base<_Tp, _Alloc>::
+    _M_destroy_nodes(_Map_pointer __nstart,
+       _Map_pointer __nfinish) noexcept
+    {
+      for (_Map_pointer __n = __nstart; __n < __nfinish; ++__n)
+ _M_deallocate_node(*__n);
+    }
+# 763 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class deque : protected _Deque_base<_Tp, _Alloc>
+    {
+# 776 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
+   "std::deque must have a non-const, non-volatile value_type");
+
+
+
+
+
+
+      typedef _Deque_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+      typedef typename _Base::_Alloc_traits _Alloc_traits;
+      typedef typename _Base::_Map_pointer _Map_pointer;
+
+    public:
+      typedef _Tp value_type;
+      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 _Base::iterator iterator;
+      typedef typename _Base::const_iterator 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;
+
+    private:
+      static size_t _S_buffer_size() noexcept
+      { return __deque_buf_size(sizeof(_Tp)); }
+
+
+      using _Base::_M_initialize_map;
+      using _Base::_M_create_nodes;
+      using _Base::_M_destroy_nodes;
+      using _Base::_M_allocate_node;
+      using _Base::_M_deallocate_node;
+      using _Base::_M_allocate_map;
+      using _Base::_M_deallocate_map;
+      using _Base::_M_get_Tp_allocator;
+
+
+
+
+
+      using _Base::_M_impl;
+
+    public:
+
+
+
+
+
+
+
+      deque() = default;
+# 840 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      explicit
+      deque(const allocator_type& __a)
+      : _Base(__a, 0) { }
+# 853 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      explicit
+      deque(size_type __n, const allocator_type& __a = allocator_type())
+      : _Base(__a, _S_check_init_len(__n, __a))
+      { _M_default_initialize(); }
+# 866 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      deque(size_type __n, const value_type& __value,
+     const allocator_type& __a = allocator_type())
+      : _Base(__a, _S_check_init_len(__n, __a))
+      { _M_fill_initialize(__value); }
+# 893 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      deque(const deque& __x)
+      : _Base(_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()),
+       __x.size())
+      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
+        this->_M_impl._M_start,
+        _M_get_Tp_allocator()); }
+# 909 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      deque(deque&&) = default;
+
+
+      deque(const deque& __x, const allocator_type& __a)
+      : _Base(__a, __x.size())
+      { std::__uninitialized_copy_a(__x.begin(), __x.end(),
+        this->_M_impl._M_start,
+        _M_get_Tp_allocator()); }
+
+
+      deque(deque&& __x, const allocator_type& __a)
+      : deque(std::move(__x), __a, typename _Alloc_traits::is_always_equal{})
+      { }
+
+    private:
+      deque(deque&& __x, const allocator_type& __a, true_type)
+      : _Base(std::move(__x), __a)
+      { }
+
+      deque(deque&& __x, const allocator_type& __a, false_type)
+      : _Base(std::move(__x), __a, __x.size())
+      {
+ if (__x.get_allocator() != __a && !__x.empty())
+   {
+     std::__uninitialized_move_a(__x.begin(), __x.end(),
+     this->_M_impl._M_start,
+     _M_get_Tp_allocator());
+     __x.clear();
+   }
+      }
+
+    public:
+# 952 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      deque(initializer_list<value_type> __l,
+     const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ _M_range_initialize(__l.begin(), __l.end(),
+       random_access_iterator_tag());
+      }
+# 977 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ deque(_InputIterator __first, _InputIterator __last,
+       const allocator_type& __a = allocator_type())
+ : _Base(__a)
+ {
+   _M_range_initialize(__first, __last,
+         std::__iterator_category(__first));
+ }
+# 1003 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      ~deque()
+      { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
+# 1015 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      deque&
+      operator=(const deque& __x);
+# 1027 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      deque&
+      operator=(deque&& __x) noexcept(_Alloc_traits::_S_always_equal())
+      {
+ using __always_equal = typename _Alloc_traits::is_always_equal;
+ _M_move_assign1(std::move(__x), __always_equal{});
+ return *this;
+      }
+# 1046 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      deque&
+      operator=(initializer_list<value_type> __l)
+      {
+ _M_assign_aux(__l.begin(), __l.end(),
+        random_access_iterator_tag());
+ return *this;
+      }
+# 1065 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 1082 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ void
+ assign(_InputIterator __first, _InputIterator __last)
+ { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+# 1109 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      assign(initializer_list<value_type> __l)
+      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }
+
+
+
+      allocator_type
+      get_allocator() const noexcept
+      { return _Base::get_allocator(); }
+
+
+
+
+
+
+      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(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const noexcept
+      { return const_reverse_iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      reverse_iterator
+      rend() noexcept
+      { return reverse_iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const noexcept
+      { return const_reverse_iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      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(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      const_reverse_iterator
+      crend() const noexcept
+      { return const_reverse_iterator(this->_M_impl._M_start); }
+
+
+
+
+      size_type
+      size() const noexcept
+      { return this->_M_impl._M_finish - this->_M_impl._M_start; }
+
+
+      size_type
+      max_size() const noexcept
+      { return _S_max_size(_M_get_Tp_allocator()); }
+# 1248 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      resize(size_type __new_size)
+      {
+ const size_type __len = size();
+ if (__new_size > __len)
+   _M_default_append(__new_size - __len);
+ else if (__new_size < __len)
+   _M_erase_at_end(this->_M_impl._M_start
+     + difference_type(__new_size));
+      }
+# 1270 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      resize(size_type __new_size, const value_type& __x)
+# 1287 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      {
+ const size_type __len = size();
+ if (__new_size > __len)
+   _M_fill_insert(this->_M_impl._M_finish, __new_size - __len, __x);
+ else if (__new_size < __len)
+   _M_erase_at_end(this->_M_impl._M_start
+     + difference_type(__new_size));
+      }
+
+
+
+      void
+      shrink_to_fit() noexcept
+      { _M_shrink_to_fit(); }
+
+
+
+
+
+
+      bool
+      empty() const noexcept
+      { return this->_M_impl._M_finish == this->_M_impl._M_start; }
+# 1323 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      reference
+      operator[](size_type __n) noexcept
+      {
+ ;
+ return this->_M_impl._M_start[difference_type(__n)];
+      }
+# 1341 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      const_reference
+      operator[](size_type __n) const noexcept
+      {
+ ;
+ return this->_M_impl._M_start[difference_type(__n)];
+      }
+
+    protected:
+
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range_fmt(("deque::_M_range_check: __n " "(which is %zu)>= this->size() " "(which is %zu)")
+
+                            ,
+       __n, this->size());
+      }
+
+    public:
+# 1372 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+# 1390 "/usr/include/c++/10.2.0/bits/stl_deque.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
+      {
+ ;
+ iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+
+
+
+
+
+      const_reference
+      back() const noexcept
+      {
+ ;
+ const_iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+# 1455 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      push_front(const value_type& __x)
+      {
+ if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
+   {
+     _Alloc_traits::construct(this->_M_impl,
+         this->_M_impl._M_start._M_cur - 1,
+         __x);
+     --this->_M_impl._M_start._M_cur;
+   }
+ else
+   _M_push_front_aux(__x);
+      }
+
+
+      void
+      push_front(value_type&& __x)
+      { emplace_front(std::move(__x)); }
+
+      template<typename... _Args>
+
+
+
+ void
+
+ emplace_front(_Args&&... __args);
+# 1492 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      push_back(const value_type& __x)
+      {
+ if (this->_M_impl._M_finish._M_cur
+     != this->_M_impl._M_finish._M_last - 1)
+   {
+     _Alloc_traits::construct(this->_M_impl,
+         this->_M_impl._M_finish._M_cur, __x);
+     ++this->_M_impl._M_finish._M_cur;
+   }
+ else
+   _M_push_back_aux(__x);
+      }
+
+
+      void
+      push_back(value_type&& __x)
+      { emplace_back(std::move(__x)); }
+
+      template<typename... _Args>
+
+
+
+ void
+
+ emplace_back(_Args&&... __args);
+# 1528 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      pop_front() noexcept
+      {
+ ;
+ if (this->_M_impl._M_start._M_cur
+     != this->_M_impl._M_start._M_last - 1)
+   {
+     _Alloc_traits::destroy(_M_get_Tp_allocator(),
+       this->_M_impl._M_start._M_cur);
+     ++this->_M_impl._M_start._M_cur;
+   }
+ else
+   _M_pop_front_aux();
+      }
+# 1551 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      pop_back() noexcept
+      {
+ ;
+ if (this->_M_impl._M_finish._M_cur
+     != this->_M_impl._M_finish._M_first)
+   {
+     --this->_M_impl._M_finish._M_cur;
+     _Alloc_traits::destroy(_M_get_Tp_allocator(),
+       this->_M_impl._M_finish._M_cur);
+   }
+ else
+   _M_pop_back_aux();
+      }
+# 1576 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      template<typename... _Args>
+ iterator
+ emplace(const_iterator __position, _Args&&... __args);
+# 1589 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      iterator
+      insert(const_iterator __position, const value_type& __x);
+# 1615 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      iterator
+      insert(const_iterator __position, value_type&& __x)
+      { return emplace(__position, std::move(__x)); }
+# 1629 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      iterator
+      insert(const_iterator __p, initializer_list<value_type> __l)
+      {
+ auto __offset = __p - cbegin();
+ _M_range_insert_aux(__p._M_const_cast(), __l.begin(), __l.end(),
+       std::random_access_iterator_tag());
+ return begin() + __offset;
+      }
+# 1648 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      iterator
+      insert(const_iterator __position, size_type __n, const value_type& __x)
+      {
+ difference_type __offset = __position - cbegin();
+ _M_fill_insert(__position._M_const_cast(), __n, __x);
+ return begin() + __offset;
+      }
+# 1682 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      template<typename _InputIterator,
+        typename = std::_RequireInputIter<_InputIterator>>
+ iterator
+ insert(const_iterator __position, _InputIterator __first,
+        _InputIterator __last)
+ {
+   difference_type __offset = __position - cbegin();
+   _M_range_insert_aux(__position._M_const_cast(), __first, __last,
+         std::__iterator_category(__first));
+   return begin() + __offset;
+ }
+# 1728 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      iterator
+
+      erase(const_iterator __position)
+
+
+
+      { return _M_erase(__position._M_const_cast()); }
+# 1752 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      iterator
+
+      erase(const_iterator __first, const_iterator __last)
+
+
+
+      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
+# 1771 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      swap(deque& __x) noexcept
+      {
+
+
+                                                          ;
+
+ _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(begin()); }
+
+    protected:
+# 1821 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      static size_t
+      _S_check_init_len(size_t __n, const allocator_type& __a)
+      {
+ if (__n > _S_max_size(__a))
+   __throw_length_error(
+       ("cannot create std::deque larger than max_size()"));
+ return __n;
+      }
+
+      static size_type
+      _S_max_size(const _Tp_alloc_type& __a) noexcept
+      {
+ const size_t __diffmax = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max;
+ const size_t __allocmax = _Alloc_traits::max_size(__a);
+ return (std::min)(__diffmax, __allocmax);
+      }
+# 1850 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      template<typename _InputIterator>
+ void
+ _M_range_initialize(_InputIterator __first, _InputIterator __last,
+       std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+ void
+ _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+       std::forward_iterator_tag);
+# 1872 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      _M_fill_initialize(const value_type& __value);
+
+
+
+      void
+      _M_default_initialize();
+# 1903 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      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)
+ {
+   const size_type __len = std::distance(__first, __last);
+   if (__len > size())
+     {
+       _ForwardIterator __mid = __first;
+       std::advance(__mid, size());
+       std::copy(__first, __mid, begin());
+       _M_range_insert_aux(end(), __mid, __last,
+      std::__iterator_category(__first));
+     }
+   else
+     _M_erase_at_end(std::copy(__first, __last, begin()));
+ }
+
+
+
+      void
+      _M_fill_assign(size_type __n, const value_type& __val)
+      {
+ if (__n > size())
+   {
+     std::fill(begin(), end(), __val);
+     _M_fill_insert(end(), __n - size(), __val);
+   }
+ else
+   {
+     _M_erase_at_end(begin() + difference_type(__n));
+     std::fill(begin(), end(), __val);
+   }
+      }
+# 1951 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      template<typename... _Args>
+ void _M_push_back_aux(_Args&&... __args);
+
+      template<typename... _Args>
+ void _M_push_front_aux(_Args&&... __args);
+
+
+      void _M_pop_back_aux();
+
+      void _M_pop_front_aux();
+# 1990 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      template<typename _InputIterator>
+ void
+ _M_range_insert_aux(iterator __pos, _InputIterator __first,
+       _InputIterator __last, std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+ void
+ _M_range_insert_aux(iterator __pos, _ForwardIterator __first,
+       _ForwardIterator __last, std::forward_iterator_tag);
+
+
+
+
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+
+
+
+
+
+
+      template<typename... _Args>
+ iterator
+ _M_insert_aux(iterator __pos, _Args&&... __args);
+
+
+
+      void
+      _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);
+
+
+      template<typename _ForwardIterator>
+ void
+ _M_insert_aux(iterator __pos,
+        _ForwardIterator __first, _ForwardIterator __last,
+        size_type __n);
+
+
+
+
+      void
+      _M_destroy_data_aux(iterator __first, iterator __last);
+
+
+
+      template<typename _Alloc1>
+ void
+ _M_destroy_data(iterator __first, iterator __last, const _Alloc1&)
+ { _M_destroy_data_aux(__first, __last); }
+
+      void
+      _M_destroy_data(iterator __first, iterator __last,
+        const std::allocator<_Tp>&)
+      {
+ if (!__has_trivial_destructor(value_type))
+   _M_destroy_data_aux(__first, __last);
+      }
+
+
+      void
+      _M_erase_at_begin(iterator __pos)
+      {
+ _M_destroy_data(begin(), __pos, _M_get_Tp_allocator());
+ _M_destroy_nodes(this->_M_impl._M_start._M_node, __pos._M_node);
+ this->_M_impl._M_start = __pos;
+      }
+
+
+
+      void
+      _M_erase_at_end(iterator __pos)
+      {
+ _M_destroy_data(__pos, end(), _M_get_Tp_allocator());
+ _M_destroy_nodes(__pos._M_node + 1,
+    this->_M_impl._M_finish._M_node + 1);
+ this->_M_impl._M_finish = __pos;
+      }
+
+      iterator
+      _M_erase(iterator __pos);
+
+      iterator
+      _M_erase(iterator __first, iterator __last);
+
+
+
+      void
+      _M_default_append(size_type __n);
+
+      bool
+      _M_shrink_to_fit();
+
+
+
+
+      iterator
+      _M_reserve_elements_at_front(size_type __n)
+      {
+ const size_type __vacancies = this->_M_impl._M_start._M_cur
+          - this->_M_impl._M_start._M_first;
+ if (__n > __vacancies)
+   _M_new_elements_at_front(__n - __vacancies);
+ return this->_M_impl._M_start - difference_type(__n);
+      }
+
+      iterator
+      _M_reserve_elements_at_back(size_type __n)
+      {
+ const size_type __vacancies = (this->_M_impl._M_finish._M_last
+           - this->_M_impl._M_finish._M_cur) - 1;
+ if (__n > __vacancies)
+   _M_new_elements_at_back(__n - __vacancies);
+ return this->_M_impl._M_finish + difference_type(__n);
+      }
+
+      void
+      _M_new_elements_at_front(size_type __new_elements);
+
+      void
+      _M_new_elements_at_back(size_type __new_elements);
+# 2122 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+      void
+      _M_reserve_map_at_back(size_type __nodes_to_add = 1)
+      {
+ if (__nodes_to_add + 1 > this->_M_impl._M_map_size
+     - (this->_M_impl._M_finish._M_node - this->_M_impl._M_map))
+   _M_reallocate_map(__nodes_to_add, false);
+      }
+
+      void
+      _M_reserve_map_at_front(size_type __nodes_to_add = 1)
+      {
+ if (__nodes_to_add > size_type(this->_M_impl._M_start._M_node
+           - this->_M_impl._M_map))
+   _M_reallocate_map(__nodes_to_add, true);
+      }
+
+      void
+      _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front);
+
+
+
+
+
+      void
+      _M_move_assign1(deque&& __x, true_type) noexcept
+      {
+ this->_M_impl._M_swap_data(__x._M_impl);
+ __x.clear();
+ std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator());
+      }
+
+
+
+
+      void
+      _M_move_assign1(deque&& __x, false_type)
+      {
+ constexpr bool __move_storage =
+   _Alloc_traits::_S_propagate_on_move_assign();
+ _M_move_assign2(std::move(__x), __bool_constant<__move_storage>());
+      }
+
+
+
+      template<typename... _Args>
+      void
+      _M_replace_map(_Args&&... __args)
+      {
+
+ deque __newobj(std::forward<_Args>(__args)...);
+
+ clear();
+ _M_deallocate_node(*begin()._M_node);
+ _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+ this->_M_impl._M_map = nullptr;
+ this->_M_impl._M_map_size = 0;
+
+ this->_M_impl._M_swap_data(__newobj._M_impl);
+      }
+
+
+      void
+      _M_move_assign2(deque&& __x, true_type)
+      {
+
+ auto __alloc = __x._M_get_Tp_allocator();
+
+
+ _M_replace_map(std::move(__x));
+
+ _M_get_Tp_allocator() = std::move(__alloc);
+      }
+
+
+
+      void
+      _M_move_assign2(deque&& __x, false_type)
+      {
+ if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
+   {
+
+
+     _M_replace_map(std::move(__x), __x.get_allocator());
+   }
+ else
+   {
+
+
+     _M_assign_aux(std::make_move_iterator(__x.begin()),
+     std::make_move_iterator(__x.end()),
+     std::random_access_iterator_tag());
+     __x.clear();
+   }
+      }
+
+    };
+# 2239 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
+    { return __x.size() == __y.size()
+      && std::equal(__x.begin(), __x.end(), __y.begin()); }
+# 2277 "/usr/include/c++/10.2.0/bits/stl_deque.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const deque<_Tp, _Alloc>& __x, const deque<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+
+
+
+
+
+
+
+  template<class _Tp>
+    struct __is_bitwise_relocatable<std::deque<_Tp>>
+    : true_type { };
+
+
+
+}
+# 68 "/usr/include/c++/10.2.0/deque" 2 3
+
+# 1 "/usr/include/c++/10.2.0/bits/deque.tcc" 1 3
+# 61 "/usr/include/c++/10.2.0/bits/deque.tcc" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_default_initialize()
+    {
+      _Map_pointer __cur;
+      try
+ {
+   for (__cur = this->_M_impl._M_start._M_node;
+        __cur < this->_M_impl._M_finish._M_node;
+        ++__cur)
+     std::__uninitialized_default_a(*__cur, *__cur + _S_buffer_size(),
+        _M_get_Tp_allocator());
+   std::__uninitialized_default_a(this->_M_impl._M_finish._M_first,
+      this->_M_impl._M_finish._M_cur,
+      _M_get_Tp_allocator());
+ }
+      catch(...)
+ {
+   std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
+   _M_get_Tp_allocator());
+   throw;
+ }
+    }
+
+
+  template <typename _Tp, typename _Alloc>
+    deque<_Tp, _Alloc>&
+    deque<_Tp, _Alloc>::
+    operator=(const deque& __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())
+  {
+
+
+    _M_replace_map(__x, __x.get_allocator());
+    std::__alloc_on_copy(_M_get_Tp_allocator(),
+           __x._M_get_Tp_allocator());
+    return *this;
+  }
+       std::__alloc_on_copy(_M_get_Tp_allocator(),
+       __x._M_get_Tp_allocator());
+     }
+
+   const size_type __len = size();
+   if (__len >= __x.size())
+     _M_erase_at_end(std::copy(__x.begin(), __x.end(),
+          this->_M_impl._M_start));
+   else
+     {
+       const_iterator __mid = __x.begin() + difference_type(__len);
+       std::copy(__x.begin(), __mid, this->_M_impl._M_start);
+       _M_range_insert_aux(this->_M_impl._M_finish, __mid, __x.end(),
+      std::random_access_iterator_tag());
+     }
+ }
+      return *this;
+    }
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+
+
+
+      void
+
+      deque<_Tp, _Alloc>::
+      emplace_front(_Args&&... __args)
+      {
+ if (this->_M_impl._M_start._M_cur != this->_M_impl._M_start._M_first)
+   {
+     _Alloc_traits::construct(this->_M_impl,
+         this->_M_impl._M_start._M_cur - 1,
+         std::forward<_Args>(__args)...);
+     --this->_M_impl._M_start._M_cur;
+   }
+ else
+   _M_push_front_aux(std::forward<_Args>(__args)...);
+
+
+
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+
+
+
+      void
+
+      deque<_Tp, _Alloc>::
+      emplace_back(_Args&&... __args)
+      {
+ if (this->_M_impl._M_finish._M_cur
+     != this->_M_impl._M_finish._M_last - 1)
+   {
+     _Alloc_traits::construct(this->_M_impl,
+         this->_M_impl._M_finish._M_cur,
+         std::forward<_Args>(__args)...);
+     ++this->_M_impl._M_finish._M_cur;
+   }
+ else
+   _M_push_back_aux(std::forward<_Args>(__args)...);
+
+
+
+      }
+
+
+
+  template<typename _Tp, typename _Alloc>
+    template<typename... _Args>
+      typename deque<_Tp, _Alloc>::iterator
+      deque<_Tp, _Alloc>::
+      emplace(const_iterator __position, _Args&&... __args)
+      {
+ if (__position._M_cur == this->_M_impl._M_start._M_cur)
+   {
+     emplace_front(std::forward<_Args>(__args)...);
+     return this->_M_impl._M_start;
+   }
+ else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
+   {
+     emplace_back(std::forward<_Args>(__args)...);
+     iterator __tmp = this->_M_impl._M_finish;
+     --__tmp;
+     return __tmp;
+   }
+ else
+   return _M_insert_aux(__position._M_const_cast(),
+          std::forward<_Args>(__args)...);
+      }
+
+
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+
+    insert(const_iterator __position, const value_type& __x)
+
+
+
+    {
+      if (__position._M_cur == this->_M_impl._M_start._M_cur)
+ {
+   push_front(__x);
+   return this->_M_impl._M_start;
+ }
+      else if (__position._M_cur == this->_M_impl._M_finish._M_cur)
+ {
+   push_back(__x);
+   iterator __tmp = this->_M_impl._M_finish;
+   --__tmp;
+   return __tmp;
+ }
+      else
+ return _M_insert_aux(__position._M_const_cast(), __x);
+   }
+
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+    _M_erase(iterator __position)
+    {
+      iterator __next = __position;
+      ++__next;
+      const difference_type __index = __position - begin();
+      if (static_cast<size_type>(__index) < (size() >> 1))
+ {
+   if (__position != begin())
+     std::move_backward(begin(), __position, __next);
+   pop_front();
+ }
+      else
+ {
+   if (__next != end())
+     std::move(__next, end(), __position);
+   pop_back();
+ }
+      return begin() + __index;
+    }
+
+  template <typename _Tp, typename _Alloc>
+    typename deque<_Tp, _Alloc>::iterator
+    deque<_Tp, _Alloc>::
+    _M_erase(iterator __first, iterator __last)
+    {
+      if (__first == __last)
+ return __first;
+      else if (__first == begin() && __last == end())
+ {
+   clear();
+   return end();
+ }
+      else
+ {
+   const difference_type __n = __last - __first;
+   const difference_type __elems_before = __first - begin();
+   if (static_cast<size_type>(__elems_before) <= (size() - __n) / 2)
+     {
+       if (__first != begin())
+  std::move_backward(begin(), __first, __last);
+       _M_erase_at_begin(begin() + __n);
+     }
+   else
+     {
+       if (__last != end())
+  std::move(__last, end(), __first);
+       _M_erase_at_end(end() - __n);
+     }
+   return begin() + __elems_before;
+ }
+    }
+
+  template <typename _Tp, class _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+ iterator __cur = begin();
+ for (; __first != __last && __cur != end(); ++__cur, (void)++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   _M_range_insert_aux(end(), __first, __last,
+         std::__iterator_category(__first));
+      }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_fill_insert(iterator __pos, size_type __n, const value_type& __x)
+    {
+      if (__pos._M_cur == this->_M_impl._M_start._M_cur)
+ {
+   iterator __new_start = _M_reserve_elements_at_front(__n);
+   try
+     {
+       std::__uninitialized_fill_a(__new_start, this->_M_impl._M_start,
+       __x, _M_get_Tp_allocator());
+       this->_M_impl._M_start = __new_start;
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(__new_start._M_node,
+          this->_M_impl._M_start._M_node);
+       throw;
+     }
+ }
+      else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
+ {
+   iterator __new_finish = _M_reserve_elements_at_back(__n);
+   try
+     {
+       std::__uninitialized_fill_a(this->_M_impl._M_finish,
+       __new_finish, __x,
+       _M_get_Tp_allocator());
+       this->_M_impl._M_finish = __new_finish;
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+       throw;
+     }
+ }
+      else
+ _M_insert_aux(__pos, __n, __x);
+    }
+
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_default_append(size_type __n)
+    {
+      if (__n)
+ {
+   iterator __new_finish = _M_reserve_elements_at_back(__n);
+   try
+     {
+       std::__uninitialized_default_a(this->_M_impl._M_finish,
+          __new_finish,
+          _M_get_Tp_allocator());
+       this->_M_impl._M_finish = __new_finish;
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+       throw;
+     }
+ }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    bool
+    deque<_Tp, _Alloc>::
+    _M_shrink_to_fit()
+    {
+      const difference_type __front_capacity
+ = (this->_M_impl._M_start._M_cur - this->_M_impl._M_start._M_first);
+      if (__front_capacity == 0)
+ return false;
+
+      const difference_type __back_capacity
+ = (this->_M_impl._M_finish._M_last - this->_M_impl._M_finish._M_cur);
+      if (__front_capacity + __back_capacity < _S_buffer_size())
+ return false;
+
+      return std::__shrink_to_fit_aux<deque>::_S_do_it(*this);
+    }
+
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_fill_initialize(const value_type& __value)
+    {
+      _Map_pointer __cur;
+      try
+ {
+   for (__cur = this->_M_impl._M_start._M_node;
+        __cur < this->_M_impl._M_finish._M_node;
+        ++__cur)
+     std::__uninitialized_fill_a(*__cur, *__cur + _S_buffer_size(),
+     __value, _M_get_Tp_allocator());
+   std::__uninitialized_fill_a(this->_M_impl._M_finish._M_first,
+          this->_M_impl._M_finish._M_cur,
+          __value, _M_get_Tp_allocator());
+ }
+      catch(...)
+ {
+   std::_Destroy(this->_M_impl._M_start, iterator(*__cur, __cur),
+   _M_get_Tp_allocator());
+   throw;
+ }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_initialize(_InputIterator __first, _InputIterator __last,
+     std::input_iterator_tag)
+      {
+ this->_M_initialize_map(0);
+ try
+   {
+     for (; __first != __last; ++__first)
+
+       emplace_back(*__first);
+
+
+
+   }
+ catch(...)
+   {
+     clear();
+     throw;
+   }
+      }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
+     std::forward_iterator_tag)
+      {
+ const size_type __n = std::distance(__first, __last);
+ this->_M_initialize_map(_S_check_init_len(__n, _M_get_Tp_allocator()));
+
+ _Map_pointer __cur_node;
+ try
+   {
+     for (__cur_node = this->_M_impl._M_start._M_node;
+   __cur_node < this->_M_impl._M_finish._M_node;
+   ++__cur_node)
+       {
+  _ForwardIterator __mid = __first;
+  std::advance(__mid, _S_buffer_size());
+  std::__uninitialized_copy_a(__first, __mid, *__cur_node,
+         _M_get_Tp_allocator());
+  __first = __mid;
+       }
+     std::__uninitialized_copy_a(__first, __last,
+     this->_M_impl._M_finish._M_first,
+     _M_get_Tp_allocator());
+   }
+ catch(...)
+   {
+     std::_Destroy(this->_M_impl._M_start,
+     iterator(*__cur_node, __cur_node),
+     _M_get_Tp_allocator());
+     throw;
+   }
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_back_aux(_Args&&... __args)
+
+
+
+
+
+      {
+ if (size() == max_size())
+   __throw_length_error(
+       ("cannot create std::deque larger than max_size()"));
+
+ _M_reserve_map_at_back();
+ *(this->_M_impl._M_finish._M_node + 1) = this->_M_allocate_node();
+ try
+   {
+
+     _Alloc_traits::construct(this->_M_impl,
+         this->_M_impl._M_finish._M_cur,
+         std::forward<_Args>(__args)...);
+
+
+
+     this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node
+      + 1);
+     this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_first;
+   }
+ catch(...)
+   {
+     _M_deallocate_node(*(this->_M_impl._M_finish._M_node + 1));
+     throw;
+   }
+      }
+
+
+  template<typename _Tp, typename _Alloc>
+
+    template<typename... _Args>
+      void
+      deque<_Tp, _Alloc>::
+      _M_push_front_aux(_Args&&... __args)
+
+
+
+
+
+      {
+ if (size() == max_size())
+   __throw_length_error(
+       ("cannot create std::deque larger than max_size()"));
+
+ _M_reserve_map_at_front();
+ *(this->_M_impl._M_start._M_node - 1) = this->_M_allocate_node();
+ try
+   {
+     this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node
+            - 1);
+     this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_last - 1;
+
+     _Alloc_traits::construct(this->_M_impl,
+         this->_M_impl._M_start._M_cur,
+         std::forward<_Args>(__args)...);
+
+
+
+   }
+ catch(...)
+   {
+     ++this->_M_impl._M_start;
+     _M_deallocate_node(*(this->_M_impl._M_start._M_node - 1));
+     throw;
+   }
+      }
+
+
+  template <typename _Tp, typename _Alloc>
+    void deque<_Tp, _Alloc>::
+    _M_pop_back_aux()
+    {
+      _M_deallocate_node(this->_M_impl._M_finish._M_first);
+      this->_M_impl._M_finish._M_set_node(this->_M_impl._M_finish._M_node - 1);
+      this->_M_impl._M_finish._M_cur = this->_M_impl._M_finish._M_last - 1;
+      _Alloc_traits::destroy(_M_get_Tp_allocator(),
+        this->_M_impl._M_finish._M_cur);
+    }
+
+
+
+
+
+
+  template <typename _Tp, typename _Alloc>
+    void deque<_Tp, _Alloc>::
+    _M_pop_front_aux()
+    {
+      _Alloc_traits::destroy(_M_get_Tp_allocator(),
+        this->_M_impl._M_start._M_cur);
+      _M_deallocate_node(this->_M_impl._M_start._M_first);
+      this->_M_impl._M_start._M_set_node(this->_M_impl._M_start._M_node + 1);
+      this->_M_impl._M_start._M_cur = this->_M_impl._M_start._M_first;
+    }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_insert_aux(iterator __pos,
+     _InputIterator __first, _InputIterator __last,
+     std::input_iterator_tag)
+      { std::copy(__first, __last, std::inserter(*this, __pos)); }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_range_insert_aux(iterator __pos,
+     _ForwardIterator __first, _ForwardIterator __last,
+     std::forward_iterator_tag)
+      {
+ const size_type __n = std::distance(__first, __last);
+ if (__pos._M_cur == this->_M_impl._M_start._M_cur)
+   {
+     iterator __new_start = _M_reserve_elements_at_front(__n);
+     try
+       {
+  std::__uninitialized_copy_a(__first, __last, __new_start,
+         _M_get_Tp_allocator());
+  this->_M_impl._M_start = __new_start;
+       }
+     catch(...)
+       {
+  _M_destroy_nodes(__new_start._M_node,
+     this->_M_impl._M_start._M_node);
+  throw;
+       }
+   }
+ else if (__pos._M_cur == this->_M_impl._M_finish._M_cur)
+   {
+     iterator __new_finish = _M_reserve_elements_at_back(__n);
+     try
+       {
+  std::__uninitialized_copy_a(__first, __last,
+         this->_M_impl._M_finish,
+         _M_get_Tp_allocator());
+  this->_M_impl._M_finish = __new_finish;
+       }
+     catch(...)
+       {
+  _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+     __new_finish._M_node + 1);
+  throw;
+       }
+   }
+ else
+   _M_insert_aux(__pos, __first, __last, __n);
+      }
+
+  template<typename _Tp, typename _Alloc>
+
+    template<typename... _Args>
+      typename deque<_Tp, _Alloc>::iterator
+      deque<_Tp, _Alloc>::
+      _M_insert_aux(iterator __pos, _Args&&... __args)
+      {
+ value_type __x_copy(std::forward<_Args>(__args)...);
+
+
+
+
+
+
+
+ difference_type __index = __pos - this->_M_impl._M_start;
+ if (static_cast<size_type>(__index) < size() / 2)
+   {
+     push_front(std::move(front()));
+     iterator __front1 = this->_M_impl._M_start;
+     ++__front1;
+     iterator __front2 = __front1;
+     ++__front2;
+     __pos = this->_M_impl._M_start + __index;
+     iterator __pos1 = __pos;
+     ++__pos1;
+     std::move(__front2, __pos1, __front1);
+   }
+ else
+   {
+     push_back(std::move(back()));
+     iterator __back1 = this->_M_impl._M_finish;
+     --__back1;
+     iterator __back2 = __back1;
+     --__back2;
+     __pos = this->_M_impl._M_start + __index;
+     std::move_backward(__pos, __back2, __back1);
+   }
+ *__pos = std::move(__x_copy);
+ return __pos;
+      }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_insert_aux(iterator __pos, size_type __n, const value_type& __x)
+    {
+      const difference_type __elems_before = __pos - this->_M_impl._M_start;
+      const size_type __length = this->size();
+      value_type __x_copy = __x;
+      if (__elems_before < difference_type(__length / 2))
+ {
+   iterator __new_start = _M_reserve_elements_at_front(__n);
+   iterator __old_start = this->_M_impl._M_start;
+   __pos = this->_M_impl._M_start + __elems_before;
+   try
+     {
+       if (__elems_before >= difference_type(__n))
+  {
+    iterator __start_n = (this->_M_impl._M_start
+     + difference_type(__n));
+    std::__uninitialized_move_a(this->_M_impl._M_start,
+           __start_n, __new_start,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_start = __new_start;
+    std::move(__start_n, __pos, __old_start);
+    std::fill(__pos - difference_type(__n), __pos, __x_copy);
+  }
+       else
+  {
+    std::__uninitialized_move_fill(this->_M_impl._M_start,
+       __pos, __new_start,
+       this->_M_impl._M_start,
+       __x_copy,
+       _M_get_Tp_allocator());
+    this->_M_impl._M_start = __new_start;
+    std::fill(__old_start, __pos, __x_copy);
+  }
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(__new_start._M_node,
+          this->_M_impl._M_start._M_node);
+       throw;
+     }
+ }
+      else
+ {
+   iterator __new_finish = _M_reserve_elements_at_back(__n);
+   iterator __old_finish = this->_M_impl._M_finish;
+   const difference_type __elems_after =
+     difference_type(__length) - __elems_before;
+   __pos = this->_M_impl._M_finish - __elems_after;
+   try
+     {
+       if (__elems_after > difference_type(__n))
+  {
+    iterator __finish_n = (this->_M_impl._M_finish
+      - difference_type(__n));
+    std::__uninitialized_move_a(__finish_n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::move_backward(__pos, __finish_n, __old_finish);
+    std::fill(__pos, __pos + difference_type(__n), __x_copy);
+  }
+       else
+  {
+    std::__uninitialized_fill_move(this->_M_impl._M_finish,
+       __pos + difference_type(__n),
+       __x_copy, __pos,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::fill(__pos, __old_finish, __x_copy);
+  }
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+       throw;
+     }
+ }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    template <typename _ForwardIterator>
+      void
+      deque<_Tp, _Alloc>::
+      _M_insert_aux(iterator __pos,
+      _ForwardIterator __first, _ForwardIterator __last,
+      size_type __n)
+      {
+ const difference_type __elemsbefore = __pos - this->_M_impl._M_start;
+ const size_type __length = size();
+ if (static_cast<size_type>(__elemsbefore) < __length / 2)
+   {
+     iterator __new_start = _M_reserve_elements_at_front(__n);
+     iterator __old_start = this->_M_impl._M_start;
+     __pos = this->_M_impl._M_start + __elemsbefore;
+     try
+       {
+  if (__elemsbefore >= difference_type(__n))
+    {
+      iterator __start_n = (this->_M_impl._M_start
+       + difference_type(__n));
+      std::__uninitialized_move_a(this->_M_impl._M_start,
+      __start_n, __new_start,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_start = __new_start;
+      std::move(__start_n, __pos, __old_start);
+      std::copy(__first, __last, __pos - difference_type(__n));
+    }
+  else
+    {
+      _ForwardIterator __mid = __first;
+      std::advance(__mid, difference_type(__n) - __elemsbefore);
+      std::__uninitialized_move_copy(this->_M_impl._M_start,
+         __pos, __first, __mid,
+         __new_start,
+         _M_get_Tp_allocator());
+      this->_M_impl._M_start = __new_start;
+      std::copy(__mid, __last, __old_start);
+    }
+       }
+     catch(...)
+       {
+  _M_destroy_nodes(__new_start._M_node,
+     this->_M_impl._M_start._M_node);
+  throw;
+       }
+   }
+ else
+ {
+   iterator __new_finish = _M_reserve_elements_at_back(__n);
+   iterator __old_finish = this->_M_impl._M_finish;
+   const difference_type __elemsafter =
+     difference_type(__length) - __elemsbefore;
+   __pos = this->_M_impl._M_finish - __elemsafter;
+   try
+     {
+       if (__elemsafter > difference_type(__n))
+  {
+    iterator __finish_n = (this->_M_impl._M_finish
+      - difference_type(__n));
+    std::__uninitialized_move_a(__finish_n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::move_backward(__pos, __finish_n, __old_finish);
+    std::copy(__first, __last, __pos);
+  }
+       else
+  {
+    _ForwardIterator __mid = __first;
+    std::advance(__mid, __elemsafter);
+    std::__uninitialized_copy_move(__mid, __last, __pos,
+       this->_M_impl._M_finish,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+    this->_M_impl._M_finish = __new_finish;
+    std::copy(__first, __mid, __pos);
+  }
+     }
+   catch(...)
+     {
+       _M_destroy_nodes(this->_M_impl._M_finish._M_node + 1,
+          __new_finish._M_node + 1);
+       throw;
+     }
+ }
+      }
+
+   template<typename _Tp, typename _Alloc>
+     void
+     deque<_Tp, _Alloc>::
+     _M_destroy_data_aux(iterator __first, iterator __last)
+     {
+       for (_Map_pointer __node = __first._M_node + 1;
+     __node < __last._M_node; ++__node)
+  std::_Destroy(*__node, *__node + _S_buffer_size(),
+         _M_get_Tp_allocator());
+
+       if (__first._M_node != __last._M_node)
+  {
+    std::_Destroy(__first._M_cur, __first._M_last,
+    _M_get_Tp_allocator());
+    std::_Destroy(__last._M_first, __last._M_cur,
+    _M_get_Tp_allocator());
+  }
+       else
+  std::_Destroy(__first._M_cur, __last._M_cur,
+         _M_get_Tp_allocator());
+     }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_new_elements_at_front(size_type __new_elems)
+    {
+      if (this->max_size() - this->size() < __new_elems)
+ __throw_length_error(("deque::_M_new_elements_at_front"));
+
+      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
+         / _S_buffer_size());
+      _M_reserve_map_at_front(__new_nodes);
+      size_type __i;
+      try
+ {
+   for (__i = 1; __i <= __new_nodes; ++__i)
+     *(this->_M_impl._M_start._M_node - __i) = this->_M_allocate_node();
+ }
+      catch(...)
+ {
+   for (size_type __j = 1; __j < __i; ++__j)
+     _M_deallocate_node(*(this->_M_impl._M_start._M_node - __j));
+   throw;
+ }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_new_elements_at_back(size_type __new_elems)
+    {
+      if (this->max_size() - this->size() < __new_elems)
+ __throw_length_error(("deque::_M_new_elements_at_back"));
+
+      const size_type __new_nodes = ((__new_elems + _S_buffer_size() - 1)
+         / _S_buffer_size());
+      _M_reserve_map_at_back(__new_nodes);
+      size_type __i;
+      try
+ {
+   for (__i = 1; __i <= __new_nodes; ++__i)
+     *(this->_M_impl._M_finish._M_node + __i) = this->_M_allocate_node();
+ }
+      catch(...)
+ {
+   for (size_type __j = 1; __j < __i; ++__j)
+     _M_deallocate_node(*(this->_M_impl._M_finish._M_node + __j));
+   throw;
+ }
+    }
+
+  template <typename _Tp, typename _Alloc>
+    void
+    deque<_Tp, _Alloc>::
+    _M_reallocate_map(size_type __nodes_to_add, bool __add_at_front)
+    {
+      const size_type __old_num_nodes
+ = this->_M_impl._M_finish._M_node - this->_M_impl._M_start._M_node + 1;
+      const size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;
+
+      _Map_pointer __new_nstart;
+      if (this->_M_impl._M_map_size > 2 * __new_num_nodes)
+ {
+   __new_nstart = this->_M_impl._M_map + (this->_M_impl._M_map_size
+      - __new_num_nodes) / 2
+    + (__add_at_front ? __nodes_to_add : 0);
+   if (__new_nstart < this->_M_impl._M_start._M_node)
+     std::copy(this->_M_impl._M_start._M_node,
+        this->_M_impl._M_finish._M_node + 1,
+        __new_nstart);
+   else
+     std::copy_backward(this->_M_impl._M_start._M_node,
+          this->_M_impl._M_finish._M_node + 1,
+          __new_nstart + __old_num_nodes);
+ }
+      else
+ {
+   size_type __new_map_size = this->_M_impl._M_map_size
+         + std::max(this->_M_impl._M_map_size,
+      __nodes_to_add) + 2;
+
+   _Map_pointer __new_map = this->_M_allocate_map(__new_map_size);
+   __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2
+    + (__add_at_front ? __nodes_to_add : 0);
+   std::copy(this->_M_impl._M_start._M_node,
+      this->_M_impl._M_finish._M_node + 1,
+      __new_nstart);
+   _M_deallocate_map(this->_M_impl._M_map, this->_M_impl._M_map_size);
+
+   this->_M_impl._M_map = __new_map;
+   this->_M_impl._M_map_size = __new_map_size;
+ }
+
+      this->_M_impl._M_start._M_set_node(__new_nstart);
+      this->_M_impl._M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
+    }
+
+
+
+
+
+  template<typename _Tp, typename _VTp>
+    void
+    __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>& __first,
+       const std::_Deque_iterator<_Tp, _Tp&, _Tp*>& __last,
+       const _VTp& __value)
+    {
+      typedef std::_Deque_iterator<_Tp, _Tp&, _Tp*> _Iter;
+      if (__first._M_node != __last._M_node)
+ {
+   std::__fill_a1(__first._M_cur, __first._M_last, __value);
+
+   for (typename _Iter::_Map_pointer __node = __first._M_node + 1;
+        __node < __last._M_node; ++__node)
+     std::__fill_a1(*__node, *__node + _Iter::_S_buffer_size(), __value);
+
+   std::__fill_a1(__last._M_first, __last._M_cur, __value);
+ }
+      else
+ std::__fill_a1(__first._M_cur, __last._M_cur, __value);
+    }
+
+  template<bool _IsMove,
+    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
+    _OI
+    __copy_move_dit(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first,
+      std::_Deque_iterator<_Tp, _Ref, _Ptr> __last,
+      _OI __result)
+    {
+      typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter;
+      if (__first._M_node != __last._M_node)
+ {
+   __result
+     = std::__copy_move_a1<_IsMove>(__first._M_cur, __first._M_last,
+        __result);
+
+   for (typename _Iter::_Map_pointer __node = __first._M_node + 1;
+        __node != __last._M_node; ++__node)
+     __result
+       = std::__copy_move_a1<_IsMove>(*__node,
+          *__node + _Iter::_S_buffer_size(),
+          __result);
+
+   return std::__copy_move_a1<_IsMove>(__last._M_first, __last._M_cur,
+           __result);
+ }
+
+      return std::__copy_move_a1<_IsMove>(__first._M_cur, __last._M_cur,
+       __result);
+    }
+
+  template<bool _IsMove,
+    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
+    _OI
+    __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first,
+     std::_Deque_iterator<_Tp, _Ref, _Ptr> __last,
+     _OI __result)
+    { return __copy_move_dit<_IsMove>(__first, __last, __result); }
+
+  template<bool _IsMove,
+    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
+    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
+    __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr> __first,
+     std::_Deque_iterator<_ITp, _IRef, _IPtr> __last,
+     std::_Deque_iterator<_OTp, _OTp&, _OTp*> __result)
+    { return __copy_move_dit<_IsMove>(__first, __last, __result); }
+
+  template<bool _IsMove, typename _II, typename _Tp>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value,
+      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
+    __copy_move_a1(_II __first, _II __last,
+     std::_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef std::_Deque_iterator<_Tp, _Tp&, _Tp*> _Iter;
+      typedef typename _Iter::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+ {
+   const difference_type __clen
+     = std::min(__len, __result._M_last - __result._M_cur);
+   std::__copy_move_a1<_IsMove>(__first, __first + __clen,
+           __result._M_cur);
+
+   __first += __clen;
+   __result += __clen;
+   __len -= __clen;
+ }
+
+      return __result;
+    }
+
+  template<bool _IsMove,
+    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
+    _OI
+    __copy_move_backward_dit(
+  std::_Deque_iterator<_Tp, _Ref, _Ptr> __first,
+  std::_Deque_iterator<_Tp, _Ref, _Ptr> __last,
+  _OI __result)
+    {
+      typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter;
+      if (__first._M_node != __last._M_node)
+ {
+   __result = std::__copy_move_backward_a1<_IsMove>(
+  __last._M_first, __last._M_cur, __result);
+
+   for (typename _Iter::_Map_pointer __node = __last._M_node - 1;
+        __node != __first._M_node; --__node)
+     __result = std::__copy_move_backward_a1<_IsMove>(
+  *__node, *__node + _Iter::_S_buffer_size(), __result);
+
+   return std::__copy_move_backward_a1<_IsMove>(
+   __first._M_cur, __first._M_last, __result);
+ }
+
+      return std::__copy_move_backward_a1<_IsMove>(
+  __first._M_cur, __last._M_cur, __result);
+    }
+
+  template<bool _IsMove,
+    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
+    _OI
+    __copy_move_backward_a1(
+  std::_Deque_iterator<_Tp, _Ref, _Ptr> __first,
+  std::_Deque_iterator<_Tp, _Ref, _Ptr> __last,
+  _OI __result)
+    { return __copy_move_backward_dit<_IsMove>(__first, __last, __result); }
+
+  template<bool _IsMove,
+    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
+    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
+    __copy_move_backward_a1(
+  std::_Deque_iterator<_ITp, _IRef, _IPtr> __first,
+  std::_Deque_iterator<_ITp, _IRef, _IPtr> __last,
+  std::_Deque_iterator<_OTp, _OTp&, _OTp*> __result)
+    { return __copy_move_backward_dit<_IsMove>(__first, __last, __result); }
+
+  template<bool _IsMove, typename _II, typename _Tp>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value,
+      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
+    __copy_move_backward_a1(_II __first, _II __last,
+  std::_Deque_iterator<_Tp, _Tp&, _Tp*> __result)
+    {
+      typedef std::_Deque_iterator<_Tp, _Tp&, _Tp*> _Iter;
+      typedef typename _Iter::difference_type difference_type;
+
+      difference_type __len = __last - __first;
+      while (__len > 0)
+ {
+   difference_type __rlen = __result._M_cur - __result._M_first;
+   _Tp* __rend = __result._M_cur;
+   if (!__rlen)
+     {
+       __rlen = _Iter::_S_buffer_size();
+       __rend = *(__result._M_node - 1) + __rlen;
+     }
+
+   const difference_type __clen = std::min(__len, __rlen);
+   std::__copy_move_backward_a1<_IsMove>(__last - __clen, __last, __rend);
+
+   __last -= __clen;
+   __result -= __clen;
+   __len -= __clen;
+ }
+
+      return __result;
+    }
+
+  template<typename _Tp, typename _Ref, typename _Ptr, typename _II>
+    bool
+    __equal_dit(
+ const std::_Deque_iterator<_Tp, _Ref, _Ptr>& __first1,
+ const std::_Deque_iterator<_Tp, _Ref, _Ptr>& __last1,
+ _II __first2)
+    {
+      typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter;
+      if (__first1._M_node != __last1._M_node)
+ {
+   if (!std::__equal_aux1(__first1._M_cur, __first1._M_last, __first2))
+     return false;
+
+   __first2 += __first1._M_last - __first1._M_cur;
+   for (typename _Iter::_Map_pointer __node = __first1._M_node + 1;
+        __node != __last1._M_node;
+        __first2 += _Iter::_S_buffer_size(), ++__node)
+     if (!std::__equal_aux1(*__node, *__node + _Iter::_S_buffer_size(),
+      __first2))
+       return false;
+
+   return std::__equal_aux1(__last1._M_first, __last1._M_cur, __first2);
+ }
+
+      return std::__equal_aux1(__first1._M_cur, __last1._M_cur, __first2);
+    }
+
+  template<typename _Tp, typename _Ref, typename _Ptr, typename _II>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value, bool>::__type
+    __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first1,
+   std::_Deque_iterator<_Tp, _Ref, _Ptr> __last1,
+   _II __first2)
+    { return std::__equal_dit(__first1, __last1, __first2); }
+
+  template<typename _Tp1, typename _Ref1, typename _Ptr1,
+    typename _Tp2, typename _Ref2, typename _Ptr2>
+    bool
+    __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __first1,
+   std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __last1,
+   std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __first2)
+    { return std::__equal_dit(__first1, __last1, __first2); }
+
+  template<typename _II, typename _Tp, typename _Ref, typename _Ptr>
+    typename __gnu_cxx::__enable_if<
+      __is_random_access_iter<_II>::__value, bool>::__type
+    __equal_aux1(_II __first1, _II __last1,
+  std::_Deque_iterator<_Tp, _Ref, _Ptr> __first2)
+    {
+      typedef std::_Deque_iterator<_Tp, _Ref, _Ptr> _Iter;
+      typedef typename _Iter::difference_type difference_type;
+
+      difference_type __len = __last1 - __first1;
+      while (__len > 0)
+ {
+   const difference_type __clen
+     = std::min(__len, __first2._M_last - __first2._M_cur);
+   if (!std::__equal_aux1(__first1, __first1 + __clen, __first2._M_cur))
+     return false;
+
+   __first1 += __clen;
+   __len -= __clen;
+   __first2 += __clen;
+ }
+
+      return true;
+    }
+
+
+}
+# 70 "/usr/include/c++/10.2.0/deque" 2 3
+# 61 "/usr/include/c++/10.2.0/stack" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/stl_stack.h" 1 3
+# 65 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 98 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+  template<typename _Tp, typename _Sequence = deque<_Tp> >
+    class stack
+    {
+# 111 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+      template<typename _Tp1, typename _Seq1>
+ friend bool
+ operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
+
+      template<typename _Tp1, typename _Seq1>
+ friend bool
+ operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
+# 126 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+      template<typename _Alloc>
+ using _Uses = typename
+   enable_if<uses_allocator<_Sequence, _Alloc>::value>::type;
+# 139 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+    public:
+      typedef typename _Sequence::value_type value_type;
+      typedef typename _Sequence::reference reference;
+      typedef typename _Sequence::const_reference const_reference;
+      typedef typename _Sequence::size_type size_type;
+      typedef _Sequence container_type;
+
+    protected:
+
+      _Sequence c;
+
+    public:
+# 160 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+      template<typename _Seq = _Sequence, typename _Requires = typename
+        enable_if<is_default_constructible<_Seq>::value>::type>
+ stack()
+ : c() { }
+
+      explicit
+      stack(const _Sequence& __c)
+      : c(__c) { }
+
+      explicit
+      stack(_Sequence&& __c)
+      : c(std::move(__c)) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ explicit
+ stack(const _Alloc& __a)
+ : c(__a) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ stack(const _Sequence& __c, const _Alloc& __a)
+ : c(__c, __a) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ stack(_Sequence&& __c, const _Alloc& __a)
+ : c(std::move(__c), __a) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ stack(const stack& __q, const _Alloc& __a)
+ : c(__q.c, __a) { }
+
+      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
+ stack(stack&& __q, const _Alloc& __a)
+ : c(std::move(__q.c), __a) { }
+
+
+
+
+
+      bool
+      empty() const
+      { return c.empty(); }
+
+
+      size_type
+      size() const
+      { return c.size(); }
+
+
+
+
+
+      reference
+      top()
+      {
+ ;
+ return c.back();
+      }
+
+
+
+
+
+      const_reference
+      top() const
+      {
+ ;
+ return c.back();
+      }
+# 238 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+      void
+      push(const value_type& __x)
+      { c.push_back(__x); }
+
+
+      void
+      push(value_type&& __x)
+      { c.push_back(std::move(__x)); }
+
+
+
+
+
+
+
+      template<typename... _Args>
+ void
+ emplace(_Args&&... __args)
+ { c.emplace_back(std::forward<_Args>(__args)...); }
+# 271 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+      void
+      pop()
+      {
+ ;
+ c.pop_back();
+      }
+
+
+      void
+      swap(stack& __s)
+
+      noexcept(__is_nothrow_swappable<_Sequence>::value)
+
+
+
+      {
+ using std::swap;
+ swap(c, __s.c);
+      }
+
+    };
+# 317 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return __x.c == __y.c; }
+# 335 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return __x.c < __y.c; }
+
+
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Seq>
+    inline bool
+    operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
+    { return !(__x < __y); }
+# 372 "/usr/include/c++/10.2.0/bits/stl_stack.h" 3
+  template<typename _Tp, typename _Seq>
+    inline
+
+
+    typename enable_if<__is_swappable<_Seq>::value>::type
+
+
+
+    swap(stack<_Tp, _Seq>& __x, stack<_Tp, _Seq>& __y)
+    noexcept(noexcept(__x.swap(__y)))
+    { __x.swap(__y); }
+
+  template<typename _Tp, typename _Seq, typename _Alloc>
+    struct uses_allocator<stack<_Tp, _Seq>, _Alloc>
+    : public uses_allocator<_Seq, _Alloc>::type { };
+
+
+
+}
+# 62 "/usr/include/c++/10.2.0/stack" 2 3
+# 22 "/home/ted/dev/openrct2/src/openrct2/core/OrcaStream.hpp" 2
+
+
+
+
+# 25 "/home/ted/dev/openrct2/src/openrct2/core/OrcaStream.hpp"
+namespace OpenRCT2
+{
+    class OrcaStream
+    {
+    public:
+        enum class Mode
+        {
+            READING,
+            WRITING,
+        };
+
+        static constexpr uint32_t COMPRESSION_NONE = 0;
+        static constexpr uint32_t COMPRESSION_GZIP = 1;
+
+    private:
+#pragma pack(push, 1)
+        struct Header
+        {
+            uint32_t Magic{};
+            uint32_t TargetVersion{};
+            uint32_t MinVersion{};
+            uint32_t NumChunks{};
+            uint64_t UncompressedSize{};
+            uint32_t Compression{};
+            uint64_t CompressedSize{};
+            std::array<uint8_t, 20> Sha1{};
+            uint8_t padding[8];
+        };
+        static_assert(sizeof(Header) == 64, "Header should be 64 bytes");
+
+        struct ChunkEntry
+        {
+            uint32_t Id{};
+            uint64_t Offset{};
+            uint64_t Length{};
+        };
+#pragma pack(pop)
+
+        IStream* _stream;
+        Mode _mode;
+        Header _header;
+        std::vector<ChunkEntry> _chunks;
+        MemoryStream _buffer;
+        ChunkEntry _currentChunk;
+
+    public:
+        OrcaStream(IStream& stream, Mode mode)
+        {
+            _stream = &stream;
+            _mode = mode;
+            if (mode == Mode::READING)
+            {
+                _header = _stream->ReadValue<Header>();
+
+                _chunks.clear();
+                for (uint32_t i = 0; i < _header.NumChunks; i++)
+                {
+                    auto entry = _stream->ReadValue<ChunkEntry>();
+                    _chunks.push_back(entry);
+                }
+
+
+                _buffer = MemoryStream{};
+                uint8_t temp[2048];
+                uint64_t bytesLeft = _header.CompressedSize;
+                do
+                {
+                    auto readLen = std::min(bytesLeft, sizeof(temp));
+                    _stream->Read(temp, readLen);
+                    _buffer.Write(temp, readLen);
+                    bytesLeft -= readLen;
+                } while (bytesLeft > 0);
+
+
+                if (_header.Compression == COMPRESSION_GZIP)
+                {
+                    size_t outUncompressedSize{};
+                    auto uncompressedData = util_zlib_inflate(
+                        reinterpret_cast<const uint8_t*>(_buffer.GetData()), _buffer.GetLength(), &outUncompressedSize);
+                    if (_header.UncompressedSize != outUncompressedSize)
+                    {
+
+                    }
+                    _buffer.Clear();
+                    _buffer.Write(uncompressedData, outUncompressedSize);
+                    std::free(uncompressedData);
+                }
+            }
+            else
+            {
+                _header = {};
+                _header.Compression = COMPRESSION_GZIP;
+
+                _buffer = MemoryStream{};
+            }
+        }
+
+        OrcaStream(const OrcaStream&) = delete;
+
+        ~OrcaStream()
+        {
+            if (_mode == Mode::READING)
+            {
+            }
+            else
+            {
+                const void* uncompressedData = _buffer.GetData();
+                const uint64_t uncompressedSize = _buffer.GetLength();
+
+                _header.NumChunks = static_cast<uint32_t>(_chunks.size());
+                _header.UncompressedSize = uncompressedSize;
+                _header.CompressedSize = uncompressedSize;
+                _header.Sha1 = Crypt::SHA1(uncompressedData, uncompressedSize);
+
+
+                std::optional<std::vector<uint8_t>> compressedBytes;
+                if (_header.Compression == COMPRESSION_GZIP)
+                {
+                    compressedBytes = util_zlib_deflate(reinterpret_cast<const uint8_t*>(uncompressedData), uncompressedSize);
+                    if (compressedBytes)
+                    {
+                        _header.CompressedSize = compressedBytes->size();
+                    }
+                    else
+                    {
+
+                        _header.Compression = COMPRESSION_NONE;
+                    }
+                }
+
+
+                _stream->WriteValue(_header);
+                for (const auto& chunk : _chunks)
+                {
+                    _stream->WriteValue(chunk);
+                }
+
+
+                if (compressedBytes)
+                {
+                    _stream->Write(compressedBytes->data(), compressedBytes->size());
+                }
+                else
+                {
+                    _stream->Write(uncompressedData, uncompressedSize);
+                }
+            }
+        }
+
+        Mode GetMode() const
+        {
+            return _mode;
+        }
+
+        Header& GetHeader()
+        {
+            return _header;
+        }
+
+        const Header& GetHeader() const
+        {
+            return _header;
+        }
+
+        template<typename TFunc> bool ReadWriteChunk(uint32_t chunkId, TFunc f)
+        {
+            if (_mode == Mode::READING)
+            {
+                if (SeekChunk(chunkId))
+                {
+                    ChunkStream stream(_buffer, _mode);
+                    f(stream);
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                _currentChunk.Id = chunkId;
+                _currentChunk.Offset = _buffer.GetPosition();
+                _currentChunk.Length = 0;
+                ChunkStream stream(_buffer, _mode);
+                f(stream);
+                _currentChunk.Length = static_cast<uint64_t>(_buffer.GetPosition()) - _currentChunk.Offset;
+                _chunks.push_back(_currentChunk);
+                return true;
+            }
+        }
+
+    private:
+        bool SeekChunk(uint32_t id)
+        {
+            auto result = std::find_if(_chunks.begin(), _chunks.end(), [id](const ChunkEntry& e) { return e.Id == id; });
+            if (result != _chunks.end())
+            {
+                auto offset = result->Offset;
+                _buffer.SetPosition(offset);
+                return true;
+            }
+            return false;
+        }
+
+    public:
+        class ChunkStream
+        {
+        private:
+            struct ArrayState
+            {
+                std::streampos StartPos{};
+                std::streampos LastPos{};
+                size_t Count{};
+                size_t ElementSize{};
+            };
+
+            MemoryStream& _buffer;
+            Mode _mode;
+            std::stack<ArrayState> _arrayStack;
+
+        public:
+            ChunkStream(MemoryStream& buffer, Mode mode)
+                : _buffer(buffer)
+                , _mode(mode)
+            {
+            }
+
+            Mode GetMode() const
+            {
+                return _mode;
+            }
+
+            MemoryStream& GetStream()
+            {
+                return _buffer;
+            }
+
+            void ReadWrite(void* addr, size_t len)
+            {
+                if (_mode == Mode::READING)
+                {
+                    ReadBuffer(addr, len);
+                }
+                else
+                {
+                    WriteBuffer(addr, len);
+                }
+            }
+
+            template<typename T, typename = std::enable_if<std::is_integral<T>::value>> void ReadWrite(T& v)
+            {
+                if (_mode == Mode::READING)
+                {
+                    v = ReadInteger<T>();
+                }
+                else
+                {
+                    WriteInteger(v);
+                }
+            }
+
+            template<typename TMem, typename TSave> void ReadWriteAs(TMem& v)
+            {
+                TSave sv;
+                if (_mode != Mode::READING)
+                {
+                    sv = v;
+                }
+                ReadWrite(reinterpret_cast<void*>(&sv), sizeof(TSave));
+                if (_mode == Mode::READING)
+                {
+                    v = static_cast<TMem>(sv);
+                }
+            }
+
+            template<typename T, typename = std::enable_if<std::is_integral<T>::value>> T Read()
+            {
+                T v{};
+                ReadWrite(v);
+                return v;
+            }
+
+
+
+
+
+
+            void ReadWrite(std::string& v)
+            {
+                if (_mode == Mode::READING)
+                {
+                    v = ReadString();
+                }
+                else
+                {
+                    WriteString(v);
+                }
+            }
+
+            template<typename T, typename = std::enable_if<std::is_integral<T>::value>> void Write(const T& v)
+            {
+                if (_mode == Mode::READING)
+                {
+                    T temp;
+                    ReadWrite(temp);
+                }
+                else
+                {
+                    ReadWrite(v);
+                }
+            }
+
+
+
+
+            void Write(const std::string_view& v)
+            {
+                if (_mode == Mode::READING)
+                {
+                    std::string temp;
+                    ReadWrite(temp);
+                }
+                else
+                {
+                    WriteString(v);
+                }
+            }
+
+
+
+
+            void Write(const std::string& v)
+            {
+                Write(std::string_view(v));
+            }
+
+            template<typename TVec, typename TFunc> void ReadWriteVector(TVec& vec, TFunc f)
+            {
+                if (_mode == Mode::READING)
+                {
+                    auto count = BeginArray();
+                    vec.clear();
+                    for (size_t i = 0; i < count; i++)
+                    {
+                        auto& el = vec.emplace_back();
+                        f(el);
+                        NextArrayElement();
+                    }
+                    EndArray();
+                }
+                else
+                {
+                    BeginArray();
+                    for (auto& el : vec)
+                    {
+                        f(el);
+                        NextArrayElement();
+                    }
+                    EndArray();
+                }
+            }
+
+            template<typename TArr, size_t TArrSize, typename TFunc> void ReadWriteArray(TArr (&arr)[TArrSize], TFunc f)
+            {
+                if (_mode == Mode::READING)
+                {
+                    auto count = BeginArray();
+                    for (auto& el : arr)
+                    {
+                        el = {};
+                    }
+                    for (size_t i = 0; i < count; i++)
+                    {
+                        if (i < TArrSize)
+                        {
+                            f(arr[i]);
+                        }
+                        NextArrayElement();
+                    }
+                    EndArray();
+                }
+                else
+                {
+                    BeginArray();
+                    for (auto& el : arr)
+                    {
+                        if (f(el))
+                        {
+                            NextArrayElement();
+                        }
+                    }
+                    EndArray();
+                }
+            }
+
+        private:
+            void ReadBuffer(void* dst, size_t len)
+            {
+                _buffer.Read(dst, len);
+            }
+
+            void WriteBuffer(const void* buffer, size_t len)
+            {
+                _buffer.Write(buffer, len);
+            }
+
+            template<typename T, typename = std::enable_if<std::is_integral<T>::value>> T ReadInteger()
+            {
+                if (sizeof(T) > 4)
+                {
+                    if (std::is_signed<T>())
+                    {
+                        return static_cast<T>(Read<int64_t>());
+                    }
+                    else
+                    {
+                        return static_cast<T>(Read<uint64_t>());
+                    }
+                }
+                else
+                {
+                    if (std::is_signed<T>())
+                    {
+                        auto raw = Read<int32_t>();
+                        if (raw < std::numeric_limits<T>::min() || raw > std::numeric_limits<T>::max())
+                        {
+                            throw std::runtime_error("Value is incompatible with internal type.");
+                        }
+                        return static_cast<T>(raw);
+                    }
+                    else
+                    {
+                        auto raw = Read<uint32_t>();
+                        if (raw > std::numeric_limits<T>::max())
+                        {
+                            throw std::runtime_error("Value is incompatible with internal type.");
+                        }
+                        return static_cast<T>(raw);
+                    }
+                }
+            }
+
+            template<typename T, typename = std::enable_if<std::is_integral<T>::value>> void WriteInteger(T value)
+            {
+                if (sizeof(T) > 4)
+                {
+                    if (std::is_signed<T>())
+                    {
+                        Write(static_cast<int64_t>(value));
+                    }
+                    else
+                    {
+                        Write(static_cast<uint64_t>(value));
+                    }
+                }
+                else
+                {
+                    if (std::is_signed<T>())
+                    {
+                        Write(static_cast<int32_t>(value));
+                    }
+                    else
+                    {
+                        Write(static_cast<uint32_t>(value));
+                    }
+                }
+            }
+
+            std::string ReadString()
+            {
+                std::string buffer;
+                buffer.reserve(64);
+                while (true)
+                {
+                    char c;
+                    ReadBuffer(&c, sizeof(c));
+                    if (c == 0)
+                    {
+                        break;
+                    }
+                    buffer.push_back(c);
+                }
+                buffer.shrink_to_fit();
+                return buffer;
+            }
+
+            void WriteString(const std::string_view& s)
+            {
+                char nullt = '\0';
+                auto len = s.find('\0');
+                if (len == std::string_view::npos)
+                {
+                    len = s.size();
+                }
+                _buffer.Write(s.data(), len);
+                _buffer.Write(&nullt, sizeof(nullt));
+            }
+
+            size_t BeginArray()
+            {
+                auto& arrayState = _arrayStack.emplace();
+                if (_mode == Mode::READING)
+                {
+                    arrayState.Count = Read<uint32_t>();
+                    arrayState.ElementSize = Read<uint32_t>();
+                    arrayState.LastPos = _buffer.GetPosition();
+                    return arrayState.Count;
+                }
+                else
+                {
+                    arrayState.Count = 0;
+                    arrayState.ElementSize = 0;
+                    arrayState.StartPos = _buffer.GetPosition();
+                    Write<uint32_t>(0);
+                    Write<uint32_t>(0);
+                    arrayState.LastPos = _buffer.GetPosition();
+                    return 0;
+                }
+            }
+
+            bool NextArrayElement()
+            {
+                auto& arrayState = _arrayStack.top();
+                if (_mode == Mode::READING)
+                {
+                    if (arrayState.Count == 0)
+                    {
+                        return false;
+                    }
+                    if (arrayState.ElementSize != 0)
+                    {
+                        arrayState.LastPos += arrayState.ElementSize;
+                        _buffer.SetPosition(arrayState.LastPos);
+                    }
+                    arrayState.Count--;
+                    return arrayState.Count == 0;
+                }
+                else
+                {
+                    auto lastElSize = static_cast<size_t>(_buffer.GetPosition()) - arrayState.LastPos;
+                    if (arrayState.Count == 0)
+                    {
+
+                        arrayState.ElementSize = lastElSize;
+                    }
+                    else if (arrayState.ElementSize != lastElSize)
+                    {
+
+
+                        arrayState.ElementSize = 0;
+                    }
+                    arrayState.Count++;
+                    arrayState.LastPos = _buffer.GetPosition();
+                    return true;
+                }
+            }
+
+            void EndArray()
+            {
+                auto& arrayState = _arrayStack.top();
+                if (_mode == Mode::READING)
+                {
+                }
+                else
+                {
+                    size_t backupPos = _buffer.GetPosition();
+                    if (backupPos != static_cast<size_t>(arrayState.StartPos) + 8 && arrayState.Count == 0)
+                    {
+                        throw std::runtime_error("Array data was written but no elements were added.");
+                    }
+                    _buffer.SetPosition(arrayState.StartPos);
+                    Write(static_cast<uint32_t>(arrayState.Count));
+                    Write(static_cast<uint32_t>(arrayState.ElementSize));
+                    _buffer.SetPosition(backupPos);
+                }
+                _arrayStack.pop();
+            }
+        };
+    };
+}
+# 21 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/drawing/Drawing.h" 1
+# 22 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/interface/Viewport.h" 1
+# 23 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/interface/Window.h" 1
+# 24 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/localisation/Date.h" 1
+# 25 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/localisation/Localisation.h" 1
+# 26 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/management/Award.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/management/Award.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/management/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/management/Award.h" 2
+
+struct Award
+{
+    uint16_t Time;
+    uint16_t Type;
+};
+
+enum class ParkAward : uint8_t
+{
+    MostUntidy,
+    MostTidy,
+    BestRollerCoasters,
+    BestValue,
+    MostBeautiful,
+    WorstValue,
+    Safest,
+    BestStaff,
+    BestFood,
+    WorstFood,
+    BestRestrooms,
+    MostDisappointing,
+    BestWaterRides,
+    BestCustomDesignedRides,
+    MostDazzlingRideColours,
+    MostConfusingLayout,
+    BestGentleRides,
+    Count
+};
+
+
+
+extern Award gCurrentAwards[4];
+
+bool award_is_positive(int32_t type);
+void award_reset();
+void award_update_all();
+# 27 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/management/NewsItem.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/management/NewsItem.h"
+       
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/iterator" 1 3
+# 58 "/usr/include/c++/10.2.0/iterator" 3
+       
+# 59 "/usr/include/c++/10.2.0/iterator" 3
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+       
+# 34 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+
+
+
+
+# 37 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
+    class istream_iterator
+    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+
+    private:
+      istream_type* _M_stream;
+      _Tp _M_value;
+
+
+
+      bool _M_ok;
+
+    public:
+
+      constexpr istream_iterator()
+      : _M_stream(0), _M_value(), _M_ok(false) {}
+
+
+      istream_iterator(istream_type& __s)
+      : _M_stream(std::__addressof(__s)), _M_ok(true)
+      { _M_read(); }
+
+      istream_iterator(const istream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
+        _M_ok(__obj._M_ok)
+      { }
+# 88 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+      istream_iterator& operator=(const istream_iterator&) = default;
+      ~istream_iterator() = default;
+
+
+      const _Tp&
+      operator*() const
+      {
+
+
+                        ;
+ return _M_value;
+      }
+
+      const _Tp*
+      operator->() const { return std::__addressof((operator*())); }
+
+      istream_iterator&
+      operator++()
+      {
+
+
+                        ;
+ _M_read();
+ return *this;
+      }
+
+      istream_iterator
+      operator++(int)
+      {
+
+
+                        ;
+ istream_iterator __tmp = *this;
+ _M_read();
+ return __tmp;
+      }
+
+    private:
+      bool
+      _M_equal(const istream_iterator& __x) const
+      {
+
+
+ return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream);
+      }
+
+      void
+      _M_read()
+      {
+        if (_M_stream && !(*_M_stream >> _M_value))
+          {
+            _M_stream = 0;
+            _M_ok = false;
+          }
+      }
+
+
+
+      friend bool
+      operator==(const istream_iterator& __x, const istream_iterator& __y)
+      { return __x._M_equal(__y); }
+
+
+
+      friend bool
+      operator!=(const istream_iterator& __x, const istream_iterator& __y)
+      { return !__x._M_equal(__y); }
+
+
+
+
+
+
+    };
+# 174 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT> >
+    class ostream_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+
+
+    private:
+      ostream_type* _M_stream;
+      const _CharT* _M_string;
+
+    public:
+
+
+
+
+
+
+      ostream_iterator(ostream_type& __s)
+      : _M_stream(std::__addressof(__s)), _M_string(0) {}
+# 214 "/usr/include/c++/10.2.0/bits/stream_iterator.h" 3
+      ostream_iterator(ostream_type& __s, const _CharT* __c)
+      : _M_stream(std::__addressof(__s)), _M_string(__c) { }
+
+
+      ostream_iterator(const ostream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
+
+
+      ostream_iterator& operator=(const ostream_iterator&) = default;
+
+
+
+
+      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; }
+    };
+
+
+
+
+}
+# 66 "/usr/include/c++/10.2.0/iterator" 2 3
+# 17 "/home/ted/dev/openrct2/src/openrct2/management/NewsItem.h" 2
+
+
+
+
+# 20 "/home/ted/dev/openrct2/src/openrct2/management/NewsItem.h"
+struct CoordsXYZ;
+class Formatter;
+
+namespace News
+{
+    enum class ItemType : uint8_t
+    {
+        Null,
+        Ride,
+        PeepOnRide,
+        Peep,
+        Money,
+        Blank,
+        Research,
+        Peeps,
+        Award,
+        Graph,
+        Count
+    };
+
+    constexpr size_t ItemTypeCount = static_cast<size_t>(News::ItemType::Count);
+
+    enum ItemTypeProperty : uint8_t
+    {
+        HasLocation = 1,
+        HasSubject = 2,
+    };
+
+    enum ItemFlags : uint8_t
+    {
+        HasButton = 1 << 0,
+    };
+
+
+
+
+    struct Item
+    {
+        News::ItemType Type;
+        uint8_t Flags;
+        uint32_t Assoc;
+        uint16_t Ticks;
+        uint16_t MonthYear;
+        uint8_t Day;
+        std::string Text;
+
+        constexpr bool IsEmpty() const noexcept
+        {
+            return Type == News::ItemType::Null;
+        }
+
+        constexpr uint8_t GetTypeProperties() const
+        {
+            switch (Type)
+            {
+                case News::ItemType::Blank:
+                    return News::ItemTypeProperty::HasLocation;
+                case News::ItemType::Money:
+                case News::ItemType::Research:
+                case News::ItemType::Peeps:
+                case News::ItemType::Award:
+                case News::ItemType::Graph:
+                    return News::ItemTypeProperty::HasSubject;
+                case News::ItemType::Ride:
+                case News::ItemType::PeepOnRide:
+                case News::ItemType::Peep:
+                    return News::ItemTypeProperty::HasLocation | News::ItemTypeProperty::HasSubject;
+                case News::ItemType::Null:
+                case News::ItemType::Count:
+                default:
+                    return 0;
+            }
+        }
+
+        void SetFlags(uint8_t flag)
+        {
+            Flags |= flag;
+        }
+
+        constexpr bool TypeHasSubject() const
+        {
+            return this->GetTypeProperties() & News::ItemTypeProperty::HasSubject;
+        }
+
+        constexpr bool TypeHasLocation() const
+        {
+            return this->GetTypeProperties() & News::ItemTypeProperty::HasLocation;
+        }
+
+        constexpr bool HasButton() const noexcept
+        {
+            return Flags & News::ItemFlags::HasButton;
+        }
+    };
+
+    constexpr int32_t ItemHistoryStart = 11;
+    constexpr int32_t MaxItemsArchive = 50;
+    constexpr int32_t MaxItems = News::ItemHistoryStart + News::MaxItemsArchive;
+
+    template<std::size_t N> class ItemQueue
+    {
+    public:
+        static_assert(N > 0, "Cannot instantiate News::ItemQueue with size=0");
+
+        using value_type = typename std::array<News::Item, N>::value_type;
+        using pointer = value_type*;
+        using const_pointer = const value_type*;
+        using reference = value_type&;
+        using const_reference = const value_type&;
+        using iterator = typename std::array<News::Item, N>::iterator;
+        using const_iterator = typename std::array<News::Item, N>::const_iterator;
+        using size_type = std::size_t;
+        using difference_type = std::ptrdiff_t;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+        ItemQueue()
+        {
+            Queue[0].Type = News::ItemType::Null;
+        }
+
+        constexpr iterator begin() noexcept
+        {
+            return std::begin(Queue);
+        }
+        constexpr const_iterator begin() const noexcept
+        {
+            return cbegin();
+        }
+        constexpr const_iterator cbegin() const noexcept
+        {
+            return std::cbegin(Queue);
+        }
+        iterator end() noexcept
+        {
+            return std::find_if(std::begin(Queue), std::end(Queue), [](const_reference item) { return item.IsEmpty(); });
+        }
+        const_iterator end() const noexcept
+        {
+            return cend();
+        }
+        const_iterator cend() const noexcept
+        {
+            return std::find_if(std::cbegin(Queue), std::cend(Queue), [](const_reference item) { return item.IsEmpty(); });
+        }
+
+        constexpr bool empty() const noexcept
+        {
+            return Queue[0].IsEmpty();
+        }
+
+        size_type size() const noexcept
+        {
+            return std::distance(cbegin(), cend());
+        }
+
+        reference front() noexcept
+        {
+            return *begin();
+        }
+        const_reference front() const noexcept
+        {
+            return *cbegin();
+        }
+        reference back() noexcept
+        {
+            return *end();
+        }
+        const_reference back() const noexcept
+        {
+            return *cend();
+        }
+
+        void pop_front()
+        {
+            std::move(std::begin(Queue) + 1, std::end(Queue), std::begin(Queue));
+            Queue[N - 1].Type = News::ItemType::Null;
+        }
+
+        void push_back(const_reference item)
+        {
+            auto it = end();
+            if (!std::distance(it, std::end(Queue)))
+            {
+
+                pop_front();
+                Queue[N - 1] = item;
+            }
+            else
+            {
+                *it = item;
+                ++it;
+                if (std::distance(it, std::end(Queue)))
+                    it->Type = News::ItemType::Null;
+            }
+        }
+
+        reference operator[](size_type n) noexcept
+        {
+            return Queue[n];
+        }
+        const_reference operator[](size_type n) const noexcept
+        {
+            return Queue[n];
+        }
+
+        constexpr size_type capacity() const noexcept
+        {
+            return N;
+        }
+
+        void clear() noexcept
+        {
+            front().Type = News::ItemType::Null;
+        }
+
+    private:
+        std::array<News::Item, N> Queue;
+    };
+
+    struct ItemQueues
+    {
+        News::Item& operator[](size_t index);
+        const News::Item& operator[](size_t index) const;
+        News::Item* At(int32_t index);
+        const News::Item* At(int32_t index) const;
+        bool IsEmpty() const;
+        void Clear();
+        uint16_t IncrementTicks();
+        News::Item& Current();
+        const News::Item& Current() const;
+        bool CurrentShouldBeArchived() const;
+        void ArchiveCurrent();
+        News::Item* FirstOpenOrNewSlot();
+        const auto& GetRecent() const
+        {
+            return Recent;
+        }
+        const auto& GetArchived() const
+        {
+            return Archived;
+        }
+
+        template<typename Predicate> void ForeachRecentNews(Predicate&& p)
+        {
+            for (auto& newsItem : Recent)
+            {
+                p(newsItem);
+            }
+        }
+
+        template<typename Predicate> void ForeachArchivedNews(Predicate&& p)
+        {
+            for (auto& newsItem : Archived)
+            {
+                p(newsItem);
+            }
+        }
+
+    private:
+        int32_t RemoveTime() const;
+
+        News::ItemQueue<News::ItemHistoryStart> Recent;
+        News::ItemQueue<News::MaxItemsArchive> Archived;
+    };
+
+    void InitQueue();
+
+    void UpdateCurrentItem();
+    void CloseCurrentItem();
+
+    std::optional<CoordsXYZ> GetSubjectLocation(News::ItemType type, int32_t subject);
+
+    News::Item* AddItemToQueue(News::ItemType type, rct_string_id string_id, uint32_t assoc, const Formatter& formatter);
+    News::Item* AddItemToQueue(News::ItemType type, const utf8* text, uint32_t assoc);
+
+    bool CheckIfItemRequiresAssoc(News::ItemType type);
+
+    void OpenSubject(News::ItemType type, int32_t subject);
+
+    void DisableNewsItems(News::ItemType type, uint32_t assoc);
+
+    News::Item* GetItem(int32_t index);
+
+    bool IsQueueEmpty();
+
+    bool IsValidIndex(int32_t index);
+
+    void AddItemToQueue(News::Item* newNewsItem);
+    void RemoveItem(int32_t index);
+}
+
+extern News::ItemQueues gNewsItems;
+# 29 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/ObjectManager.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/ObjectManager.h"
+       
+
+
+
+
+
+
+struct IObjectRepository;
+class Object;
+class ObjectList;
+struct ObjectRepositoryItem;
+
+struct IObjectManager
+{
+    virtual ~IObjectManager()
+    {
+    }
+
+    virtual Object* GetLoadedObject(size_t index) = 0;
+    virtual Object* GetLoadedObject(ObjectType objectType, size_t index) = 0;
+    virtual Object* GetLoadedObject(const ObjectEntryDescriptor& entry) = 0;
+    virtual ObjectEntryIndex GetLoadedObjectEntryIndex(const Object* object) = 0;
+    virtual ObjectList GetLoadedObjects() = 0;
+
+    virtual Object* LoadObject(std::string_view identifier) = 0;
+    virtual Object* LoadObject(const rct_object_entry* entry) = 0;
+    virtual void LoadObjects(const ObjectList& entries) = 0;
+    virtual void UnloadObjects(const std::vector<rct_object_entry>& entries) = 0;
+    virtual void UnloadAll() = 0;
+
+    virtual void ResetObjects() = 0;
+
+    virtual std::vector<const ObjectRepositoryItem*> GetPackableObjects() = 0;
+    virtual const std::vector<ObjectEntryIndex>& GetAllRideEntries(uint8_t rideType) = 0;
+};
+
+std::unique_ptr<IObjectManager> CreateObjectManager(IObjectRepository& objectRepository);
+
+Object* object_manager_get_loaded_object_by_index(size_t index);
+Object* object_manager_get_loaded_object(const ObjectEntryDescriptor& entry);
+ObjectEntryIndex object_manager_get_loaded_object_entry_index(const Object* loadedObject);
+ObjectEntryIndex object_manager_get_loaded_object_entry_index(const ObjectEntryDescriptor& entry);
+Object* object_manager_load_object(const rct_object_entry* entry);
+void object_manager_unload_objects(const std::vector<rct_object_entry>& entries);
+void object_manager_unload_all_objects();
+rct_string_id object_manager_get_source_game_string(const ObjectSourceGame sourceGame);
+# 31 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/object/ObjectRepository.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/object/ObjectRepository.h"
+       
+# 19 "/home/ted/dev/openrct2/src/openrct2/object/ObjectRepository.h"
+namespace OpenRCT2
+{
+    struct IStream;
+}
+
+class Object;
+namespace OpenRCT2
+{
+    struct IPlatformEnvironment;
+}
+
+namespace OpenRCT2::Localisation
+{
+    class LocalisationService;
+}
+
+struct rct_drawpixelinfo;
+
+struct ObjectRepositoryItem
+{
+    size_t Id;
+    std::string Identifier;
+    rct_object_entry ObjectEntry;
+    std::string Path;
+    std::string Name;
+    std::vector<std::string> Authors;
+    std::vector<ObjectSourceGame> Sources;
+    Object* LoadedObject{};
+    struct
+    {
+        uint8_t RideFlags;
+        uint8_t RideCategory[2];
+        uint8_t RideType[3];
+    } RideInfo;
+    struct
+    {
+        std::vector<ObjectEntryDescriptor> Entries;
+    } SceneryGroupInfo;
+
+    ObjectSourceGame GetFirstSourceGame() const
+    {
+        if (Sources.empty())
+            return ObjectSourceGame::Custom;
+        else
+            return static_cast<ObjectSourceGame>(Sources[0]);
+    }
+};
+
+struct IObjectRepository
+{
+    virtual ~IObjectRepository() = default;
+
+    virtual void LoadOrConstruct(int32_t language) = 0;
+    virtual void Construct(int32_t language) = 0;
+    virtual size_t GetNumObjects() const = 0;
+    virtual const ObjectRepositoryItem* GetObjects() const = 0;
+    virtual const ObjectRepositoryItem* FindObjectLegacy(std::string_view legacyIdentifier) const = 0;
+    virtual const ObjectRepositoryItem* FindObject(std::string_view identifier) const = 0;
+    virtual const ObjectRepositoryItem* FindObject(const rct_object_entry* objectEntry) const = 0;
+    virtual const ObjectRepositoryItem* FindObject(const ObjectEntryDescriptor& oed) const = 0;
+
+    virtual std::unique_ptr<Object> LoadObject(const ObjectRepositoryItem* ori) = 0;
+    virtual void RegisterLoadedObject(const ObjectRepositoryItem* ori, Object* object) = 0;
+    virtual void UnregisterLoadedObject(const ObjectRepositoryItem* ori, Object* object) = 0;
+
+    virtual void AddObject(const rct_object_entry* objectEntry, const void* data, size_t dataSize) = 0;
+    virtual void AddObjectFromFile(std::string_view objectName, const void* data, size_t dataSize) = 0;
+
+    virtual void ExportPackedObject(OpenRCT2::IStream* stream) = 0;
+    virtual void WritePackedObjects(OpenRCT2::IStream* stream, std::vector<const ObjectRepositoryItem*>& objects) = 0;
+};
+
+std::unique_ptr<IObjectRepository> CreateObjectRepository(const std::shared_ptr<OpenRCT2::IPlatformEnvironment>& env);
+
+bool IsObjectCustom(const ObjectRepositoryItem* object);
+
+size_t object_repository_get_items_count();
+const ObjectRepositoryItem* object_repository_get_items();
+const ObjectRepositoryItem* object_repository_find_object_by_entry(const rct_object_entry* entry);
+const ObjectRepositoryItem* object_repository_find_object_by_name(const char* name);
+std::unique_ptr<Object> object_repository_load_object(const rct_object_entry* objectEntry);
+# 32 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/peep/Staff.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/peep/Staff.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/peep/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/peep/Staff.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/peep/Peep.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/peep/Staff.h" 2
+
+
+
+
+
+
+enum class StaffMode : uint8_t
+{
+    None,
+    Walk,
+    Patrol = 3
+};
+
+enum STAFF_ORDERS
+{
+    STAFF_ORDERS_SWEEPING = (1 << 0),
+    STAFF_ORDERS_WATER_FLOWERS = (1 << 1),
+    STAFF_ORDERS_EMPTY_BINS = (1 << 2),
+    STAFF_ORDERS_MOWING = (1 << 3),
+    STAFF_ORDERS_INSPECT_RIDES = (1 << 0),
+    STAFF_ORDERS_FIX_RIDES = (1 << 1)
+};
+
+enum class EntertainerCostume : uint8_t
+{
+    Panda,
+    Tiger,
+    Elephant,
+    Roman,
+    Gorilla,
+    Snowman,
+    Knight,
+    Astronaut,
+    Bandit,
+    Sheriff,
+    Pirate,
+
+    Count
+};
+
+extern const rct_string_id StaffCostumeNames[static_cast<uint8_t>(EntertainerCostume::Count)];
+
+extern uint32_t gStaffPatrolAreas[(200 + static_cast<uint8_t>(StaffType::Count)) * 128];
+extern StaffMode gStaffModes[200 + static_cast<uint8_t>(StaffType::Count)];
+extern uint16_t gStaffDrawPatrolAreas;
+extern colour_t gStaffHandymanColour;
+extern colour_t gStaffMechanicColour;
+extern colour_t gStaffSecurityColour;
+
+void staff_reset_modes();
+void staff_set_name(uint16_t spriteIndex, const char* name);
+bool staff_hire_new_member(StaffType staffType, EntertainerCostume entertainerType);
+void staff_update_greyed_patrol_areas();
+bool staff_is_patrol_area_set_for_type(StaffType type, const CoordsXY& coords);
+void staff_set_patrol_area(int32_t staffIndex, const CoordsXY& coords, bool value);
+void staff_toggle_patrol_area(int32_t staffIndex, const CoordsXY& coords);
+colour_t staff_get_colour(StaffType staffType);
+bool staff_set_colour(StaffType staffType, colour_t value);
+uint32_t staff_get_available_entertainer_costumes();
+int32_t staff_get_available_entertainer_costume_list(EntertainerCostume* costumeList);
+
+money32 GetStaffWage(StaffType type);
+PeepSpriteType EntertainerCostumeToSprite(EntertainerCostume entertainerType);
+# 33 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/ride/Vehicle.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/ride/Vehicle.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/ride/../audio/audio.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/ride/../audio/audio.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/ride/../audio/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/ride/../audio/audio.h" 2
+
+
+
+
+struct CoordsXYZ;
+
+namespace OpenRCT2::Audio
+{
+    constexpr size_t MaxDeviceNameSize = 256;
+    constexpr size_t MaxVehicleSounds = 14;
+    constexpr size_t MaxDefaultMusic = 46;
+    constexpr uint16_t SoundIdNull = 0xFFFF;
+
+
+
+    enum class SoundId : uint8_t;
+
+    struct Sound
+    {
+        SoundId Id;
+        int16_t Volume;
+        int16_t Pan;
+        uint16_t Frequency;
+        void* Channel;
+    };
+
+    struct VehicleSound
+    {
+        uint16_t id;
+        int16_t volume;
+        Sound TrackSound;
+        Sound OtherSound;
+    };
+
+    struct VehicleSoundParams
+    {
+        uint16_t id;
+        int16_t pan_x;
+        int16_t pan_y;
+        uint16_t frequency;
+        int16_t volume;
+        uint16_t priority;
+    };
+
+    enum class SoundId : uint8_t
+    {
+        LiftClassic,
+        TrackFrictionClassicWood,
+        FrictionClassic,
+        Scream1,
+        Click1,
+        Click2,
+        PlaceItem,
+        Scream2,
+        Scream3,
+        Scream4,
+        Scream5,
+        Scream6,
+        LiftFrictionWheels,
+        Purchase,
+        Crash,
+        LayingOutWater,
+        Water1,
+        Water2,
+        TrainWhistle,
+        TrainDeparting,
+        WaterSplash,
+        GoKartEngine,
+        RideLaunch1,
+        RideLaunch2,
+        Cough1,
+        Cough2,
+        Cough3,
+        Cough4,
+        Rain,
+        Thunder1,
+        Thunder2,
+        TrackFrictionTrain,
+        TrackFrictionWater,
+        BalloonPop,
+        MechanicFix,
+        Scream7,
+        ToiletFlush,
+        Click3,
+        Quack,
+        NewsItem,
+        WindowOpen,
+        Laugh1,
+        Laugh2,
+        Laugh3,
+        Applause,
+        HauntedHouseScare,
+        HauntedHouseScream1,
+        HauntedHouseScream2,
+        BlockBrakeClose,
+        BlockBrakeRelease,
+        Error,
+        BrakeRelease,
+        LiftArrow,
+        LiftWood,
+        TrackFrictionWood,
+        LiftWildMouse,
+        LiftBM,
+        TrackFrictionBM,
+        Scream8,
+        Tram,
+        DoorOpen,
+        DoorClose,
+        Portcullis,
+        NoScream = 254,
+        Null = 255
+    };
+
+    constexpr uint8_t RCT2SoundCount = static_cast<uint32_t>(SoundId::Portcullis) + 1;
+
+    extern bool gGameSoundsOff;
+    extern int32_t gVolumeAdjustZoom;
+
+    extern void* gTitleMusicChannel;
+    extern void* gWeatherSoundChannel;
+
+    extern VehicleSound gVehicleSoundList[MaxVehicleSounds];
+
+
+
+
+    bool IsAvailable();
+
+
+
+
+    int32_t GetDeviceCount();
+
+
+
+
+    const std::string& GetDeviceName(int32_t index);
+
+
+
+
+    int32_t GetCurrentDeviceIndex();
+
+
+
+
+
+    void Close();
+
+
+
+
+    void Init();
+
+
+
+
+
+    void InitRideSoundsAndInfo();
+
+
+
+
+
+    void InitRideSounds(int32_t device);
+
+
+
+
+
+    void Pause();
+# 192 "/home/ted/dev/openrct2/src/openrct2/ride/../audio/audio.h"
+    void Play(SoundId soundId, int32_t volume, int32_t pan);
+# 201 "/home/ted/dev/openrct2/src/openrct2/ride/../audio/audio.h"
+    void Play3D(SoundId soundId, const CoordsXYZ& loc);
+
+
+
+
+    void PopulateDevices();
+
+
+
+
+
+    void PlayTitleMusic();
+
+
+
+
+    void StopWeatherSound();
+
+
+
+
+
+    void StopTitleMusic();
+
+
+
+
+
+    void StopVehicleSounds();
+
+
+
+
+
+    void ToggleAllSounds();
+
+
+
+
+
+    void Resume();
+
+    void StopAll();
+
+}
+# 14 "/home/ted/dev/openrct2/src/openrct2/ride/Vehicle.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/ride/../common.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/ride/Vehicle.h" 2
+
+
+
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/ride/VehicleSubpositionData.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/ride/VehicleSubpositionData.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/ride/Track.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/ride/Track.h"
+       
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/ride/Ride.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/ride/Track.h" 2
+
+constexpr const uint32_t RideConstructionSpecialPieceSelected = 0x10000;
+
+constexpr const int32_t BLOCK_BRAKE_BASE_SPEED = 0x20364;
+
+using track_type_t = uint16_t;
+using roll_type_t = uint8_t;
+using pitch_type_t = uint8_t;
+
+struct rct_trackdefinition
+{
+    track_type_t type;
+    pitch_type_t vangle_end;
+    pitch_type_t vangle_start;
+    roll_type_t bank_end;
+    roll_type_t bank_start;
+    int8_t preview_z_offset;
+};
+
+struct PitchAndRoll
+{
+    pitch_type_t Pitch;
+    roll_type_t Roll;
+};
+constexpr bool operator==(const PitchAndRoll& vb1, const PitchAndRoll& vb2)
+{
+    return vb1.Pitch == vb2.Pitch && vb1.Roll == vb2.Roll;
+}
+constexpr bool operator!=(const PitchAndRoll& vb1, const PitchAndRoll& vb2)
+{
+    return !(vb1 == vb2);
+}
+
+
+struct rct_preview_track
+{
+    uint8_t index;
+    int16_t x;
+    int16_t y;
+    int16_t z;
+    uint8_t var_07;
+    QuarterTile var_08;
+    uint8_t flags;
+};
+
+
+struct rct_track_coordinates
+{
+    int8_t rotation_begin;
+    int8_t rotation_end;
+    int16_t z_begin;
+    int16_t z_end;
+    int16_t x;
+    int16_t y;
+};
+
+enum
+{
+    RCT_PREVIEW_TRACK_FLAG_0 = (1 << 0),
+    RCT_PREVIEW_TRACK_FLAG_1 = (1 << 1),
+    RCT_PREVIEW_TRACK_FLAG_IS_VERTICAL = (1 << 2),
+};
+
+enum
+{
+    TRACK_ELEMENT_FLAG_TERMINAL_STATION = 1 << 3,
+    TD6_TRACK_ELEMENT_FLAG_INVERTED = 1 << 6,
+};
+
+enum
+{
+    TRACK_ELEMENT_FLAGS2_CHAIN_LIFT = 1 << 0,
+    TRACK_ELEMENT_FLAGS2_INVERTED = 1 << 1,
+
+    TRACK_ELEMENT_FLAGS2_CABLE_LIFT = 1 << 2,
+    TRACK_ELEMENT_FLAGS2_HIGHLIGHT = 1 << 3,
+    TRACK_ELEMENT_FLAGS2_HAS_GREEN_LIGHT = 1 << 4,
+    TRACK_ELEMENT_FLAGS2_BLOCK_BRAKE_CLOSED = 1 << 5,
+    TRACK_ELEMENT_FLAGS2_INDESTRUCTIBLE_TRACK_PIECE = 1 << 6,
+};
+
+enum
+{
+    TRACK_ELEMENT_COLOUR_SCHEME_MASK = 0b00000011,
+
+    TRACK_ELEMENT_COLOUR_DOOR_A_MASK = 0b00011100,
+    TRACK_ELEMENT_COLOUR_DOOR_B_MASK = 0b11100000,
+    TRACK_ELEMENT_COLOUR_SEAT_ROTATION_MASK = 0b11110000,
+};
+
+
+constexpr uint16_t const MAX_TRACK_HEIGHT = 254 * COORDS_Z_STEP;
+constexpr uint8_t const DEFAULT_SEAT_ROTATION = 4;
+
+enum
+{
+    TRACK_NONE = 0,
+
+    TRACK_FLAT = 0,
+    TRACK_STRAIGHT,
+    TRACK_STATION_END,
+    TRACK_LIFT_HILL,
+    TRACK_LIFT_HILL_STEEP,
+    TRACK_LIFT_HILL_CURVE,
+    TRACK_FLAT_ROLL_BANKING,
+    TRACK_VERTICAL_LOOP,
+    TRACK_SLOPE,
+    TRACK_SLOPE_STEEP,
+    TRACK_SLOPE_LONG,
+    TRACK_SLOPE_CURVE,
+    TRACK_SLOPE_CURVE_STEEP,
+    TRACK_S_BEND,
+    TRACK_CURVE_VERY_SMALL,
+    TRACK_CURVE_SMALL,
+    TRACK_CURVE,
+    TRACK_TWIST,
+    TRACK_HALF_LOOP,
+    TRACK_CORKSCREW,
+    TRACK_TOWER_BASE,
+    TRACK_HELIX_SMALL,
+    TRACK_HELIX_LARGE,
+    TRACK_HELIX_LARGE_UNBANKED,
+    TRACK_BRAKES,
+    TRACK_25,
+    TRACK_ON_RIDE_PHOTO,
+    TRACK_WATER_SPLASH,
+    TRACK_SLOPE_VERTICAL,
+    TRACK_BARREL_ROLL,
+    TRACK_POWERED_LIFT,
+    TRACK_HALF_LOOP_LARGE,
+    TRACK_SLOPE_CURVE_BANKED,
+    TRACK_LOG_FLUME_REVERSER,
+    TRACK_HEARTLINE_ROLL,
+    TRACK_REVERSER,
+    TRACK_REVERSE_FREEFALL,
+    TRACK_SLOPE_TO_FLAT,
+    TRACK_BLOCK_BRAKES,
+    TRACK_SLOPE_ROLL_BANKING,
+    TRACK_SLOPE_STEEP_LONG,
+    TRACK_CURVE_VERTICAL,
+    TRACK_42,
+    TRACK_LIFT_HILL_CABLE,
+    TRACK_LIFT_HILL_CURVED,
+    TRACK_QUARTER_LOOP,
+    TRACK_SPINNING_TUNNEL,
+    TRACK_BOOSTER,
+    TRACK_INLINE_TWIST_UNINVERTED,
+    TRACK_INLINE_TWIST_INVERTED,
+    TRACK_QUARTER_LOOP_UNINVERTED,
+    TRACK_QUARTER_LOOP_INVERTED,
+    TRACK_RAPIDS,
+    TRACK_HALF_LOOP_UNINVERTED,
+    TRACK_HALF_LOOP_INVERTED,
+
+    TRACK_WATERFALL,
+    TRACK_WHIRLPOOL,
+    TRACK_BRAKE_FOR_DROP,
+    TRACK_CORKSCREW_UNINVERTED,
+    TRACK_CORKSCREW_INVERTED,
+    TRACK_HEARTLINE_TRANSFER,
+    TRACK_MINI_GOLF_HOLE,
+    TRACK_ROTATION_CONTROL_TOGGLE,
+
+    TRACK_GROUP_COUNT,
+};
+
+enum
+{
+    TRACK_CURVE_LEFT_VERY_SMALL = 5,
+    TRACK_CURVE_LEFT_SMALL = 3,
+    TRACK_CURVE_LEFT = 1,
+    TRACK_CURVE_LEFT_LARGE = 7,
+    TRACK_CURVE_NONE = 0,
+    TRACK_CURVE_RIGHT_LARGE = 8,
+    TRACK_CURVE_RIGHT = 2,
+    TRACK_CURVE_RIGHT_SMALL = 4,
+    TRACK_CURVE_RIGHT_VERY_SMALL = 6
+};
+
+enum
+{
+    TRACK_SLOPE_NONE = 0,
+    TRACK_SLOPE_UP_25 = 2,
+    TRACK_SLOPE_UP_60 = 4,
+    TRACK_SLOPE_DOWN_25 = 6,
+    TRACK_SLOPE_DOWN_60 = 8,
+    TRACK_SLOPE_UP_90 = 10,
+    TRACK_SLOPE_DOWN_90 = 18,
+
+    TRACK_VANGLE_TOWER = 10,
+    TRACK_VANGLE_REVERSE_FREEFALL = 10
+};
+
+enum
+{
+    TRACK_BANK_NONE = 0,
+    TRACK_BANK_LEFT = 2,
+    TRACK_BANK_RIGHT = 4,
+    TRACK_BANK_UPSIDE_DOWN = 15,
+};
+
+enum
+{
+    TRACK_ELEM_FLAG_ONLY_UNDERWATER = (1 << 0),
+    TRACK_ELEM_FLAG_TURN_LEFT = (1 << 1),
+    TRACK_ELEM_FLAG_TURN_RIGHT = (1 << 2),
+    TRACK_ELEM_FLAG_TURN_BANKED = (1 << 3),
+    TRACK_ELEM_FLAG_TURN_SLOPED = (1 << 4),
+    TRACK_ELEM_FLAG_DOWN = (1 << 5),
+    TRACK_ELEM_FLAG_UP = (1 << 6),
+    TRACK_ELEM_FLAG_NORMAL_TO_INVERSION = (1 << 7),
+    TRACK_ELEM_FLAG_IS_GOLF_HOLE = (1 << 7),
+    TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT = (1 << 8),
+    TRACK_ELEM_FLAG_ONLY_ABOVE_GROUND = (1 << 9),
+    TRACK_ELEM_FLAG_IS_STEEP_UP = (1 << 10),
+
+    TRACK_ELEM_FLAG_HELIX = (1 << 11),
+    TRACK_ELEM_FLAG_ALLOW_LIFT_HILL = (1 << 12),
+    TRACK_ELEM_FLAG_CURVE_ALLOWS_LIFT = (1 << 13),
+    TRACK_ELEM_FLAG_INVERSION_TO_NORMAL = (1 << 14),
+    TRACK_ELEM_FLAG_BANKED = (1 << 15),
+};
+
+namespace TrackElemType
+{
+    constexpr track_type_t Flat = 0;
+    constexpr track_type_t EndStation = 1;
+    constexpr track_type_t BeginStation = 2;
+    constexpr track_type_t MiddleStation = 3;
+    constexpr track_type_t Up25 = 4;
+    constexpr track_type_t Up60 = 5;
+    constexpr track_type_t FlatToUp25 = 6;
+    constexpr track_type_t Up25ToUp60 = 7;
+    constexpr track_type_t Up60ToUp25 = 8;
+    constexpr track_type_t Up25ToFlat = 9;
+    constexpr track_type_t Down25 = 10;
+    constexpr track_type_t Down60 = 11;
+    constexpr track_type_t FlatToDown25 = 12;
+    constexpr track_type_t Down25ToDown60 = 13;
+    constexpr track_type_t Down60ToDown25 = 14;
+    constexpr track_type_t Down25ToFlat = 15;
+    constexpr track_type_t LeftQuarterTurn5Tiles = 16;
+    constexpr track_type_t RightQuarterTurn5Tiles = 17;
+    constexpr track_type_t FlatToLeftBank = 18;
+    constexpr track_type_t FlatToRightBank = 19;
+    constexpr track_type_t LeftBankToFlat = 20;
+    constexpr track_type_t RightBankToFlat = 21;
+    constexpr track_type_t BankedLeftQuarterTurn5Tiles = 22;
+    constexpr track_type_t BankedRightQuarterTurn5Tiles = 23;
+    constexpr track_type_t LeftBankToUp25 = 24;
+    constexpr track_type_t RightBankToUp25 = 25;
+    constexpr track_type_t Up25ToLeftBank = 26;
+    constexpr track_type_t Up25ToRightBank = 27;
+    constexpr track_type_t LeftBankToDown25 = 28;
+    constexpr track_type_t RightBankToDown25 = 29;
+    constexpr track_type_t Down25ToLeftBank = 30;
+    constexpr track_type_t Down25ToRightBank = 31;
+    constexpr track_type_t LeftBank = 32;
+    constexpr track_type_t RightBank = 33;
+    constexpr track_type_t LeftQuarterTurn5TilesUp25 = 34;
+    constexpr track_type_t RightQuarterTurn5TilesUp25 = 35;
+    constexpr track_type_t LeftQuarterTurn5TilesDown25 = 36;
+    constexpr track_type_t RightQuarterTurn5TilesDown25 = 37;
+    constexpr track_type_t SBendLeft = 38;
+    constexpr track_type_t SBendRight = 39;
+    constexpr track_type_t LeftVerticalLoop = 40;
+    constexpr track_type_t RightVerticalLoop = 41;
+    constexpr track_type_t LeftQuarterTurn3Tiles = 42;
+    constexpr track_type_t RightQuarterTurn3Tiles = 43;
+    constexpr track_type_t LeftBankedQuarterTurn3Tiles = 44;
+    constexpr track_type_t RightBankedQuarterTurn3Tiles = 45;
+    constexpr track_type_t LeftQuarterTurn3TilesUp25 = 46;
+    constexpr track_type_t RightQuarterTurn3TilesUp25 = 47;
+    constexpr track_type_t LeftQuarterTurn3TilesDown25 = 48;
+    constexpr track_type_t RightQuarterTurn3TilesDown25 = 49;
+    constexpr track_type_t LeftQuarterTurn1Tile = 50;
+    constexpr track_type_t RightQuarterTurn1Tile = 51;
+    constexpr track_type_t LeftTwistDownToUp = 52;
+    constexpr track_type_t RightTwistDownToUp = 53;
+    constexpr track_type_t LeftTwistUpToDown = 54;
+    constexpr track_type_t RightTwistUpToDown = 55;
+    constexpr track_type_t HalfLoopUp = 56;
+    constexpr track_type_t HalfLoopDown = 57;
+    constexpr track_type_t LeftCorkscrewUp = 58;
+    constexpr track_type_t RightCorkscrewUp = 59;
+    constexpr track_type_t LeftCorkscrewDown = 60;
+    constexpr track_type_t RightCorkscrewDown = 61;
+    constexpr track_type_t FlatToUp60 = 62;
+    constexpr track_type_t Up60ToFlat = 63;
+    constexpr track_type_t FlatToDown60 = 64;
+    constexpr track_type_t Down60ToFlat = 65;
+    constexpr track_type_t TowerBase = 66;
+    constexpr track_type_t TowerSection = 67;
+    constexpr track_type_t FlatCovered = 68;
+    constexpr track_type_t Up25Covered = 69;
+    constexpr track_type_t Up60Covered = 70;
+    constexpr track_type_t FlatToUp25Covered = 71;
+    constexpr track_type_t Up25ToUp60Covered = 72;
+    constexpr track_type_t Up60ToUp25Covered = 73;
+    constexpr track_type_t Up25ToFlatCovered = 74;
+    constexpr track_type_t Down25Covered = 75;
+    constexpr track_type_t Down60Covered = 76;
+    constexpr track_type_t FlatToDown25Covered = 77;
+    constexpr track_type_t Down25ToDown60Covered = 78;
+    constexpr track_type_t Down60ToDown25Covered = 79;
+    constexpr track_type_t Down25ToFlatCovered = 80;
+    constexpr track_type_t LeftQuarterTurn5TilesCovered = 81;
+    constexpr track_type_t RightQuarterTurn5TilesCovered = 82;
+    constexpr track_type_t SBendLeftCovered = 83;
+    constexpr track_type_t SBendRightCovered = 84;
+    constexpr track_type_t LeftQuarterTurn3TilesCovered = 85;
+    constexpr track_type_t RightQuarterTurn3TilesCovered = 86;
+    constexpr track_type_t LeftHalfBankedHelixUpSmall = 87;
+    constexpr track_type_t RightHalfBankedHelixUpSmall = 88;
+    constexpr track_type_t LeftHalfBankedHelixDownSmall = 89;
+    constexpr track_type_t RightHalfBankedHelixDownSmall = 90;
+    constexpr track_type_t LeftHalfBankedHelixUpLarge = 91;
+    constexpr track_type_t RightHalfBankedHelixUpLarge = 92;
+    constexpr track_type_t LeftHalfBankedHelixDownLarge = 93;
+    constexpr track_type_t RightHalfBankedHelixDownLarge = 94;
+    constexpr track_type_t LeftQuarterTurn1TileUp60 = 95;
+    constexpr track_type_t RightQuarterTurn1TileUp60 = 96;
+    constexpr track_type_t LeftQuarterTurn1TileDown60 = 97;
+    constexpr track_type_t RightQuarterTurn1TileDown60 = 98;
+    constexpr track_type_t Brakes = 99;
+    constexpr track_type_t RotationControlToggleAlias = 100;
+    constexpr track_type_t Booster = 100;
+    constexpr track_type_t Maze = 101;
+
+    constexpr track_type_t InvertedUp90ToFlatQuarterLoopAlias = 101;
+    constexpr track_type_t LeftQuarterBankedHelixLargeUp = 102;
+    constexpr track_type_t RightQuarterBankedHelixLargeUp = 103;
+    constexpr track_type_t LeftQuarterBankedHelixLargeDown = 104;
+    constexpr track_type_t RightQuarterBankedHelixLargeDown = 105;
+    constexpr track_type_t LeftQuarterHelixLargeUp = 106;
+    constexpr track_type_t RightQuarterHelixLargeUp = 107;
+    constexpr track_type_t LeftQuarterHelixLargeDown = 108;
+    constexpr track_type_t RightQuarterHelixLargeDown = 109;
+    constexpr track_type_t Up25LeftBanked = 110;
+    constexpr track_type_t Up25RightBanked = 111;
+    constexpr track_type_t Waterfall = 112;
+    constexpr track_type_t Rapids = 113;
+    constexpr track_type_t OnRidePhoto = 114;
+    constexpr track_type_t Down25LeftBanked = 115;
+    constexpr track_type_t Down25RightBanked = 116;
+    constexpr track_type_t Watersplash = 117;
+    constexpr track_type_t FlatToUp60LongBase = 118;
+    constexpr track_type_t Up60ToFlatLongBase = 119;
+    constexpr track_type_t Whirlpool = 120;
+    constexpr track_type_t Down60ToFlatLongBase = 121;
+    constexpr track_type_t FlatToDown60LongBase = 122;
+    constexpr track_type_t CableLiftHill = 123;
+    constexpr track_type_t ReverseFreefallSlope = 124;
+    constexpr track_type_t ReverseFreefallVertical = 125;
+    constexpr track_type_t Up90 = 126;
+    constexpr track_type_t Down90 = 127;
+    constexpr track_type_t Up60ToUp90 = 128;
+    constexpr track_type_t Down90ToDown60 = 129;
+    constexpr track_type_t Up90ToUp60 = 130;
+    constexpr track_type_t Down60ToDown90 = 131;
+    constexpr track_type_t BrakeForDrop = 132;
+    constexpr track_type_t LeftEighthToDiag = 133;
+    constexpr track_type_t RightEighthToDiag = 134;
+    constexpr track_type_t LeftEighthToOrthogonal = 135;
+    constexpr track_type_t RightEighthToOrthogonal = 136;
+    constexpr track_type_t LeftEighthBankToDiag = 137;
+    constexpr track_type_t RightEighthBankToDiag = 138;
+    constexpr track_type_t LeftEighthBankToOrthogonal = 139;
+    constexpr track_type_t RightEighthBankToOrthogonal = 140;
+    constexpr track_type_t DiagFlat = 141;
+    constexpr track_type_t DiagUp25 = 142;
+    constexpr track_type_t DiagUp60 = 143;
+    constexpr track_type_t DiagFlatToUp25 = 144;
+    constexpr track_type_t DiagUp25ToUp60 = 145;
+    constexpr track_type_t DiagUp60ToUp25 = 146;
+    constexpr track_type_t DiagUp25ToFlat = 147;
+    constexpr track_type_t DiagDown25 = 148;
+    constexpr track_type_t DiagDown60 = 149;
+    constexpr track_type_t DiagFlatToDown25 = 150;
+    constexpr track_type_t DiagDown25ToDown60 = 151;
+    constexpr track_type_t DiagDown60ToDown25 = 152;
+    constexpr track_type_t DiagDown25ToFlat = 153;
+    constexpr track_type_t DiagFlatToUp60 = 154;
+    constexpr track_type_t DiagUp60ToFlat = 155;
+    constexpr track_type_t DiagFlatToDown60 = 156;
+    constexpr track_type_t DiagDown60ToFlat = 157;
+    constexpr track_type_t DiagFlatToLeftBank = 158;
+    constexpr track_type_t DiagFlatToRightBank = 159;
+    constexpr track_type_t DiagLeftBankToFlat = 160;
+    constexpr track_type_t DiagRightBankToFlat = 161;
+    constexpr track_type_t DiagLeftBankToUp25 = 162;
+    constexpr track_type_t DiagRightBankToUp25 = 163;
+    constexpr track_type_t DiagUp25ToLeftBank = 164;
+    constexpr track_type_t DiagUp25ToRightBank = 165;
+    constexpr track_type_t DiagLeftBankToDown25 = 166;
+    constexpr track_type_t DiagRightBankToDown25 = 167;
+    constexpr track_type_t DiagDown25ToLeftBank = 168;
+    constexpr track_type_t DiagDown25ToRightBank = 169;
+    constexpr track_type_t DiagLeftBank = 170;
+    constexpr track_type_t DiagRightBank = 171;
+    constexpr track_type_t LogFlumeReverser = 172;
+    constexpr track_type_t SpinningTunnel = 173;
+    constexpr track_type_t LeftBarrelRollUpToDown = 174;
+    constexpr track_type_t RightBarrelRollUpToDown = 175;
+    constexpr track_type_t LeftBarrelRollDownToUp = 176;
+    constexpr track_type_t RightBarrelRollDownToUp = 177;
+    constexpr track_type_t LeftBankToLeftQuarterTurn3TilesUp25 = 178;
+    constexpr track_type_t RightBankToRightQuarterTurn3TilesUp25 = 179;
+    constexpr track_type_t LeftQuarterTurn3TilesDown25ToLeftBank = 180;
+    constexpr track_type_t RightQuarterTurn3TilesDown25ToRightBank = 181;
+    constexpr track_type_t PoweredLift = 182;
+    constexpr track_type_t LeftLargeHalfLoopUp = 183;
+    constexpr track_type_t RightLargeHalfLoopUp = 184;
+    constexpr track_type_t RightLargeHalfLoopDown = 185;
+    constexpr track_type_t LeftLargeHalfLoopDown = 186;
+    constexpr track_type_t LeftFlyerTwistUp = 187;
+    constexpr track_type_t RightFlyerTwistUp = 188;
+    constexpr track_type_t LeftFlyerTwistDown = 189;
+    constexpr track_type_t RightFlyerTwistDown = 190;
+    constexpr track_type_t FlyerHalfLoopUp = 191;
+    constexpr track_type_t FlyerHalfLoopDown = 192;
+    constexpr track_type_t LeftFlyerCorkscrewUp = 193;
+    constexpr track_type_t RightFlyerCorkscrewUp = 194;
+    constexpr track_type_t LeftFlyerCorkscrewDown = 195;
+    constexpr track_type_t RightFlyerCorkscrewDown = 196;
+    constexpr track_type_t HeartLineTransferUp = 197;
+    constexpr track_type_t HeartLineTransferDown = 198;
+    constexpr track_type_t LeftHeartLineRoll = 199;
+    constexpr track_type_t RightHeartLineRoll = 200;
+    constexpr track_type_t MinigolfHoleA = 201;
+    constexpr track_type_t MinigolfHoleB = 202;
+    constexpr track_type_t MinigolfHoleC = 203;
+    constexpr track_type_t MinigolfHoleD = 204;
+    constexpr track_type_t MinigolfHoleE = 205;
+    constexpr track_type_t MultiDimInvertedFlatToDown90QuarterLoop = 206;
+    constexpr track_type_t Up90ToInvertedFlatQuarterLoop = 207;
+    constexpr track_type_t InvertedFlatToDown90QuarterLoop = 208;
+    constexpr track_type_t LeftCurvedLiftHill = 209;
+    constexpr track_type_t RightCurvedLiftHill = 210;
+    constexpr track_type_t LeftReverser = 211;
+    constexpr track_type_t RightReverser = 212;
+    constexpr track_type_t AirThrustTopCap = 213;
+    constexpr track_type_t AirThrustVerticalDown = 214;
+    constexpr track_type_t AirThrustVerticalDownToLevel = 215;
+    constexpr track_type_t BlockBrakes = 216;
+    constexpr track_type_t LeftBankedQuarterTurn3TileUp25 = 217;
+    constexpr track_type_t RightBankedQuarterTurn3TileUp25 = 218;
+    constexpr track_type_t LeftBankedQuarterTurn3TileDown25 = 219;
+    constexpr track_type_t RightBankedQuarterTurn3TileDown25 = 220;
+    constexpr track_type_t LeftBankedQuarterTurn5TileUp25 = 221;
+    constexpr track_type_t RightBankedQuarterTurn5TileUp25 = 222;
+    constexpr track_type_t LeftBankedQuarterTurn5TileDown25 = 223;
+    constexpr track_type_t RightBankedQuarterTurn5TileDown25 = 224;
+    constexpr track_type_t Up25ToLeftBankedUp25 = 225;
+    constexpr track_type_t Up25ToRightBankedUp25 = 226;
+    constexpr track_type_t LeftBankedUp25ToUp25 = 227;
+    constexpr track_type_t RightBankedUp25ToUp25 = 228;
+    constexpr track_type_t Down25ToLeftBankedDown25 = 229;
+    constexpr track_type_t Down25ToRightBankedDown25 = 230;
+    constexpr track_type_t LeftBankedDown25ToDown25 = 231;
+    constexpr track_type_t RightBankedDown25ToDown25 = 232;
+    constexpr track_type_t LeftBankedFlatToLeftBankedUp25 = 233;
+    constexpr track_type_t RightBankedFlatToRightBankedUp25 = 234;
+    constexpr track_type_t LeftBankedUp25ToLeftBankedFlat = 235;
+    constexpr track_type_t RightBankedUp25ToRightBankedFlat = 236;
+    constexpr track_type_t LeftBankedFlatToLeftBankedDown25 = 237;
+    constexpr track_type_t RightBankedFlatToRightBankedDown25 = 238;
+    constexpr track_type_t LeftBankedDown25ToLeftBankedFlat = 239;
+    constexpr track_type_t RightBankedDown25ToRightBankedFlat = 240;
+    constexpr track_type_t FlatToLeftBankedUp25 = 241;
+    constexpr track_type_t FlatToRightBankedUp25 = 242;
+    constexpr track_type_t LeftBankedUp25ToFlat = 243;
+    constexpr track_type_t RightBankedUp25ToFlat = 244;
+    constexpr track_type_t FlatToLeftBankedDown25 = 245;
+    constexpr track_type_t FlatToRightBankedDown25 = 246;
+    constexpr track_type_t LeftBankedDown25ToFlat = 247;
+    constexpr track_type_t RightBankedDown25ToFlat = 248;
+    constexpr track_type_t LeftQuarterTurn1TileUp90 = 249;
+    constexpr track_type_t RightQuarterTurn1TileUp90 = 250;
+    constexpr track_type_t LeftQuarterTurn1TileDown90 = 251;
+    constexpr track_type_t RightQuarterTurn1TileDown90 = 252;
+    constexpr track_type_t MultiDimUp90ToInvertedFlatQuarterLoop = 253;
+    constexpr track_type_t MultiDimFlatToDown90QuarterLoop = 254;
+    constexpr track_type_t MultiDimInvertedUp90ToFlatQuarterLoop = 255;
+    constexpr track_type_t RotationControlToggle = 256;
+
+    constexpr track_type_t FlatTrack1x4A = 257;
+    constexpr track_type_t FlatTrack2x2 = 258;
+    constexpr track_type_t FlatTrack4x4 = 259;
+    constexpr track_type_t FlatTrack2x4 = 260;
+    constexpr track_type_t FlatTrack1x5 = 261;
+    constexpr track_type_t FlatTrack1x1A = 262;
+    constexpr track_type_t FlatTrack1x4B = 263;
+    constexpr track_type_t FlatTrack1x1B = 264;
+    constexpr track_type_t FlatTrack1x4C = 265;
+    constexpr track_type_t FlatTrack3x3 = 266;
+
+    constexpr track_type_t Count = 267;
+    constexpr track_type_t None = 65535;
+
+    constexpr track_type_t FlatTrack1x4A_Alias = 95;
+    constexpr track_type_t FlatTrack2x2_Alias = 110;
+    constexpr track_type_t FlatTrack4x4_Alias = 111;
+    constexpr track_type_t FlatTrack2x4_Alias = 115;
+    constexpr track_type_t FlatTrack1x5_Alias = 116;
+    constexpr track_type_t FlatTrack1x1A_Alias = 118;
+    constexpr track_type_t FlatTrack1x4B_Alias = 119;
+    constexpr track_type_t FlatTrack1x1B_Alias = 121;
+    constexpr track_type_t FlatTrack1x4C_Alias = 122;
+    constexpr track_type_t FlatTrack3x3_Alias = 123;
+};
+
+enum
+{
+    TRACK_SEQUENCE_FLAG_DIRECTION_0 = (1 << 0),
+    TRACK_SEQUENCE_FLAG_DIRECTION_1 = (1 << 1),
+    TRACK_SEQUENCE_FLAG_DIRECTION_2 = (1 << 2),
+    TRACK_SEQUENCE_FLAG_DIRECTION_3 = (1 << 3),
+    TRACK_SEQUENCE_FLAG_ORIGIN = (1 << 4),
+    TRACK_SEQUENCE_FLAG_CONNECTS_TO_PATH = (1 << 5),
+    TRACK_SEQUENCE_FLAG_DISALLOW_DOORS = (1 << 6),
+};
+
+enum
+{
+    GC_SET_MAZE_TRACK_BUILD = 0,
+    GC_SET_MAZE_TRACK_MOVE = 1,
+    GC_SET_MAZE_TRACK_FILL = 2,
+};
+
+struct track_circuit_iterator
+{
+    CoordsXYE last;
+    CoordsXYE current;
+    int32_t currentZ;
+    int32_t currentDirection;
+    TileElement* first;
+    bool firstIteration;
+    bool looped;
+};
+
+extern const rct_trackdefinition TrackDefinitions[TrackElemType::Count];
+
+PitchAndRoll TrackPitchAndRollStart(track_type_t trackType);
+PitchAndRoll TrackPitchAndRollEnd(track_type_t trackType);
+
+int32_t track_is_connected_by_shape(TileElement* a, TileElement* b);
+
+void track_circuit_iterator_begin(track_circuit_iterator* it, CoordsXYE first);
+bool track_circuit_iterator_previous(track_circuit_iterator* it);
+bool track_circuit_iterator_next(track_circuit_iterator* it);
+bool track_circuit_iterators_match(const track_circuit_iterator* firstIt, const track_circuit_iterator* secondIt);
+
+void track_get_back(CoordsXYE* input, CoordsXYE* output);
+void track_get_front(CoordsXYE* input, CoordsXYE* output);
+
+bool track_element_is_covered(track_type_t trackElementType);
+bool track_type_is_station(track_type_t trackType);
+
+roll_type_t track_get_actual_bank(TileElement* tileElement, roll_type_t bank);
+roll_type_t track_get_actual_bank_2(int32_t rideType, bool isInverted, roll_type_t bank);
+roll_type_t track_get_actual_bank_3(bool useInvertedSprites, TileElement* tileElement);
+
+bool track_add_station_element(CoordsXYZD loc, ride_id_t rideIndex, int32_t flags, bool fromTrackDesign);
+bool track_remove_station_element(const CoordsXYZD& loc, ride_id_t rideIndex, int32_t flags);
+
+money32 maze_set_track(
+    uint16_t x, uint16_t y, uint16_t z, uint8_t flags, bool initialPlacement, uint8_t direction, ride_id_t rideIndex,
+    uint8_t mode);
+
+bool TrackTypeHasSpeedSetting(track_type_t trackType);
+# 13 "/home/ted/dev/openrct2/src/openrct2/ride/VehicleSubpositionData.h" 2
+
+
+
+constexpr const size_t VehicleTrackSubpositionSizeDefault = TrackElemType::Count * NumOrthogonalDirections;
+
+struct rct_vehicle_info;
+
+enum class VehicleTrackSubposition : uint8_t
+{
+    Default,
+
+    ChairliftGoingOut,
+    ChairliftGoingBack,
+
+    ChairliftEndBullwheel,
+    ChairliftStartBullwheel,
+    GoKartsLeftLane,
+    GoKartsRightLane,
+    GoKartsMovingToRightLane,
+    GoKartsMovingToLeftLane,
+    MiniGolfStart9 = 9,
+    MiniGolfPathA9 = 9,
+    MiniGolfBallPathA10,
+    MiniGolfPathB11,
+    MiniGolfBallPathB12,
+    MiniGolfPathC13,
+    MiniGolfBallPathC14,
+    ReverserRCFrontBogie,
+    ReverserRCRearBogie,
+
+    Count,
+};
+
+struct rct_vehicle_info_list
+{
+    uint16_t size;
+    const rct_vehicle_info* info;
+};
+
+extern const rct_vehicle_info_list* const* const gTrackVehicleInfo[EnumValue(VehicleTrackSubposition::Count)];
+# 22 "/home/ted/dev/openrct2/src/openrct2/ride/Vehicle.h" 2
+
+
+
+
+
+using track_type_t = uint16_t;
+
+struct Ride;
+struct rct_ride_entry;
+
+struct GForces
+{
+    int32_t VerticalG{};
+    int32_t LateralG{};
+};
+
+
+struct rct_vehicle_info
+{
+    int16_t x;
+    int16_t y;
+    int16_t z;
+    uint8_t direction;
+    uint8_t vehicle_sprite_type;
+    uint8_t bank_rotation;
+};
+
+struct SoundIdVolume;
+
+constexpr const uint16_t VehicleTrackDirectionMask = 0b0000000000000011;
+constexpr const uint16_t VehicleTrackTypeMask = 0b1111111111111100;
+
+struct Vehicle : SpriteBase
+{
+    static constexpr auto cEntityType = EntityType::Vehicle;
+
+    enum class Type : uint8_t
+    {
+        Head,
+        Tail,
+    };
+
+    enum class Status
+    {
+        MovingToEndOfStation,
+        WaitingForPassengers,
+        WaitingToDepart,
+        Departing,
+        Travelling,
+        Arriving,
+        UnloadingPassengers,
+        TravellingBoat,
+        Crashing,
+        Crashed,
+        TravellingDodgems,
+        Swinging,
+        Rotating,
+        FerrisWheelRotating,
+        SimulatorOperating,
+        ShowingFilm,
+        SpaceRingsOperating,
+        TopSpinOperating,
+        HauntedHouseOperating,
+        DoingCircusShow,
+        CrookedHouseOperating,
+        WaitingForCableLift,
+        TravellingCableLift,
+        Stopping,
+        WaitingForPassengers17,
+        WaitingToStart,
+        Starting,
+        Operating1A,
+        Stopping1B,
+        UnloadingPassengers1C,
+        StoppedByBlockBrakes
+    };
+
+    Type SubType;
+    uint8_t vehicle_sprite_type;
+    uint8_t bank_rotation;
+    int32_t remaining_distance;
+    int32_t velocity;
+    int32_t acceleration;
+    ride_id_t ride;
+    uint8_t vehicle_type;
+    rct_vehicle_colour colours;
+    union
+    {
+        uint16_t track_progress;
+        struct
+        {
+            int8_t var_34;
+            uint8_t var_35;
+        };
+    };
+    uint16_t TrackTypeAndDirection;
+    CoordsXYZ TrackLocation;
+    uint16_t next_vehicle_on_train;
+
+
+    uint16_t prev_vehicle_on_ride;
+
+
+    uint16_t next_vehicle_on_ride;
+
+    uint16_t var_44;
+    uint16_t mass;
+    uint16_t update_flags;
+    uint8_t SwingSprite;
+    StationIndex current_station;
+    union
+    {
+        int16_t SwingPosition;
+        int16_t current_time;
+        struct
+        {
+            int8_t ferris_wheel_var_0;
+            int8_t ferris_wheel_var_1;
+        };
+    };
+    union
+    {
+        int16_t SwingSpeed;
+        int16_t crash_z;
+    };
+    Status status;
+    uint8_t sub_state;
+    uint16_t peep[32];
+    uint8_t peep_tshirt_colours[32];
+    uint8_t num_seats;
+    uint8_t num_peeps;
+    uint8_t next_free_seat;
+    uint8_t restraints_position;
+    union
+    {
+        int16_t spin_speed;
+        int16_t crash_x;
+    };
+    uint16_t sound2_flags;
+    uint8_t spin_sprite;
+    OpenRCT2::Audio::SoundId sound1_id;
+    uint8_t sound1_volume;
+    OpenRCT2::Audio::SoundId sound2_id;
+    uint8_t sound2_volume;
+    int8_t sound_vector_factor;
+    union
+    {
+        uint16_t var_C0;
+        int16_t crash_y;
+        uint16_t time_waiting;
+        uint16_t cable_lift_target;
+    };
+    uint8_t speed;
+    uint8_t powered_acceleration;
+    union
+    {
+        uint8_t dodgems_collision_direction;
+        uint8_t var_C4;
+    };
+    uint8_t animation_frame;
+    uint8_t pad_C6[0x2];
+    uint16_t var_C8;
+    uint16_t var_CA;
+    OpenRCT2::Audio::SoundId scream_sound_id;
+    VehicleTrackSubposition TrackSubposition;
+    union
+    {
+        uint8_t var_CE;
+        uint8_t num_laps;
+    };
+    union
+    {
+        uint8_t var_CF;
+        uint8_t brake_speed;
+    };
+    uint16_t lost_time_out;
+    int8_t vertical_drop_countdown;
+    uint8_t var_D3;
+    uint8_t mini_golf_current_animation;
+    uint8_t mini_golf_flags;
+    ObjectEntryIndex ride_subtype;
+    uint8_t colours_extended;
+    uint8_t seat_rotation;
+    uint8_t target_seat_rotation;
+    CoordsXY BoatLocation;
+
+    constexpr bool IsHead() const
+    {
+        return SubType == Vehicle::Type::Head;
+    }
+    void Update();
+    Vehicle* GetHead();
+    const Vehicle* GetHead() const;
+    Vehicle* GetCar(size_t carIndex) const;
+    void SetState(Vehicle::Status vehicleStatus, uint8_t subState = 0);
+    bool IsGhost() const;
+    void UpdateSoundParams(std::vector<OpenRCT2::Audio::VehicleSoundParams>& vehicleSoundParamsList) const;
+    bool DodgemsCarWouldCollideAt(const CoordsXY& coords, uint16_t* spriteId) const;
+    int32_t UpdateTrackMotion(int32_t* outStation);
+    int32_t CableLiftUpdateTrackMotion();
+    GForces GetGForces() const;
+    void SetMapToolbar() const;
+    int32_t IsUsedInPairs() const;
+    rct_ride_entry* GetRideEntry() const;
+    rct_ride_entry_vehicle* Entry() const;
+    Ride* GetRide() const;
+    Vehicle* TrainHead() const;
+    Vehicle* TrainTail() const;
+    void EnableCollisionsForTrain();
+
+
+
+    void MoveRelativeDistance(int32_t distance);
+    track_type_t GetTrackType() const
+    {
+        return TrackTypeAndDirection >> 2;
+    }
+    uint8_t GetTrackDirection() const
+    {
+        return TrackTypeAndDirection & VehicleTrackDirectionMask;
+    }
+    void SetTrackType(track_type_t trackType)
+    {
+
+        TrackTypeAndDirection &= ~VehicleTrackTypeMask;
+        TrackTypeAndDirection |= trackType << 2;
+    }
+    void SetTrackDirection(uint8_t trackDirection)
+    {
+
+        TrackTypeAndDirection &= ~VehicleTrackDirectionMask;
+        TrackTypeAndDirection |= trackDirection & VehicleTrackDirectionMask;
+    }
+    bool HasUpdateFlag(uint32_t flag) const
+    {
+        return (update_flags & flag) != 0;
+    }
+    void ClearUpdateFlag(uint32_t flag)
+    {
+        update_flags &= ~flag;
+    }
+    void SetUpdateFlag(uint32_t flag)
+    {
+        update_flags |= flag;
+    }
+    void ApplyMass(int16_t appliedMass);
+
+private:
+    bool SoundCanPlay() const;
+    uint16_t GetSoundPriority() const;
+    const rct_vehicle_info* GetMoveInfo() const;
+    uint16_t GetTrackProgress() const;
+    OpenRCT2::Audio::VehicleSoundParams CreateSoundParam(uint16_t priority) const;
+    void CableLiftUpdate();
+    bool CableLiftUpdateTrackMotionForwards();
+    bool CableLiftUpdateTrackMotionBackwards();
+    void CableLiftUpdateMovingToEndOfStation();
+    void CableLiftUpdateWaitingToDepart();
+    void CableLiftUpdateDeparting();
+    void CableLiftUpdateTravelling();
+    void CableLiftUpdateArriving();
+    void Sub6DBF3E();
+    void UpdateMeasurements();
+    void UpdateMovingToEndOfStation();
+    void UpdateWaitingForPassengers();
+    void UpdateWaitingToDepart();
+    void UpdateCrash();
+    void UpdateDodgemsMode();
+    void UpdateSwinging();
+    void UpdateSimulatorOperating();
+    void UpdateTopSpinOperating();
+    void UpdateFerrisWheelRotating();
+    void UpdateSpaceRingsOperating();
+    void UpdateHauntedHouseOperating();
+    void UpdateCrookedHouseOperating();
+    void UpdateRotating();
+    void UpdateDeparting();
+    void FinishDeparting();
+    void UpdateTravelling();
+    void UpdateTravellingCableLift();
+    void UpdateTravellingBoat();
+    void UpdateMotionBoatHire();
+    void TryReconnectBoatToTrack(const CoordsXY& currentBoatLocation, const CoordsXY& trackCoords);
+    void UpdateDepartingBoatHire();
+    void UpdateTravellingBoatHireSetup();
+    void UpdateBoatLocation();
+    void UpdateArriving();
+    void UpdateUnloadingPassengers();
+    void UpdateWaitingForCableLift();
+    void UpdateShowingFilm();
+    void UpdateDoingCircusShow();
+    void UpdateCrossings() const;
+    void UpdateSound();
+    void GetLiftHillSound(Ride* curRide, SoundIdVolume& curSound);
+    OpenRCT2::Audio::SoundId UpdateScreamSound();
+    OpenRCT2::Audio::SoundId ProduceScreamSound(const int32_t totalNumPeeps);
+    void UpdateCrashSetup();
+    void UpdateCollisionSetup();
+    int32_t UpdateMotionDodgems();
+    void UpdateAdditionalAnimation();
+    void CheckIfMissing();
+    bool CurrentTowerElementIsTop();
+    bool UpdateTrackMotionForwards(rct_ride_entry_vehicle* vehicleEntry, Ride* curRide, rct_ride_entry* rideEntry);
+    bool UpdateTrackMotionBackwards(rct_ride_entry_vehicle* vehicleEntry, Ride* curRide, rct_ride_entry* rideEntry);
+    int32_t UpdateTrackMotionPoweredRideAcceleration(
+        rct_ride_entry_vehicle* vehicleEntry, uint32_t totalMass, const int32_t curAcceleration);
+    int32_t NumPeepsUntilTrainTail() const;
+    void InvalidateWindow();
+    void TestReset();
+    void UpdateTestFinish();
+    void PeepEasterEggHereWeAre() const;
+    bool CanDepartSynchronised() const;
+    void ReverseReverserCar();
+    void UpdateReverserCarBogies();
+    void UpdateHandleWaterSplash() const;
+    void Claxon() const;
+    void UpdateTrackMotionUpStopCheck() const;
+    void ApplyNonStopBlockBrake();
+    void ApplyStopBlockBrake();
+    void CheckAndApplyBlockSectionStopSite();
+    void UpdateVelocity();
+    void UpdateSpinningCar();
+    void UpdateSwingingCar();
+    int32_t GetSwingAmount() const;
+    bool OpenRestraints();
+    bool CloseRestraints();
+    void CrashOnWater();
+    void CrashOnLand();
+    void SimulateCrash() const;
+    void KillAllPassengersInTrain();
+    void KillPassengers(Ride* curRide);
+    void TrainReadyToDepart(uint8_t num_peeps_on_train, uint8_t num_used_seats);
+    int32_t UpdateTrackMotionMiniGolf(int32_t* outStation);
+    void UpdateTrackMotionMiniGolfVehicle(Ride* curRide, rct_ride_entry* rideEntry, rct_ride_entry_vehicle* vehicleEntry);
+    bool UpdateTrackMotionForwardsGetNewTrack(uint16_t trackType, Ride* curRide, rct_ride_entry* rideEntry);
+    bool UpdateTrackMotionBackwardsGetNewTrack(uint16_t trackType, Ride* curRide, uint16_t* progress);
+    bool UpdateMotionCollisionDetection(const CoordsXYZ& loc, uint16_t* otherVehicleIndex);
+    void UpdateGoKartAttemptSwitchLanes();
+    void UpdateSceneryDoor() const;
+    void UpdateSceneryDoorBackwards() const;
+    void UpdateLandscapeDoor() const;
+    void UpdateLandscapeDoorBackwards() const;
+};
+
+struct train_ref
+{
+    Vehicle* head;
+    Vehicle* tail;
+};
+
+enum : uint32_t
+{
+    VEHICLE_ENTRY_FLAG_POWERED_RIDE_UNRESTRICTED_GRAVITY = 1
+        << 0,
+    VEHICLE_ENTRY_FLAG_NO_UPSTOP_WHEELS = 1 << 1,
+    VEHICLE_ENTRY_FLAG_NO_UPSTOP_BOBSLEIGH = 1 << 2,
+    VEHICLE_ENTRY_FLAG_MINI_GOLF = 1 << 3,
+    VEHICLE_ENTRY_FLAG_4 = 1 << 4,
+    VEHICLE_ENTRY_FLAG_5 = 1 << 5,
+    VEHICLE_ENTRY_FLAG_HAS_INVERTED_SPRITE_SET = 1 << 6,
+
+    VEHICLE_ENTRY_FLAG_DODGEM_INUSE_LIGHTS = 1
+        << 7,
+    VEHICLE_ENTRY_FLAG_ALLOW_DOORS_DEPRECATED = 1 << 8,
+    VEHICLE_ENTRY_FLAG_ENABLE_ADDITIONAL_COLOUR_2 = 1 << 9,
+    VEHICLE_ENTRY_FLAG_10 = 1 << 10,
+    VEHICLE_ENTRY_FLAG_11 = 1 << 11,
+    VEHICLE_ENTRY_FLAG_OVERRIDE_NUM_VERTICAL_FRAMES = 1
+        << 12,
+
+    VEHICLE_ENTRY_FLAG_13 = 1 << 13,
+    VEHICLE_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES = 1
+        << 14,
+
+    VEHICLE_ENTRY_FLAG_LIFT = 1 << 15,
+    VEHICLE_ENTRY_FLAG_ENABLE_ADDITIONAL_COLOUR_1 = 1 << 16,
+    VEHICLE_ENTRY_FLAG_SWINGING = 1 << 17,
+    VEHICLE_ENTRY_FLAG_SPINNING = 1 << 18,
+    VEHICLE_ENTRY_FLAG_POWERED = 1 << 19,
+    VEHICLE_ENTRY_FLAG_RIDERS_SCREAM = 1 << 20,
+    VEHICLE_ENTRY_FLAG_21 = 1 << 21,
+    VEHICLE_ENTRY_FLAG_BOAT_HIRE_COLLISION_DETECTION = 1 << 22,
+    VEHICLE_ENTRY_FLAG_VEHICLE_ANIMATION = 1 << 23,
+
+    VEHICLE_ENTRY_FLAG_RIDER_ANIMATION = 1 << 24,
+    VEHICLE_ENTRY_FLAG_25 = 1 << 25,
+    VEHICLE_ENTRY_FLAG_LOADING_WAYPOINTS = 1
+        << 26,
+    VEHICLE_ENTRY_FLAG_SLIDE_SWING = 1
+        << 27,
+    VEHICLE_ENTRY_FLAG_CHAIRLIFT = 1 << 28,
+    VEHICLE_ENTRY_FLAG_WATER_RIDE = 1 << 29,
+    VEHICLE_ENTRY_FLAG_GO_KART = 1 << 30,
+    VEHICLE_ENTRY_FLAG_DODGEM_CAR_PLACEMENT = 1u << 31,
+};
+
+enum
+{
+    VEHICLE_ENTRY_ANIMATION_NONE,
+    VEHICLE_ENTRY_ANIMATION_MINITURE_RAILWAY_LOCOMOTIVE,
+    VEHICLE_ENTRY_ANIMATION_SWAN,
+    VEHICLE_ENTRY_ANIMATION_CANOES,
+    VEHICLE_ENTRY_ANIMATION_ROW_BOATS,
+    VEHICLE_ENTRY_ANIMATION_WATER_TRICYCLES,
+    VEHICLE_ENTRY_ANIMATION_OBSERVATION_TOWER,
+    VEHICLE_ENTRY_ANIMATION_HELICARS,
+    VEHICLE_ENTRY_ANIMATION_MONORAIL_CYCLES,
+    VEHICLE_ENTRY_ANIMATION_MULTI_DIM_COASTER
+};
+
+enum : uint32_t
+{
+    VEHICLE_UPDATE_FLAG_ON_LIFT_HILL = (1 << 0),
+    VEHICLE_UPDATE_FLAG_COLLISION_DISABLED = (1 << 1),
+    VEHICLE_UPDATE_FLAG_WAIT_ON_ADJACENT = (1 << 2),
+    VEHICLE_UPDATE_FLAG_REVERSING_SHUTTLE = (1 << 3),
+    VEHICLE_UPDATE_FLAG_TRAIN_READY_DEPART = (1 << 4),
+    VEHICLE_UPDATE_FLAG_TESTING = (1 << 5),
+    VEHICLE_UPDATE_FLAG_6 = (1 << 6),
+    VEHICLE_UPDATE_FLAG_ZERO_VELOCITY = (1 << 7),
+    VEHICLE_UPDATE_FLAG_BROKEN_CAR = (1 << 8),
+    VEHICLE_UPDATE_FLAG_BROKEN_TRAIN = (1 << 9),
+    VEHICLE_UPDATE_FLAG_ON_BRAKE_FOR_DROP = (1 << 10),
+    VEHICLE_UPDATE_FLAG_USE_INVERTED_SPRITES = (1 << 11),
+
+    VEHICLE_UPDATE_FLAG_12 = (1 << 12),
+    VEHICLE_UPDATE_FLAG_ROTATION_OFF_WILD_MOUSE = (1 << 13),
+    VEHICLE_UPDATE_FLAG_SINGLE_CAR_POSITION = (1 << 14),
+
+};
+
+enum : uint32_t
+{
+    VEHICLE_SPRITE_FLAG_FLAT = (1 << 0),
+    VEHICLE_SPRITE_FLAG_GENTLE_SLOPES = (1 << 1),
+    VEHICLE_SPRITE_FLAG_STEEP_SLOPES = (1 << 2),
+    VEHICLE_SPRITE_FLAG_VERTICAL_SLOPES = (1 << 3),
+    VEHICLE_SPRITE_FLAG_DIAGONAL_SLOPES = (1 << 4),
+    VEHICLE_SPRITE_FLAG_FLAT_BANKED = (1 << 5),
+    VEHICLE_SPRITE_FLAG_INLINE_TWISTS = (1 << 6),
+    VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_BANKED_TRANSITIONS = (1 << 7),
+    VEHICLE_SPRITE_FLAG_DIAGONAL_GENTLE_SLOPE_BANKED_TRANSITIONS = (1 << 8),
+    VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TRANSITIONS = (1 << 9),
+    VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TURNS = (1 << 10),
+    VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_WHILE_BANKED_TRANSITIONS = (1 << 11),
+    VEHICLE_SPRITE_FLAG_CORKSCREWS = (1 << 12),
+    VEHICLE_SPRITE_FLAG_RESTRAINT_ANIMATION = (1 << 13),
+    VEHICLE_SPRITE_FLAG_CURVED_LIFT_HILL = (1 << 14),
+    VEHICLE_SPRITE_FLAG_15 = (1 << 15),
+};
+
+enum
+{
+    VEHICLE_VISUAL_DEFAULT,
+    VEHICLE_VISUAL_FLAT_RIDE_OR_CAR_RIDE,
+    VEHICLE_VISUAL_LAUNCHED_FREEFALL,
+    VEHICLE_VISUAL_OBSERVATION_TOWER,
+    VEHICLE_VISUAL_RIVER_RAPIDS,
+    VEHICLE_VISUAL_MINI_GOLF_PLAYER,
+    VEHICLE_VISUAL_MINI_GOLF_BALL,
+    VEHICLE_VISUAL_REVERSER,
+    VEHICLE_VISUAL_SPLASH_BOATS_OR_WATER_COASTER,
+    VEHICLE_VISUAL_ROTO_DROP,
+    VEHICLE_VISUAL_SPLASH1_EFFECT,
+    VEHICLE_VISUAL_SPLASH2_EFFECT,
+    VEHICLE_VISUAL_SPLASH3_EFFECT,
+    VEHICLE_VISUAL_SPLASH4_EFFECT,
+    VEHICLE_VISUAL_SPLASH5_EFFECT,
+    VEHICLE_VISUAL_VIRGINIA_REEL,
+    VEHICLE_VISUAL_SUBMARINE
+};
+
+enum : uint32_t
+{
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_VEHICLE_AT_STATION = 1 << 0,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_1 = 1 << 1,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_2 = 1 << 2,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_3 = 1 << 3,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_VEHICLE_ON_LIFT_HILL = 1 << 4,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_5 = 1 << 5,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_VEHICLE_DERAILED = 1 << 6,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_VEHICLE_COLLISION = 1 << 7,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_8 = 1 << 8,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_9 = 1 << 9,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_VEHICLE_AT_BLOCK_BRAKE = 1 << 10,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_11 = 1 << 11,
+    VEHICLE_UPDATE_MOTION_TRACK_FLAG_12 = 1 << 12,
+};
+
+enum
+{
+    VEHICLE_SOUND2_FLAGS_LIFT_HILL = 1 << 1
+};
+
+enum
+{
+    FRICTION_SOUND_WOOD_SMALL = 1,
+    FRICTION_SOUND_STEEL = 2,
+    FRICTION_SOUND_PETROL = 21,
+    FRICTION_SOUND_TRAIN = 31,
+    FRICTION_SOUND_WATERSLIDE = 32,
+    FRICTION_SOUND_WOOD_LARGE = 54,
+    FRICTION_SOUND_STEEL_SMOOTH = 57,
+    FRICTION_SOUND_NONE = 255
+};
+
+enum
+{
+    SOUND_RANGE_SCREAMS_0 = 0,
+    SOUND_RANGE_SCREAMS_1 = 1,
+    SOUND_RANGE_SCREAMS_2 = 2,
+    SOUND_RANGE_WHISTLE = 3,
+    SOUND_RANGE_BELL = 4,
+    SOUND_RANGE_NONE = 255
+};
+
+
+
+
+Vehicle* try_get_vehicle(uint16_t spriteIndex);
+void vehicle_update_all();
+void vehicle_sounds_update();
+
+extern Vehicle* gCurrentVehicle;
+extern StationIndex _vehicleStationIndex;
+extern uint32_t _vehicleMotionTrackFlags;
+extern int32_t _vehicleVelocityF64E08;
+extern int32_t _vehicleVelocityF64E0C;
+extern int32_t _vehicleUnkF64E10;
+extern uint8_t _vehicleF64E2C;
+extern Vehicle* _vehicleFrontVehicle;
+extern CoordsXYZ unk_F64E20;
+# 35 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/Scenario.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/scenario/Scenario.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../common.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/scenario/Scenario.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../core/Random.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/scenario/../core/Random.hpp"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../core/Meta.hpp" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/scenario/../core/Meta.hpp"
+       
+
+
+
+namespace Meta
+{
+
+
+
+    template<typename... _TConditions> struct all : std::true_type
+    {
+    };
+
+    template<typename _TCondition, typename... _TConditions>
+    struct all<_TCondition, _TConditions...> : std::conditional<_TCondition::value, all<_TConditions...>, std::false_type>::type
+    {
+    };
+
+    template<typename _TType, typename... _TTypes> using all_convertible = all<std::is_convertible<_TTypes, _TType>...>;
+
+}
+# 13 "/home/ted/dev/openrct2/src/openrct2/scenario/../core/Random.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/random" 1 3
+# 32 "/usr/include/c++/10.2.0/random" 3
+       
+# 33 "/usr/include/c++/10.2.0/random" 3
+
+
+
+
+
+# 1 "/usr/include/c++/10.2.0/cmath" 1 3
+# 39 "/usr/include/c++/10.2.0/cmath" 3
+       
+# 40 "/usr/include/c++/10.2.0/cmath" 3
+
+
+
+
+
+# 1 "/usr/include/math.h" 1 3 4
+# 27 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
+# 28 "/usr/include/math.h" 2 3 4
+
+
+
+
+
+
+
+# 34 "/usr/include/math.h" 3 4
+extern "C" {
+
+
+
+
+
+# 1 "/usr/include/bits/math-vector.h" 1 3 4
+# 25 "/usr/include/bits/math-vector.h" 3 4
+# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4
+# 26 "/usr/include/bits/math-vector.h" 2 3 4
+# 41 "/usr/include/math.h" 2 3 4
+# 138 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4
+# 139 "/usr/include/math.h" 2 3 4
+# 149 "/usr/include/math.h" 3 4
+typedef float float_t;
+typedef double double_t;
+# 190 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/fp-logb.h" 1 3 4
+# 191 "/usr/include/math.h" 2 3 4
+# 233 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/fp-fast.h" 1 3 4
+# 234 "/usr/include/math.h" 2 3 4
+
+
+
+enum
+  {
+    FP_INT_UPWARD =
+
+      0,
+    FP_INT_DOWNWARD =
+
+      1,
+    FP_INT_TOWARDZERO =
+
+      2,
+    FP_INT_TONEARESTFROMZERO =
+
+      3,
+    FP_INT_TONEAREST =
+
+      4,
+  };
+# 298 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
+# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
+extern int __fpclassify (double __value) noexcept (true)
+     __attribute__ ((__const__));
+
+
+extern int __signbit (double __value) noexcept (true)
+     __attribute__ ((__const__));
+
+
+
+extern int __isinf (double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __finite (double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __isnan (double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __iseqsig (double __x, double __y) noexcept (true);
+
+
+extern int __issignaling (double __value) noexcept (true)
+     __attribute__ ((__const__));
+# 299 "/usr/include/math.h" 2 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true);
+
+extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true);
+
+extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true);
+
+extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true);
+
+
+ extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true);
+
+ extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true);
+
+extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true);
+
+
+
+
+extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true);
+
+extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true);
+
+extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true);
+
+
+
+ extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true)
+                                                        ;
+
+
+
+
+extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true);
+
+extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true);
+
+extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true);
+
+
+
+
+
+ extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true);
+
+
+extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true);
+
+
+extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true);
+
+
+ extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true);
+
+
+extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true);
+
+
+extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true);
+
+
+
+
+extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true);
+
+
+extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true);
+
+
+extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true);
+
+
+
+
+extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true);
+
+
+extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true);
+
+
+
+
+
+
+ extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true);
+
+
+extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true);
+
+
+
+extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true);
+
+
+
+
+extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true);
+
+
+
+
+
+
+extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); extern double __ceil (double __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); extern double __fabs (double __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); extern double __floor (double __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true);
+# 183 "/usr/include/bits/mathcalls.h" 3 4
+extern int finite (double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true);
+
+
+
+extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true);
+
+
+
+
+
+
+extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true);
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true);
+extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true);
+extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true);
+extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true);
+extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true);
+extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true);
+
+
+
+
+
+extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true);
+extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true);
+extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true);
+
+
+
+
+extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true);
+
+
+
+
+
+extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true);
+
+
+
+
+
+
+
+extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true);
+
+
+
+
+
+
+extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true);
+
+
+extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true);
+
+extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true);
+
+
+
+
+extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true);
+
+extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true);
+
+
+
+extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true);
+
+
+
+extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true);
+
+
+
+extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true);
+
+
+
+
+extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true);
+
+
+
+
+extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true);
+
+
+
+extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true);
+
+
+
+extern double round (double __x) noexcept (true) __attribute__ ((__const__)); extern double __round (double __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); extern double __trunc (double __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true);
+
+
+
+
+
+
+extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true);
+__extension__
+extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true);
+
+
+
+extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true);
+__extension__
+extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true);
+
+
+
+extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true);
+
+
+extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true);
+
+
+
+
+extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); extern double __roundeven (double __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true)
+                            ;
+
+
+
+extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true)
+                              ;
+
+
+
+
+extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true)
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true)
+                               ;
+
+
+extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern int canonicalize (double *__cx, const double *__x) noexcept (true);
+
+
+
+
+extern int totalorder (const double *__x, const double *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermag (const double *__x, const double *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true);
+
+
+extern int setpayload (double *__x, double __payload) noexcept (true);
+
+
+extern int setpayloadsig (double *__x, double __payload) noexcept (true);
+
+
+
+
+
+
+
+extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true);
+# 300 "/usr/include/math.h" 2 3 4
+# 315 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
+# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
+extern int __fpclassifyf (float __value) noexcept (true)
+     __attribute__ ((__const__));
+
+
+extern int __signbitf (float __value) noexcept (true)
+     __attribute__ ((__const__));
+
+
+
+extern int __isinff (float __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __finitef (float __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __isnanf (float __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __iseqsigf (float __x, float __y) noexcept (true);
+
+
+extern int __issignalingf (float __value) noexcept (true)
+     __attribute__ ((__const__));
+# 316 "/usr/include/math.h" 2 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true);
+
+extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true);
+
+extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true);
+
+extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true);
+
+
+ extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true);
+
+ extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true);
+
+extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true);
+
+
+
+
+extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true);
+
+extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true);
+
+extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true);
+
+
+
+ extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true)
+                                                        ;
+
+
+
+
+extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true);
+
+extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true);
+
+extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true);
+
+
+
+
+
+ extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true);
+
+
+extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true);
+
+
+extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true);
+
+
+ extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true);
+
+
+extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true);
+
+
+extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true);
+
+
+
+
+extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true);
+
+
+extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true);
+
+
+extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true);
+
+
+
+
+extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true);
+
+
+extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true);
+
+
+
+
+
+
+ extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true);
+
+
+extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true);
+
+
+
+extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true);
+
+
+
+
+extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true);
+
+
+
+
+
+
+extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __ceilf (float __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true);
+# 177 "/usr/include/bits/mathcalls.h" 3 4
+extern int isinff (float __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+
+
+extern int finitef (float __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true);
+
+
+
+extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true);
+
+
+
+
+
+
+extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true);
+# 213 "/usr/include/bits/mathcalls.h" 3 4
+extern int isnanf (float __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+
+
+
+extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true);
+extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true);
+extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true);
+extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true);
+extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true);
+extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true);
+
+
+
+
+
+extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true);
+extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true);
+extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true);
+
+
+
+
+extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true);
+
+
+
+
+
+extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true);
+
+
+
+
+
+
+
+extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true);
+
+
+
+
+
+
+extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true);
+
+
+extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true);
+
+extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true);
+
+
+
+
+extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true);
+
+extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true);
+
+
+
+extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true);
+
+
+
+extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true);
+
+
+
+extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true);
+
+
+
+
+extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true);
+
+
+
+
+extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true);
+
+
+
+extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true);
+
+
+
+extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundf (float __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __truncf (float __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true);
+
+
+
+
+
+
+extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true);
+__extension__
+extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true);
+
+
+
+extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true);
+__extension__
+extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true);
+
+
+
+extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true);
+
+
+extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true);
+
+
+
+
+extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundevenf (float __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true)
+                            ;
+
+
+
+extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true)
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true)
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true)
+                               ;
+
+
+extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern int canonicalizef (float *__cx, const float *__x) noexcept (true);
+
+
+
+
+extern int totalorderf (const float *__x, const float *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf (const float *__x, const float *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true);
+
+
+extern int setpayloadf (float *__x, float __payload) noexcept (true);
+
+
+extern int setpayloadsigf (float *__x, float __payload) noexcept (true);
+
+
+
+
+
+
+
+extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true);
+# 317 "/usr/include/math.h" 2 3 4
+# 384 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
+# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
+extern int __fpclassifyl (long double __value) noexcept (true)
+     __attribute__ ((__const__));
+
+
+extern int __signbitl (long double __value) noexcept (true)
+     __attribute__ ((__const__));
+
+
+
+extern int __isinfl (long double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __finitel (long double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __isnanl (long double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __iseqsigl (long double __x, long double __y) noexcept (true);
+
+
+extern int __issignalingl (long double __value) noexcept (true)
+     __attribute__ ((__const__));
+# 385 "/usr/include/math.h" 2 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true);
+
+extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true);
+
+extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true);
+
+extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true);
+
+
+ extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true);
+
+ extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true);
+
+extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true);
+
+
+
+
+extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true);
+
+extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true);
+
+extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true);
+
+
+
+ extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true)
+                                                        ;
+
+
+
+
+extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true);
+
+extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true);
+
+extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true);
+
+
+
+
+
+ extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true);
+
+
+extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true);
+
+
+extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true);
+
+
+ extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true);
+
+
+extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true);
+
+
+extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true);
+
+
+
+
+extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true);
+
+
+extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true);
+
+
+extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true);
+
+
+
+
+extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true);
+
+
+extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true);
+
+
+
+
+
+
+ extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true);
+
+
+extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true);
+
+
+
+extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true);
+
+
+
+
+extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true);
+
+
+
+
+
+
+extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __ceill (long double __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true);
+# 177 "/usr/include/bits/mathcalls.h" 3 4
+extern int isinfl (long double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+
+
+extern int finitel (long double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true);
+
+
+
+extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true);
+
+
+
+
+
+
+extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true);
+# 213 "/usr/include/bits/mathcalls.h" 3 4
+extern int isnanl (long double __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+
+
+
+extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true);
+extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true);
+extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true);
+extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true);
+extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true);
+extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true);
+
+
+
+
+
+extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true);
+extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true);
+extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true);
+
+
+
+
+extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true);
+
+
+
+
+
+extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true);
+
+
+
+
+
+
+
+extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true);
+
+
+
+
+
+
+extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true);
+
+
+extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true);
+
+extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true);
+
+
+
+
+extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true);
+
+extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true);
+
+
+
+extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true);
+
+
+
+extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true);
+
+
+
+extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true);
+
+
+
+
+extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true);
+
+
+
+
+extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true);
+
+
+
+extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true);
+
+
+
+extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundl (long double __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true);
+
+
+
+
+
+
+extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true);
+__extension__
+extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true);
+
+
+
+extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true);
+__extension__
+extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true);
+
+
+
+extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true);
+
+
+extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true);
+
+
+
+
+extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundevenl (long double __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true)
+                            ;
+
+
+
+extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true)
+                              ;
+
+
+
+
+extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true)
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true)
+                               ;
+
+
+extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true);
+
+
+
+
+extern int totalorderl (const long double *__x, const long double *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true);
+
+
+extern int setpayloadl (long double *__x, long double __payload) noexcept (true);
+
+
+extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true);
+
+
+
+
+
+
+
+extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true);
+# 386 "/usr/include/math.h" 2 3 4
+# 436 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true);
+
+extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true);
+
+extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true);
+
+extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true);
+
+
+ extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true);
+
+ extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true);
+
+extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true);
+
+
+
+
+extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true);
+
+extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true);
+
+extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true);
+
+
+
+ extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true)
+                                                        ;
+
+
+
+
+extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true);
+
+extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true);
+
+extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true);
+
+
+
+
+
+ extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true);
+
+
+extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true);
+
+
+extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true);
+
+
+ extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true);
+
+
+extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true);
+
+
+extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true);
+
+
+
+
+extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true);
+
+
+extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true);
+
+
+extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true);
+
+
+
+
+extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true);
+
+
+extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true);
+
+
+
+
+
+
+ extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true);
+
+
+extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true);
+
+
+
+extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true);
+
+
+
+
+extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true);
+
+
+
+
+
+
+extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true);
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true);
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true);
+extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true);
+extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true);
+extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true);
+extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true);
+extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true);
+
+
+
+
+
+extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true);
+extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true);
+extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true);
+
+
+
+
+extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true);
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true);
+
+
+
+
+
+
+extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true);
+
+
+extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true);
+
+
+
+
+
+
+extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true);
+
+extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true);
+
+
+
+extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true);
+
+
+
+extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true);
+
+
+
+extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true);
+
+
+
+
+extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true);
+
+
+
+
+extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true);
+
+
+
+extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true);
+
+
+
+extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true);
+
+
+
+
+
+
+extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true);
+__extension__
+extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true);
+
+
+
+extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true);
+__extension__
+extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true);
+
+
+
+extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true);
+
+
+extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true);
+
+
+
+
+extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true)
+                            ;
+
+
+
+extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true)
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true)
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true)
+                               ;
+
+
+extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true);
+
+
+
+
+extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true);
+
+
+extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true);
+
+
+extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true);
+# 437 "/usr/include/math.h" 2 3 4
+# 453 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true);
+
+extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true);
+
+extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true);
+
+extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true);
+
+
+ extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true);
+
+ extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true);
+
+extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true);
+
+
+
+
+extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true);
+
+extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true);
+
+extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true);
+
+
+
+ extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true)
+                                                        ;
+
+
+
+
+extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true);
+
+extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true);
+
+extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true);
+
+
+
+
+
+ extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true);
+
+
+extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true);
+
+
+extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true);
+
+
+ extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true);
+
+
+extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true);
+
+
+extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true);
+
+
+
+
+extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true);
+
+
+extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true);
+
+
+extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true);
+
+
+
+
+extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true);
+
+
+extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true);
+
+
+
+
+
+
+ extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true);
+
+
+
+extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+
+
+extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true);
+
+
+
+
+
+
+extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true);
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true);
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true);
+extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true);
+extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true);
+extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true);
+extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true);
+extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true);
+
+
+
+
+
+extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true);
+extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true);
+extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true);
+
+
+
+
+extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true);
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true);
+
+
+
+
+
+
+extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true);
+
+
+extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+
+
+
+
+extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true);
+
+extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true);
+
+
+
+extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+
+extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true);
+
+
+
+extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true);
+
+
+
+
+extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true);
+
+
+
+
+extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true);
+
+
+
+extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true);
+
+
+
+extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true);
+
+
+
+
+
+
+extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true);
+__extension__
+extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true);
+
+
+
+extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true);
+__extension__
+extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true);
+
+
+
+extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true);
+
+
+
+
+extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true)
+                            ;
+
+
+
+extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true)
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true)
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true)
+                               ;
+
+
+extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true);
+
+
+
+
+extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true);
+
+
+extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true);
+
+
+extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true);
+# 454 "/usr/include/math.h" 2 3 4
+# 467 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
+# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
+extern int __fpclassifyf128 (_Float128 __value) noexcept (true)
+     __attribute__ ((__const__));
+
+
+extern int __signbitf128 (_Float128 __value) noexcept (true)
+     __attribute__ ((__const__));
+
+
+
+extern int __isinff128 (_Float128 __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __finitef128 (_Float128 __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __isnanf128 (_Float128 __value) noexcept (true)
+  __attribute__ ((__const__));
+
+
+extern int __iseqsigf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern int __issignalingf128 (_Float128 __value) noexcept (true)
+     __attribute__ ((__const__));
+# 468 "/usr/include/math.h" 2 3 4
+
+
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float128 acosf128 (_Float128 __x) noexcept (true); extern _Float128 __acosf128 (_Float128 __x) noexcept (true);
+
+extern _Float128 asinf128 (_Float128 __x) noexcept (true); extern _Float128 __asinf128 (_Float128 __x) noexcept (true);
+
+extern _Float128 atanf128 (_Float128 __x) noexcept (true); extern _Float128 __atanf128 (_Float128 __x) noexcept (true);
+
+extern _Float128 atan2f128 (_Float128 __y, _Float128 __x) noexcept (true); extern _Float128 __atan2f128 (_Float128 __y, _Float128 __x) noexcept (true);
+
+
+ extern _Float128 cosf128 (_Float128 __x) noexcept (true); extern _Float128 __cosf128 (_Float128 __x) noexcept (true);
+
+ extern _Float128 sinf128 (_Float128 __x) noexcept (true); extern _Float128 __sinf128 (_Float128 __x) noexcept (true);
+
+extern _Float128 tanf128 (_Float128 __x) noexcept (true); extern _Float128 __tanf128 (_Float128 __x) noexcept (true);
+
+
+
+
+extern _Float128 coshf128 (_Float128 __x) noexcept (true); extern _Float128 __coshf128 (_Float128 __x) noexcept (true);
+
+extern _Float128 sinhf128 (_Float128 __x) noexcept (true); extern _Float128 __sinhf128 (_Float128 __x) noexcept (true);
+
+extern _Float128 tanhf128 (_Float128 __x) noexcept (true); extern _Float128 __tanhf128 (_Float128 __x) noexcept (true);
+
+
+
+ extern void sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true); extern void __sincosf128 (_Float128 __x, _Float128 *__sinx, _Float128 *__cosx) noexcept (true)
+                                                        ;
+
+
+
+
+extern _Float128 acoshf128 (_Float128 __x) noexcept (true); extern _Float128 __acoshf128 (_Float128 __x) noexcept (true);
+
+extern _Float128 asinhf128 (_Float128 __x) noexcept (true); extern _Float128 __asinhf128 (_Float128 __x) noexcept (true);
+
+extern _Float128 atanhf128 (_Float128 __x) noexcept (true); extern _Float128 __atanhf128 (_Float128 __x) noexcept (true);
+
+
+
+
+
+ extern _Float128 expf128 (_Float128 __x) noexcept (true); extern _Float128 __expf128 (_Float128 __x) noexcept (true);
+
+
+extern _Float128 frexpf128 (_Float128 __x, int *__exponent) noexcept (true); extern _Float128 __frexpf128 (_Float128 __x, int *__exponent) noexcept (true);
+
+
+extern _Float128 ldexpf128 (_Float128 __x, int __exponent) noexcept (true); extern _Float128 __ldexpf128 (_Float128 __x, int __exponent) noexcept (true);
+
+
+ extern _Float128 logf128 (_Float128 __x) noexcept (true); extern _Float128 __logf128 (_Float128 __x) noexcept (true);
+
+
+extern _Float128 log10f128 (_Float128 __x) noexcept (true); extern _Float128 __log10f128 (_Float128 __x) noexcept (true);
+
+
+extern _Float128 modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true); extern _Float128 __modff128 (_Float128 __x, _Float128 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float128 exp10f128 (_Float128 __x) noexcept (true); extern _Float128 __exp10f128 (_Float128 __x) noexcept (true);
+
+
+
+
+extern _Float128 expm1f128 (_Float128 __x) noexcept (true); extern _Float128 __expm1f128 (_Float128 __x) noexcept (true);
+
+
+extern _Float128 log1pf128 (_Float128 __x) noexcept (true); extern _Float128 __log1pf128 (_Float128 __x) noexcept (true);
+
+
+extern _Float128 logbf128 (_Float128 __x) noexcept (true); extern _Float128 __logbf128 (_Float128 __x) noexcept (true);
+
+
+
+
+extern _Float128 exp2f128 (_Float128 __x) noexcept (true); extern _Float128 __exp2f128 (_Float128 __x) noexcept (true);
+
+
+extern _Float128 log2f128 (_Float128 __x) noexcept (true); extern _Float128 __log2f128 (_Float128 __x) noexcept (true);
+
+
+
+
+
+
+ extern _Float128 powf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __powf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float128 sqrtf128 (_Float128 __x) noexcept (true); extern _Float128 __sqrtf128 (_Float128 __x) noexcept (true);
+
+
+
+extern _Float128 hypotf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __hypotf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+
+
+extern _Float128 cbrtf128 (_Float128 __x) noexcept (true); extern _Float128 __cbrtf128 (_Float128 __x) noexcept (true);
+
+
+
+
+
+
+extern _Float128 ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __ceilf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float128 fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fabsf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float128 floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __floorf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float128 fmodf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fmodf128 (_Float128 __x, _Float128 __y) noexcept (true);
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float128 copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __copysignf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float128 nanf128 (const char *__tagb) noexcept (true); extern _Float128 __nanf128 (const char *__tagb) noexcept (true);
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float128 j0f128 (_Float128) noexcept (true); extern _Float128 __j0f128 (_Float128) noexcept (true);
+extern _Float128 j1f128 (_Float128) noexcept (true); extern _Float128 __j1f128 (_Float128) noexcept (true);
+extern _Float128 jnf128 (int, _Float128) noexcept (true); extern _Float128 __jnf128 (int, _Float128) noexcept (true);
+extern _Float128 y0f128 (_Float128) noexcept (true); extern _Float128 __y0f128 (_Float128) noexcept (true);
+extern _Float128 y1f128 (_Float128) noexcept (true); extern _Float128 __y1f128 (_Float128) noexcept (true);
+extern _Float128 ynf128 (int, _Float128) noexcept (true); extern _Float128 __ynf128 (int, _Float128) noexcept (true);
+
+
+
+
+
+extern _Float128 erff128 (_Float128) noexcept (true); extern _Float128 __erff128 (_Float128) noexcept (true);
+extern _Float128 erfcf128 (_Float128) noexcept (true); extern _Float128 __erfcf128 (_Float128) noexcept (true);
+extern _Float128 lgammaf128 (_Float128) noexcept (true); extern _Float128 __lgammaf128 (_Float128) noexcept (true);
+
+
+
+
+extern _Float128 tgammaf128 (_Float128) noexcept (true); extern _Float128 __tgammaf128 (_Float128) noexcept (true);
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float128 lgammaf128_r (_Float128, int *__signgamp) noexcept (true); extern _Float128 __lgammaf128_r (_Float128, int *__signgamp) noexcept (true);
+
+
+
+
+
+
+extern _Float128 rintf128 (_Float128 __x) noexcept (true); extern _Float128 __rintf128 (_Float128 __x) noexcept (true);
+
+
+extern _Float128 nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __nextafterf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+
+
+
+
+extern _Float128 nextdownf128 (_Float128 __x) noexcept (true); extern _Float128 __nextdownf128 (_Float128 __x) noexcept (true);
+
+extern _Float128 nextupf128 (_Float128 __x) noexcept (true); extern _Float128 __nextupf128 (_Float128 __x) noexcept (true);
+
+
+
+extern _Float128 remainderf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __remainderf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+
+extern _Float128 scalbnf128 (_Float128 __x, int __n) noexcept (true); extern _Float128 __scalbnf128 (_Float128 __x, int __n) noexcept (true);
+
+
+
+extern int ilogbf128 (_Float128 __x) noexcept (true); extern int __ilogbf128 (_Float128 __x) noexcept (true);
+
+
+
+
+extern long int llogbf128 (_Float128 __x) noexcept (true); extern long int __llogbf128 (_Float128 __x) noexcept (true);
+
+
+
+
+extern _Float128 scalblnf128 (_Float128 __x, long int __n) noexcept (true); extern _Float128 __scalblnf128 (_Float128 __x, long int __n) noexcept (true);
+
+
+
+extern _Float128 nearbyintf128 (_Float128 __x) noexcept (true); extern _Float128 __nearbyintf128 (_Float128 __x) noexcept (true);
+
+
+
+extern _Float128 roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __roundf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern _Float128 truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __truncf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float128 remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true); extern _Float128 __remquof128 (_Float128 __x, _Float128 __y, int *__quo) noexcept (true);
+
+
+
+
+
+
+extern long int lrintf128 (_Float128 __x) noexcept (true); extern long int __lrintf128 (_Float128 __x) noexcept (true);
+__extension__
+extern long long int llrintf128 (_Float128 __x) noexcept (true); extern long long int __llrintf128 (_Float128 __x) noexcept (true);
+
+
+
+extern long int lroundf128 (_Float128 __x) noexcept (true); extern long int __lroundf128 (_Float128 __x) noexcept (true);
+__extension__
+extern long long int llroundf128 (_Float128 __x) noexcept (true); extern long long int __llroundf128 (_Float128 __x) noexcept (true);
+
+
+
+extern _Float128 fdimf128 (_Float128 __x, _Float128 __y) noexcept (true); extern _Float128 __fdimf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float128 fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaxf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float128 fminf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float128 fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true); extern _Float128 __fmaf128 (_Float128 __x, _Float128 __y, _Float128 __z) noexcept (true);
+
+
+
+
+extern _Float128 roundevenf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__)); extern _Float128 __roundevenf128 (_Float128 __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true)
+                            ;
+
+
+
+extern __uintmax_t ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true)
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true)
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf128 (_Float128 __x, int __round, unsigned int __width) noexcept (true)
+                               ;
+
+
+extern _Float128 fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fmaxmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float128 fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__)); extern _Float128 __fminmagf128 (_Float128 __x, _Float128 __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern int canonicalizef128 (_Float128 *__cx, const _Float128 *__x) noexcept (true);
+
+
+
+
+extern int totalorderf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf128 (const _Float128 *__x, const _Float128 *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern _Float128 getpayloadf128 (const _Float128 *__x) noexcept (true); extern _Float128 __getpayloadf128 (const _Float128 *__x) noexcept (true);
+
+
+extern int setpayloadf128 (_Float128 *__x, _Float128 __payload) noexcept (true);
+
+
+extern int setpayloadsigf128 (_Float128 *__x, _Float128 __payload) noexcept (true);
+# 471 "/usr/include/math.h" 2 3 4
+# 487 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true);
+
+extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true);
+
+extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true);
+
+extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true);
+
+
+ extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true);
+
+ extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true);
+
+extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true);
+
+
+
+
+extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true);
+
+extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true);
+
+extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true);
+
+
+
+ extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true)
+                                                        ;
+
+
+
+
+extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true);
+
+extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true);
+
+extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true);
+
+
+
+
+
+ extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true);
+
+
+extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true);
+
+
+extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true);
+
+
+ extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true);
+
+
+extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true);
+
+
+extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true);
+
+
+
+
+extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true);
+
+
+extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true);
+
+
+extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true);
+
+
+
+
+extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true);
+
+
+extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true);
+
+
+
+
+
+
+ extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true);
+
+
+extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true);
+
+
+
+extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true);
+
+
+
+
+extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true);
+
+
+
+
+
+
+extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true);
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true);
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true);
+extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true);
+extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true);
+extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true);
+extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true);
+extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true);
+
+
+
+
+
+extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true);
+extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true);
+extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true);
+
+
+
+
+extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true);
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true);
+
+
+
+
+
+
+extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true);
+
+
+extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true);
+
+
+
+
+
+
+extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true);
+
+extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true);
+
+
+
+extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true);
+
+
+
+extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true);
+
+
+
+extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true);
+
+
+
+
+extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true);
+
+
+
+
+extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true);
+
+
+
+extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true);
+
+
+
+extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true);
+
+
+
+
+
+
+extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true);
+__extension__
+extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true);
+
+
+
+extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true);
+__extension__
+extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true);
+
+
+
+extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true);
+
+
+extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true);
+
+
+
+
+extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true)
+                            ;
+
+
+
+extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true)
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true)
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true)
+                               ;
+
+
+extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true);
+
+
+
+
+extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true);
+
+
+extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true);
+
+
+extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true);
+# 488 "/usr/include/math.h" 2 3 4
+# 504 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true);
+
+extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true);
+
+extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true);
+
+extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true);
+
+
+ extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true);
+
+ extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true);
+
+extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true);
+
+
+
+
+extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true);
+
+extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true);
+
+extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true);
+
+
+
+ extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true)
+                                                        ;
+
+
+
+
+extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true);
+
+extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true);
+
+extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true);
+
+
+
+
+
+ extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true);
+
+
+extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true);
+
+
+extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true);
+
+
+ extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true);
+
+
+extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true);
+
+
+extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));
+
+
+
+extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true);
+
+
+
+
+extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true);
+
+
+extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true);
+
+
+extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true);
+
+
+
+
+extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true);
+
+
+extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true);
+
+
+
+
+
+
+ extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true);
+
+
+
+extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+
+
+extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true);
+
+
+
+
+
+
+extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true);
+# 198 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true);
+# 220 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true);
+extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true);
+extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true);
+extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true);
+extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true);
+extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true);
+
+
+
+
+
+extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true);
+extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true);
+extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true);
+
+
+
+
+extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true);
+# 252 "/usr/include/bits/mathcalls.h" 3 4
+extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true);
+
+
+
+
+
+
+extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true);
+
+
+extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+
+
+
+
+extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true);
+
+extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true);
+
+
+
+extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+
+extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true);
+
+
+
+extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true);
+
+
+
+
+extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true);
+
+
+
+
+extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true);
+
+
+
+extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true);
+
+
+
+extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+
+extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true);
+
+
+
+
+
+
+extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true);
+__extension__
+extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true);
+
+
+
+extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true);
+__extension__
+extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true);
+
+
+
+extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true);
+
+
+
+
+extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));
+
+
+
+extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true)
+                            ;
+
+
+
+extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true)
+                              ;
+
+
+
+
+extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true)
+                             ;
+
+
+
+
+extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true)
+                               ;
+
+
+extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));
+
+
+extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true);
+
+
+
+
+extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true)
+
+     __attribute__ ((__pure__));
+
+
+extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true);
+
+
+extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true);
+
+
+extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true);
+# 505 "/usr/include/math.h" 2 3 4
+# 552 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern float fadd (double __x, double __y) noexcept (true);
+
+
+extern float fdiv (double __x, double __y) noexcept (true);
+
+
+extern float fmul (double __x, double __y) noexcept (true);
+
+
+extern float fsub (double __x, double __y) noexcept (true);
+# 553 "/usr/include/math.h" 2 3 4
+# 571 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern float faddl (long double __x, long double __y) noexcept (true);
+
+
+extern float fdivl (long double __x, long double __y) noexcept (true);
+
+
+extern float fmull (long double __x, long double __y) noexcept (true);
+
+
+extern float fsubl (long double __x, long double __y) noexcept (true);
+# 572 "/usr/include/math.h" 2 3 4
+# 597 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern double daddl (long double __x, long double __y) noexcept (true);
+
+
+extern double ddivl (long double __x, long double __y) noexcept (true);
+
+
+extern double dmull (long double __x, long double __y) noexcept (true);
+
+
+extern double dsubl (long double __x, long double __y) noexcept (true);
+# 598 "/usr/include/math.h" 2 3 4
+# 677 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true);
+
+
+extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true);
+
+
+extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true);
+
+
+extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true);
+# 678 "/usr/include/math.h" 2 3 4
+# 687 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true);
+# 688 "/usr/include/math.h" 2 3 4
+# 697 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true);
+# 698 "/usr/include/math.h" 2 3 4
+# 707 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32 f32addf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float32 f32divf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float32 f32mulf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float32 f32subf128 (_Float128 __x, _Float128 __y) noexcept (true);
+# 708 "/usr/include/math.h" 2 3 4
+# 727 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true);
+
+
+extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true);
+# 728 "/usr/include/math.h" 2 3 4
+# 737 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true);
+# 738 "/usr/include/math.h" 2 3 4
+# 747 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float32x f32xaddf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float32x f32xdivf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float32x f32xmulf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float32x f32xsubf128 (_Float128 __x, _Float128 __y) noexcept (true);
+# 748 "/usr/include/math.h" 2 3 4
+# 767 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true);
+
+
+extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true);
+# 768 "/usr/include/math.h" 2 3 4
+# 777 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float64 f64addf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float64 f64divf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float64 f64mulf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float64 f64subf128 (_Float128 __x, _Float128 __y) noexcept (true);
+# 778 "/usr/include/math.h" 2 3 4
+# 797 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
+# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
+extern _Float64x f64xaddf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float64x f64xdivf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float64x f64xmulf128 (_Float128 __x, _Float128 __y) noexcept (true);
+
+
+extern _Float64x f64xsubf128 (_Float128 __x, _Float128 __y) noexcept (true);
+# 798 "/usr/include/math.h" 2 3 4
+# 834 "/usr/include/math.h" 3 4
+extern int signgam;
+# 914 "/usr/include/math.h" 3 4
+enum
+  {
+    FP_NAN =
+
+      0,
+    FP_INFINITE =
+
+      1,
+    FP_ZERO =
+
+      2,
+    FP_SUBNORMAL =
+
+      3,
+    FP_NORMAL =
+
+      4
+  };
+# 1034 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/iscanonical.h" 1 3 4
+# 23 "/usr/include/bits/iscanonical.h" 3 4
+extern int __iscanonicall (long double __x)
+     noexcept (true) __attribute__ ((__const__));
+# 46 "/usr/include/bits/iscanonical.h" 3 4
+extern "C++" {
+inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); }
+inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); }
+inline int iscanonical (long double __val) { return __iscanonicall (__val); }
+
+inline int iscanonical (_Float128 __val) { return ((void) (__typeof (__val)) (__val), 1); }
+
+}
+# 1035 "/usr/include/math.h" 2 3 4
+# 1046 "/usr/include/math.h" 3 4
+extern "C++" {
+inline int issignaling (float __val) { return __issignalingf (__val); }
+inline int issignaling (double __val) { return __issignaling (__val); }
+inline int
+issignaling (long double __val)
+{
+
+
+
+  return __issignalingl (__val);
+
+}
+
+
+
+inline int issignaling (_Float128 __val) { return __issignalingf128 (__val); }
+
+}
+# 1077 "/usr/include/math.h" 3 4
+extern "C++" {
+# 1108 "/usr/include/math.h" 3 4
+template <class __T> inline bool
+iszero (__T __val)
+{
+  return __val == 0;
+}
+
+}
+# 1326 "/usr/include/math.h" 3 4
+extern "C++" {
+template<typename> struct __iseqsig_type;
+
+template<> struct __iseqsig_type<float>
+{
+  static int __call (float __x, float __y) throw ()
+  {
+    return __iseqsigf (__x, __y);
+  }
+};
+
+template<> struct __iseqsig_type<double>
+{
+  static int __call (double __x, double __y) throw ()
+  {
+    return __iseqsig (__x, __y);
+  }
+};
+
+template<> struct __iseqsig_type<long double>
+{
+  static int __call (long double __x, long double __y) throw ()
+  {
+
+    return __iseqsigl (__x, __y);
+
+
+
+  }
+};
+
+
+
+
+template<> struct __iseqsig_type<_Float128>
+{
+  static int __call (_Float128 __x, _Float128 __y) throw ()
+  {
+    return __iseqsigf128 (__x, __y);
+  }
+};
+
+
+template<typename _T1, typename _T2>
+inline int
+iseqsig (_T1 __x, _T2 __y) throw ()
+{
+
+  typedef decltype (((__x) + (__y) + 0.0f)) _T3;
+
+
+
+  return __iseqsig_type<_T3>::__call (__x, __y);
+}
+
+}
+
+
+
+
+}
+# 46 "/usr/include/c++/10.2.0/cmath" 2 3
+# 77 "/usr/include/c++/10.2.0/cmath" 3
+extern "C++"
+{
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+  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); }
+# 412 "/usr/include/c++/10.2.0/cmath" 3
+  template<typename _Tp, typename _Up>
+    inline constexpr
+    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
+    pow(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return pow(__type(__x), __type(__y));
+    }
+
+  using ::sin;
+
+
+  inline constexpr float
+  sin(float __x)
+  { return __builtin_sinf(__x); }
+
+  inline constexpr long double
+  sin(long double __x)
+  { return __builtin_sinl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sin(_Tp __x)
+    { return __builtin_sin(__x); }
+
+  using ::sinh;
+
+
+  inline constexpr float
+  sinh(float __x)
+  { return __builtin_sinhf(__x); }
+
+  inline constexpr long double
+  sinh(long double __x)
+  { return __builtin_sinhl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sinh(_Tp __x)
+    { return __builtin_sinh(__x); }
+
+  using ::sqrt;
+
+
+  inline constexpr float
+  sqrt(float __x)
+  { return __builtin_sqrtf(__x); }
+
+  inline constexpr long double
+  sqrt(long double __x)
+  { return __builtin_sqrtl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    sqrt(_Tp __x)
+    { return __builtin_sqrt(__x); }
+
+  using ::tan;
+
+
+  inline constexpr float
+  tan(float __x)
+  { return __builtin_tanf(__x); }
+
+  inline constexpr long double
+  tan(long double __x)
+  { return __builtin_tanl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    tan(_Tp __x)
+    { return __builtin_tan(__x); }
+
+  using ::tanh;
+
+
+  inline constexpr float
+  tanh(float __x)
+  { return __builtin_tanhf(__x); }
+
+  inline constexpr long double
+  tanh(long double __x)
+  { return __builtin_tanhl(__x); }
+
+
+  template<typename _Tp>
+    inline constexpr
+    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                    double>::__type
+    tanh(_Tp __x)
+    { return __builtin_tanh(__x); }
+# 536 "/usr/include/c++/10.2.0/cmath" 3
+  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_signbit(__x); }
+
+  constexpr bool
+  signbit(double __x)
+  { return __builtin_signbit(__x); }
+
+  constexpr bool
+  signbit(long double __x)
+  { return __builtin_signbit(__x); }
+
+
+
+  template<typename _Tp>
+    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+                                              bool>::__type
+    signbit(_Tp __x)
+    { return __x < 0 ? true : false; }
+
+
+
+  constexpr bool
+  isgreater(float __x, float __y)
+  { return __builtin_isgreater(__x, __y); }
+
+  constexpr bool
+  isgreater(double __x, double __y)
+  { return __builtin_isgreater(__x, __y); }
+
+  constexpr bool
+  isgreater(long double __x, long double __y)
+  { return __builtin_isgreater(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreater(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  isgreaterequal(float __x, float __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+  constexpr bool
+  isgreaterequal(double __x, double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+  constexpr bool
+  isgreaterequal(long double __x, long double __y)
+  { return __builtin_isgreaterequal(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isgreaterequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isgreaterequal(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  isless(float __x, float __y)
+  { return __builtin_isless(__x, __y); }
+
+  constexpr bool
+  isless(double __x, double __y)
+  { return __builtin_isless(__x, __y); }
+
+  constexpr bool
+  isless(long double __x, long double __y)
+  { return __builtin_isless(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isless(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isless(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  islessequal(float __x, float __y)
+  { return __builtin_islessequal(__x, __y); }
+
+  constexpr bool
+  islessequal(double __x, double __y)
+  { return __builtin_islessequal(__x, __y); }
+
+  constexpr bool
+  islessequal(long double __x, long double __y)
+  { return __builtin_islessequal(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    islessequal(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessequal(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  islessgreater(float __x, float __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+  constexpr bool
+  islessgreater(double __x, double __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+  constexpr bool
+  islessgreater(long double __x, long double __y)
+  { return __builtin_islessgreater(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    islessgreater(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_islessgreater(__type(__x), __type(__y));
+    }
+
+
+
+  constexpr bool
+  isunordered(float __x, float __y)
+  { return __builtin_isunordered(__x, __y); }
+
+  constexpr bool
+  isunordered(double __x, double __y)
+  { return __builtin_isunordered(__x, __y); }
+
+  constexpr bool
+  isunordered(long double __x, long double __y)
+  { return __builtin_isunordered(__x, __y); }
+
+
+
+  template<typename _Tp, typename _Up>
+    constexpr typename
+    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
+       && __is_arithmetic<_Up>::__value), bool>::__type
+    isunordered(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return __builtin_isunordered(__type(__x), __type(__y));
+    }
+# 1065 "/usr/include/c++/10.2.0/cmath" 3
+  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); }
+# 1923 "/usr/include/c++/10.2.0/cmath" 3
+
+}
+
+
+
+
+
+}
+# 39 "/usr/include/c++/10.2.0/random" 2 3
+# 1 "/usr/include/c++/10.2.0/cstdlib" 1 3
+# 39 "/usr/include/c++/10.2.0/cstdlib" 3
+       
+# 40 "/usr/include/c++/10.2.0/cstdlib" 3
+# 40 "/usr/include/c++/10.2.0/random" 2 3
+# 49 "/usr/include/c++/10.2.0/random" 3
+# 1 "/usr/include/c++/10.2.0/bits/random.h" 1 3
+# 37 "/usr/include/c++/10.2.0/bits/random.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 58 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, size_t __bits,
+    typename _UniformRandomNumberGenerator>
+    _RealType
+    generate_canonical(_UniformRandomNumberGenerator& __g);
+
+
+
+
+  namespace __detail
+  {
+    template<typename _UIntType, size_t __w,
+      bool = __w < static_cast<size_t>
+     (std::numeric_limits<_UIntType>::digits)>
+      struct _Shift
+      { static const _UIntType __value = 0; };
+
+    template<typename _UIntType, size_t __w>
+      struct _Shift<_UIntType, __w, true>
+      { static const _UIntType __value = _UIntType(1) << __w; };
+
+    template<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 _Engine, typename _DInputType>
+      struct _Adaptor
+      {
+ static_assert(std::is_floating_point<_DInputType>::value,
+        "template argument must be 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;
+      };
+
+    template<typename _Sseq>
+      using __seed_seq_generate_t = decltype(
+   std::declval<_Sseq&>().generate(std::declval<uint_least32_t*>(),
+       std::declval<uint_least32_t*>()));
+
+
+
+    template<typename _Sseq, typename _Engine, typename _Res,
+      typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
+      using __is_seed_seq = __and_<
+        __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
+ is_unsigned<typename _Sseq::result_type>,
+ __not_<is_convertible<_Sseq, _Res>>
+      >;
+
+  }
+# 245 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    class linear_congruential_engine
+    {
+      static_assert(std::is_unsigned<_UIntType>::value,
+      "result_type must be an unsigned integral type");
+      static_assert(__m == 0u || (__a < __m && __c < __m),
+      "template argument substituting __m out of bounds");
+
+      template<typename _Sseq>
+ using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
+   _Sseq, linear_congruential_engine, _UIntType>::value>::type;
+
+    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;
+
+
+
+
+
+      linear_congruential_engine() : linear_congruential_engine(default_seed)
+      { }
+# 283 "/usr/include/c++/10.2.0/bits/random.h" 3
+      explicit
+      linear_congruential_engine(result_type __s)
+      { seed(__s); }
+
+
+
+
+
+
+
+      template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
+        explicit
+        linear_congruential_engine(_Sseq& __q)
+        { seed(__q); }
+
+
+
+
+
+
+
+      void
+      seed(result_type __s = default_seed);
+# 314 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _Sseq>
+        _If_seed_seq<_Sseq>
+        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;
+      }
+# 366 "/usr/include/c++/10.2.0/bits/random.h" 3
+      friend bool
+      operator==(const linear_congruential_engine& __lhs,
+   const linear_congruential_engine& __rhs)
+      { return __lhs._M_x == __rhs._M_x; }
+# 379 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+        _UIntType1 __m1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::linear_congruential_engine<_UIntType1,
+     __a1, __c1, __m1>& __lcr);
+# 399 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
+        _UIntType1 __m1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::linear_congruential_engine<_UIntType1, __a1,
+     __c1, __m1>& __lcr);
+
+    private:
+      _UIntType _M_x;
+    };
+# 421 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+    inline bool
+    operator!=(const std::linear_congruential_engine<_UIntType, __a,
+        __c, __m>& __lhs,
+        const std::linear_congruential_engine<_UIntType, __a,
+        __c, __m>& __rhs)
+    { return !(__lhs == __rhs); }
+# 458 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _UIntType, size_t __w,
+    size_t __n, size_t __m, size_t __r,
+    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+    _UIntType __b, size_t __t,
+    _UIntType __c, size_t __l, _UIntType __f>
+    class mersenne_twister_engine
+    {
+      static_assert(std::is_unsigned<_UIntType>::value,
+      "result_type must be 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");
+
+      template<typename _Sseq>
+ using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
+   _Sseq, mersenne_twister_engine, _UIntType>::value>::type;
+
+    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;
+
+
+
+      mersenne_twister_engine() : mersenne_twister_engine(default_seed) { }
+
+      explicit
+      mersenne_twister_engine(result_type __sd)
+      { seed(__sd); }
+
+
+
+
+
+
+
+      template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
+        explicit
+        mersenne_twister_engine(_Sseq& __q)
+        { seed(__q); }
+
+      void
+      seed(result_type __sd = default_seed);
+
+      template<typename _Sseq>
+        _If_seed_seq<_Sseq>
+        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()();
+# 577 "/usr/include/c++/10.2.0/bits/random.h" 3
+      friend bool
+      operator==(const mersenne_twister_engine& __lhs,
+   const mersenne_twister_engine& __rhs)
+      { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
+  && __lhs._M_p == __rhs._M_p); }
+# 595 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _UIntType1,
+        size_t __w1, size_t __n1,
+        size_t __m1, size_t __r1,
+        _UIntType1 __a1, size_t __u1,
+        _UIntType1 __d1, size_t __s1,
+        _UIntType1 __b1, size_t __t1,
+        _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
+        typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
+     __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
+     __l1, __f1>& __x);
+# 621 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _UIntType1,
+        size_t __w1, size_t __n1,
+        size_t __m1, size_t __r1,
+        _UIntType1 __a1, size_t __u1,
+        _UIntType1 __d1, size_t __s1,
+        _UIntType1 __b1, size_t __t1,
+        _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
+        typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
+     __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
+     __l1, __f1>& __x);
+
+    private:
+      void _M_gen_rand();
+
+      _UIntType _M_x[state_size];
+      size_t _M_p;
+    };
+# 654 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _UIntType, size_t __w,
+    size_t __n, size_t __m, size_t __r,
+    _UIntType __a, size_t __u, _UIntType __d, size_t __s,
+    _UIntType __b, size_t __t,
+    _UIntType __c, size_t __l, _UIntType __f>
+    inline bool
+    operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
+        __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
+        const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
+        __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
+    { return !(__lhs == __rhs); }
+# 682 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    class subtract_with_carry_engine
+    {
+      static_assert(std::is_unsigned<_UIntType>::value,
+      "result_type must be an unsigned integral type");
+      static_assert(0u < __s && __s < __r,
+      "0 < s < r");
+      static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
+      "template argument substituting __w out of bounds");
+
+      template<typename _Sseq>
+ using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
+   _Sseq, subtract_with_carry_engine, _UIntType>::value>::type;
+
+    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;
+
+      subtract_with_carry_engine() : subtract_with_carry_engine(default_seed)
+      { }
+
+
+
+
+
+      explicit
+      subtract_with_carry_engine(result_type __sd)
+      { seed(__sd); }
+
+
+
+
+
+
+
+      template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
+        explicit
+        subtract_with_carry_engine(_Sseq& __q)
+        { seed(__q); }
+# 740 "/usr/include/c++/10.2.0/bits/random.h" 3
+      void
+      seed(result_type __sd = default_seed);
+
+
+
+
+
+      template<typename _Sseq>
+ _If_seed_seq<_Sseq>
+        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()();
+# 795 "/usr/include/c++/10.2.0/bits/random.h" 3
+      friend bool
+      operator==(const subtract_with_carry_engine& __lhs,
+   const subtract_with_carry_engine& __rhs)
+      { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
+  && __lhs._M_carry == __rhs._M_carry
+  && __lhs._M_p == __rhs._M_p); }
+# 814 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
+        typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::subtract_with_carry_engine<_UIntType1, __w1,
+     __s1, __r1>& __x);
+# 833 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
+        typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::subtract_with_carry_engine<_UIntType1, __w1,
+     __s1, __r1>& __x);
+
+    private:
+
+      _UIntType _M_x[long_lag];
+      _UIntType _M_carry;
+      size_t _M_p;
+    };
+# 859 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
+    inline bool
+    operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
+        __s, __r>& __lhs,
+        const std::subtract_with_carry_engine<_UIntType, __w,
+        __s, __r>& __rhs)
+    { return !(__lhs == __rhs); }
+# 874 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RandomNumberEngine, size_t __p, size_t __r>
+    class discard_block_engine
+    {
+      static_assert(1 <= __r && __r <= __p,
+      "template argument substituting __r out of bounds");
+
+    public:
+
+      typedef typename _RandomNumberEngine::result_type result_type;
+
+      template<typename _Sseq>
+ using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
+   _Sseq, discard_block_engine, result_type>::value>::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 = _If_seed_seq<_Sseq>>
+        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>
+        _If_seed_seq<_Sseq>
+        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()();
+# 1025 "/usr/include/c++/10.2.0/bits/random.h" 3
+      friend bool
+      operator==(const discard_block_engine& __lhs,
+   const discard_block_engine& __rhs)
+      { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
+# 1041 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
+        typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::discard_block_engine<_RandomNumberEngine1,
+     __p1, __r1>& __x);
+# 1059 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
+        typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::discard_block_engine<_RandomNumberEngine1,
+     __p1, __r1>& __x);
+
+    private:
+      _RandomNumberEngine _M_b;
+      size_t _M_n;
+    };
+# 1082 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RandomNumberEngine, size_t __p, size_t __r>
+    inline bool
+    operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
+        __r>& __lhs,
+        const std::discard_block_engine<_RandomNumberEngine, __p,
+        __r>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+
+  template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
+    class independent_bits_engine
+    {
+      static_assert(std::is_unsigned<_UIntType>::value,
+      "result_type must be an unsigned integral type");
+      static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
+      "template argument substituting __w out of bounds");
+
+      template<typename _Sseq>
+ using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
+   _Sseq, independent_bits_engine, _UIntType>::value>::type;
+
+    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 = _If_seed_seq<_Sseq>>
+        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>
+        _If_seed_seq<_Sseq>
+        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()();
+# 1236 "/usr/include/c++/10.2.0/bits/random.h" 3
+      friend bool
+      operator==(const independent_bits_engine& __lhs,
+   const independent_bits_engine& __rhs)
+      { return __lhs._M_b == __rhs._M_b; }
+# 1253 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::independent_bits_engine<_RandomNumberEngine,
+     __w, _UIntType>& __x)
+ {
+   __is >> __x._M_b;
+   return __is;
+ }
+
+    private:
+      _RandomNumberEngine _M_b;
+    };
+# 1279 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
+    inline bool
+    operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
+        _UIntType>& __lhs,
+        const std::independent_bits_engine<_RandomNumberEngine, __w,
+        _UIntType>& __rhs)
+    { return !(__lhs == __rhs); }
+# 1297 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
+    typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const std::independent_bits_engine<_RandomNumberEngine,
+        __w, _UIntType>& __x)
+    {
+      __os << __x.base();
+      return __os;
+    }
+
+
+
+
+
+
+
+  template<typename _RandomNumberEngine, size_t __k>
+    class shuffle_order_engine
+    {
+      static_assert(1u <= __k, "template argument substituting "
+      "__k out of bound");
+
+    public:
+
+      typedef typename _RandomNumberEngine::result_type result_type;
+
+      template<typename _Sseq>
+ using _If_seed_seq = typename enable_if<__detail::__is_seed_seq<
+   _Sseq, shuffle_order_engine, result_type>::value>::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 = _If_seed_seq<_Sseq>>
+        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>
+        _If_seed_seq<_Sseq>
+        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()();
+# 1466 "/usr/include/c++/10.2.0/bits/random.h" 3
+      friend bool
+      operator==(const shuffle_order_engine& __lhs,
+   const shuffle_order_engine& __rhs)
+      { return (__lhs._M_b == __rhs._M_b
+  && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
+  && __lhs._M_y == __rhs._M_y); }
+# 1484 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RandomNumberEngine1, size_t __k1,
+        typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::shuffle_order_engine<_RandomNumberEngine1,
+     __k1>& __x);
+# 1502 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RandomNumberEngine1, size_t __k1,
+        typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
+
+    private:
+      void _M_initialize()
+      {
+ for (size_t __i = 0; __i < __k; ++__i)
+   _M_v[__i] = _M_b();
+ _M_y = _M_b();
+      }
+
+      _RandomNumberEngine _M_b;
+      result_type _M_v[__k];
+      result_type _M_y;
+    };
+# 1532 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RandomNumberEngine, size_t __k>
+    inline bool
+    operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
+        __k>& __lhs,
+        const std::shuffle_order_engine<_RandomNumberEngine,
+        __k>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+  typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
+  minstd_rand0;
+
+
+
+
+  typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
+  minstd_rand;
+# 1561 "/usr/include/c++/10.2.0/bits/random.h" 3
+  typedef mersenne_twister_engine<
+    uint_fast32_t,
+    32, 624, 397, 31,
+    0x9908b0dfUL, 11,
+    0xffffffffUL, 7,
+    0x9d2c5680UL, 15,
+    0xefc60000UL, 18, 1812433253UL> mt19937;
+
+
+
+
+  typedef mersenne_twister_engine<
+    uint_fast64_t,
+    64, 312, 156, 31,
+    0xb5026f5aa96619e9ULL, 29,
+    0x5555555555555555ULL, 17,
+    0x71d67fffeda60000ULL, 37,
+    0xfff7eee000000000ULL, 43,
+    6364136223846793005ULL> mt19937_64;
+
+  typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
+    ranlux24_base;
+
+  typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
+    ranlux48_base;
+
+  typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
+
+  typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
+
+  typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
+
+  typedef minstd_rand0 default_random_engine;
+
+
+
+
+
+  class random_device
+  {
+  public:
+
+    typedef unsigned int result_type;
+
+
+
+    random_device() { _M_init("default"); }
+
+    explicit
+    random_device(const std::string& __token) { _M_init(__token); }
+
+
+    ~random_device()
+    { _M_fini(); }
+
+
+    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 this->_M_getentropy();
+
+
+
+    }
+
+    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();
+    double _M_getentropy() const noexcept;
+
+    void _M_init(const char*, size_t);
+
+    union
+    {
+      struct
+      {
+ void* _M_file;
+ result_type (*_M_func)(void*);
+ int _M_fd;
+      };
+      mt19937 _M_mt;
+    };
+  };
+# 1687 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType>
+    inline bool
+    operator!=(const std::uniform_int_distribution<_IntType>& __d1,
+        const std::uniform_int_distribution<_IntType>& __d2)
+    { return !(__d1 == __d2); }
+# 1703 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>&,
+        const std::uniform_int_distribution<_IntType>&);
+# 1717 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>&,
+        std::uniform_int_distribution<_IntType>&);
+# 1730 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class uniform_real_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef uniform_real_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(0) { }
+
+ explicit
+ param_type(_RealType __a, _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_a;
+ _RealType _M_b;
+      };
+
+    public:
+
+
+
+
+
+      uniform_real_distribution() : uniform_real_distribution(0.0) { }
+
+
+
+
+
+
+
+      explicit
+      uniform_real_distribution(_RealType __a, _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); }
+# 1924 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>&,
+        const std::uniform_real_distribution<_RealType>&);
+# 1938 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>&,
+        std::uniform_real_distribution<_RealType>&);
+# 1960 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class normal_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef normal_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(0.0) { }
+
+ explicit
+ param_type(_RealType __mean, _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); }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_mean;
+ _RealType _M_stddev;
+      };
+
+    public:
+      normal_distribution() : normal_distribution(0.0) { }
+
+
+
+
+
+      explicit
+      normal_distribution(result_type __mean,
+     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);
+# 2129 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::normal_distribution<_RealType1>& __x);
+# 2144 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::normal_distribution<_RealType1>& __x);
+
+    private:
+      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); }
+# 2181 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class lognormal_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef lognormal_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(0.0) { }
+
+ explicit
+ param_type(_RealType __m, _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_m;
+ _RealType _M_s;
+      };
+
+      lognormal_distribution() : lognormal_distribution(0.0) { }
+
+      explicit
+      lognormal_distribution(_RealType __m, _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); }
+# 2340 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::lognormal_distribution<_RealType1>& __x);
+# 2355 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::lognormal_distribution<_RealType1>& __x);
+
+    private:
+      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); }
+# 2392 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class gamma_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef gamma_distribution<_RealType> distribution_type;
+ friend class gamma_distribution<_RealType>;
+
+ param_type() : param_type(1.0) { }
+
+ explicit
+ param_type(_RealType __alpha_val, _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); }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ void
+ _M_initialize();
+
+ _RealType _M_alpha;
+ _RealType _M_beta;
+
+ _RealType _M_malpha, _M_a2;
+      };
+
+    public:
+
+
+
+      gamma_distribution() : gamma_distribution(1.0) { }
+
+
+
+
+
+      explicit
+      gamma_distribution(_RealType __alpha_val,
+    _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); }
+# 2572 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::gamma_distribution<_RealType1>& __x);
+# 2586 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::gamma_distribution<_RealType1>& __x);
+
+    private:
+      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); }
+# 2620 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class chi_squared_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef chi_squared_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(1) { }
+
+ explicit
+ param_type(_RealType __n)
+ : _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_n;
+      };
+
+      chi_squared_distribution() : chi_squared_distribution(1) { }
+
+      explicit
+      chi_squared_distribution(_RealType __n)
+      : _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;
+ typedef typename std::gamma_distribution<result_type>::param_type
+   param_type;
+ _M_gd.param(param_type{__param.n() / 2});
+      }
+
+
+
+
+      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; }
+# 2788 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::chi_squared_distribution<_RealType1>& __x);
+# 2803 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::chi_squared_distribution<_RealType1>& __x);
+
+    private:
+      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); }
+# 2844 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class cauchy_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef cauchy_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(0) { }
+
+ explicit
+ param_type(_RealType __a, _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_a;
+ _RealType _M_b;
+      };
+
+      cauchy_distribution() : cauchy_distribution(0.0) { }
+
+      explicit
+      cauchy_distribution(_RealType __a, _RealType __b = 1.0)
+      : _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); }
+# 3021 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const std::cauchy_distribution<_RealType>& __x);
+# 3036 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+        std::cauchy_distribution<_RealType>& __x);
+# 3052 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class fisher_f_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef fisher_f_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(1) { }
+
+ explicit
+ param_type(_RealType __m, _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_m;
+ _RealType _M_n;
+      };
+
+      fisher_f_distribution() : fisher_f_distribution(1.0) { }
+
+      explicit
+      fisher_f_distribution(_RealType __m,
+       _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); }
+# 3227 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::fisher_f_distribution<_RealType1>& __x);
+# 3242 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::fisher_f_distribution<_RealType1>& __x);
+
+    private:
+      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); }
+# 3284 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class student_t_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef student_t_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(1) { }
+
+ explicit
+ param_type(_RealType __n)
+ : _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_n;
+      };
+
+      student_t_distribution() : student_t_distribution(1.0) { }
+
+      explicit
+      student_t_distribution(_RealType __n)
+      : _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); }
+# 3449 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::student_t_distribution<_RealType1>& __x);
+# 3464 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::student_t_distribution<_RealType1>& __x);
+
+    private:
+      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); }
+# 3512 "/usr/include/c++/10.2.0/bits/random.h" 3
+  class bernoulli_distribution
+  {
+  public:
+
+    typedef bool result_type;
+
+
+    struct param_type
+    {
+      typedef bernoulli_distribution distribution_type;
+
+      param_type() : param_type(0.5) { }
+
+      explicit
+      param_type(double __p)
+      : _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; }
+
+      friend bool
+      operator!=(const param_type& __p1, const param_type& __p2)
+      { return !(__p1 == __p2); }
+
+    private:
+      double _M_p;
+    };
+
+  public:
+
+
+
+    bernoulli_distribution() : bernoulli_distribution(0.5) { }
+
+
+
+
+
+
+
+    explicit
+    bernoulli_distribution(double __p)
+    : _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); }
+# 3695 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const std::bernoulli_distribution& __x);
+# 3709 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _CharT, typename _Traits>
+    inline std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+        std::bernoulli_distribution& __x)
+    {
+      double __p;
+      if (__is >> __p)
+ __x.param(bernoulli_distribution::param_type(__p));
+      return __is;
+    }
+# 3728 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType = int>
+    class binomial_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+      "result_type must be an integral type");
+
+    public:
+
+      typedef _IntType result_type;
+
+
+      struct param_type
+      {
+ typedef binomial_distribution<_IntType> distribution_type;
+ friend class binomial_distribution<_IntType>;
+
+ param_type() : param_type(1) { }
+
+ explicit
+ param_type(_IntType __t, 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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      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;
+      };
+
+
+
+      binomial_distribution() : binomial_distribution(1) { }
+
+      explicit
+      binomial_distribution(_IntType __t, 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; }
+# 3910 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _IntType1,
+        typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::binomial_distribution<_IntType1>& __x);
+# 3926 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _IntType1,
+        typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::binomial_distribution<_IntType1>& __x);
+
+    private:
+      template<typename _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); }
+# 3968 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType = int>
+    class geometric_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+      "result_type must be an integral type");
+
+    public:
+
+      typedef _IntType result_type;
+
+
+      struct param_type
+      {
+ typedef geometric_distribution<_IntType> distribution_type;
+ friend class geometric_distribution<_IntType>;
+
+ param_type() : param_type(0.5) { }
+
+ explicit
+ param_type(double __p)
+ : _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ void
+ _M_initialize()
+ { _M_log_1_p = std::log(1.0 - _M_p); }
+
+ double _M_p;
+
+ double _M_log_1_p;
+      };
+
+
+
+      geometric_distribution() : geometric_distribution(0.5) { }
+
+      explicit
+      geometric_distribution(double __p)
+      : _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); }
+# 4149 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType,
+    typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const std::geometric_distribution<_IntType>& __x);
+# 4164 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType,
+    typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+        std::geometric_distribution<_IntType>& __x);
+# 4178 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType = int>
+    class negative_binomial_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+      "result_type must be an integral type");
+
+    public:
+
+      typedef _IntType result_type;
+
+
+      struct param_type
+      {
+ typedef negative_binomial_distribution<_IntType> distribution_type;
+
+ param_type() : param_type(1) { }
+
+ explicit
+ param_type(_IntType __k, 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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _IntType _M_k;
+ double _M_p;
+      };
+
+      negative_binomial_distribution() : negative_binomial_distribution(1) { }
+
+      explicit
+      negative_binomial_distribution(_IntType __k, 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; }
+# 4346 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::negative_binomial_distribution<_IntType1>& __x);
+# 4361 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::negative_binomial_distribution<_IntType1>& __x);
+
+    private:
+      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); }
+# 4409 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType = int>
+    class poisson_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+      "result_type must be an integral type");
+
+    public:
+
+      typedef _IntType result_type;
+
+
+      struct param_type
+      {
+ typedef poisson_distribution<_IntType> distribution_type;
+ friend class poisson_distribution<_IntType>;
+
+ param_type() : param_type(1.0) { }
+
+ explicit
+ param_type(double __mean)
+ : _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      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;
+
+      };
+
+
+
+      poisson_distribution() : poisson_distribution(1.0) { }
+
+      explicit
+      poisson_distribution(double __mean)
+      : _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; }
+# 4576 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::poisson_distribution<_IntType1>& __x);
+# 4591 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::poisson_distribution<_IntType1>& __x);
+
+    private:
+      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); }
+# 4635 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class exponential_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef exponential_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(1.0) { }
+
+ explicit
+ param_type(_RealType __lambda)
+ : _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_lambda;
+      };
+
+    public:
+
+
+
+
+      exponential_distribution() : exponential_distribution(1.0) { }
+
+
+
+
+
+      explicit
+      exponential_distribution(_RealType __lambda)
+      : _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); }
+# 4820 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const std::exponential_distribution<_RealType>& __x);
+# 4835 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+        std::exponential_distribution<_RealType>& __x);
+# 4850 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class weibull_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef weibull_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(1.0) { }
+
+ explicit
+ param_type(_RealType __a, _RealType __b = _RealType(1.0))
+ : _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_a;
+ _RealType _M_b;
+      };
+
+      weibull_distribution() : weibull_distribution(1.0) { }
+
+      explicit
+      weibull_distribution(_RealType __a, _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); }
+# 5030 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const std::weibull_distribution<_RealType>& __x);
+# 5045 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+        std::weibull_distribution<_RealType>& __x);
+# 5060 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class extreme_value_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be a floating point type");
+
+    public:
+
+      typedef _RealType result_type;
+
+
+      struct param_type
+      {
+ typedef extreme_value_distribution<_RealType> distribution_type;
+
+ param_type() : param_type(0.0) { }
+
+ explicit
+ param_type(_RealType __a, _RealType __b = _RealType(1.0))
+ : _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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ _RealType _M_a;
+ _RealType _M_b;
+      };
+
+      extreme_value_distribution() : extreme_value_distribution(0.0) { }
+
+      explicit
+      extreme_value_distribution(_RealType __a, _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); }
+# 5240 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const std::extreme_value_distribution<_RealType>& __x);
+# 5255 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+        std::extreme_value_distribution<_RealType>& __x);
+# 5267 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _IntType = int>
+    class discrete_distribution
+    {
+      static_assert(std::is_integral<_IntType>::value,
+      "result_type must be 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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      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; }
+# 5453 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::discrete_distribution<_IntType1>& __x);
+# 5469 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _IntType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::discrete_distribution<_IntType1>& __x);
+
+    private:
+      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); }
+# 5502 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class piecewise_constant_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be 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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ void
+ _M_initialize();
+
+ std::vector<_RealType> _M_int;
+ std::vector<double> _M_den;
+ std::vector<double> _M_cp;
+      };
+
+      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; }
+# 5724 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::piecewise_constant_distribution<_RealType1>& __x);
+# 5740 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::piecewise_constant_distribution<_RealType1>& __x);
+
+    private:
+      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); }
+# 5773 "/usr/include/c++/10.2.0/bits/random.h" 3
+  template<typename _RealType = double>
+    class piecewise_linear_distribution
+    {
+      static_assert(std::is_floating_point<_RealType>::value,
+      "result_type must be 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; }
+
+ friend bool
+ operator!=(const param_type& __p1, const param_type& __p2)
+ { return !(__p1 == __p2); }
+
+      private:
+ void
+ _M_initialize();
+
+ std::vector<_RealType> _M_int;
+ std::vector<double> _M_den;
+ std::vector<double> _M_cp;
+ std::vector<double> _M_m;
+      };
+
+      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; }
+# 5997 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_ostream<_CharT, _Traits>&
+ operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+     const std::piecewise_linear_distribution<_RealType1>& __x);
+# 6013 "/usr/include/c++/10.2.0/bits/random.h" 3
+      template<typename _RealType1, typename _CharT, typename _Traits>
+ friend std::basic_istream<_CharT, _Traits>&
+ operator>>(std::basic_istream<_CharT, _Traits>& __is,
+     std::piecewise_linear_distribution<_RealType1>& __x);
+
+    private:
+      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); }
+# 6054 "/usr/include/c++/10.2.0/bits/random.h" 3
+  class seed_seq
+  {
+  public:
+
+    typedef uint_least32_t result_type;
+
+
+    seed_seq() noexcept
+    : _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 noexcept
+    { return _M_v.size(); }
+
+    template<typename _OutputIterator>
+      void
+      param(_OutputIterator __dest) const
+      { std::copy(_M_v.begin(), _M_v.end(), __dest); }
+
+
+    seed_seq(const seed_seq&) = delete;
+    seed_seq& operator=(const seed_seq&) = delete;
+
+  private:
+    std::vector<result_type> _M_v;
+  };
+
+
+
+
+
+
+}
+# 50 "/usr/include/c++/10.2.0/random" 2 3
+# 1 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/opt_random.h" 1 3
+# 38 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/opt_random.h" 3
+       
+# 39 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/opt_random.h" 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 217 "/usr/include/c++/10.2.0/x86_64-pc-linux-gnu/bits/opt_random.h" 3
+
+}
+# 51 "/usr/include/c++/10.2.0/random" 2 3
+# 1 "/usr/include/c++/10.2.0/bits/random.tcc" 1 3
+# 33 "/usr/include/c++/10.2.0/bits/random.tcc" 3
+# 1 "/usr/include/c++/10.2.0/numeric" 1 3
+# 58 "/usr/include/c++/10.2.0/numeric" 3
+       
+# 59 "/usr/include/c++/10.2.0/numeric" 3
+
+
+
+# 1 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 1 3
+# 64 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+# 85 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+   
+    void
+    iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
+    {
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ {
+   *__first = __value;
+   ++__value;
+ }
+    }
+
+
+
+
+
+# 131 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _Tp>
+   
+    inline _Tp
+    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
+    {
+
+     
+      ;
+
+      for (; __first != __last; ++__first)
+ __init = __init + *__first;
+      return __init;
+    }
+# 158 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
+   
+    inline _Tp
+    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,
+        _BinaryOperation __binary_op)
+    {
+
+     
+      ;
+
+      for (; __first != __last; ++__first)
+ __init = __binary_op(__init, *__first);
+      return __init;
+    }
+# 187 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
+   
+    inline _Tp
+    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+    _InputIterator2 __first2, _Tp __init)
+    {
+
+     
+     
+      ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ __init = __init + (*__first1 * *__first2);
+      return __init;
+    }
+# 219 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
+    typename _BinaryOperation1, typename _BinaryOperation2>
+   
+    inline _Tp
+    inner_product(_InputIterator1 __first1, _InputIterator1 __last1,
+    _InputIterator2 __first2, _Tp __init,
+    _BinaryOperation1 __binary_op1,
+    _BinaryOperation2 __binary_op2)
+    {
+
+     
+     
+      ;
+
+      for (; __first1 != __last1; ++__first1, (void)++__first2)
+ __init = __binary_op1(__init,
+         __binary_op2(*__first1, *__first2));
+      return __init;
+    }
+# 253 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _OutputIterator>
+   
+    _OutputIterator
+    partial_sum(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   __value = __value + *__first;
+   *++__result = __value;
+ }
+      return ++__result;
+    }
+# 294 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryOperation>
+   
+    _OutputIterator
+    partial_sum(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   __value = __binary_op(__value, *__first);
+   *++__result = __value;
+ }
+      return ++__result;
+    }
+# 335 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _OutputIterator>
+   
+    _OutputIterator
+    adjacent_difference(_InputIterator __first,
+   _InputIterator __last, _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   _ValueType __tmp = *__first;
+   *++__result = __tmp - __value;
+   __value = std::move(__tmp);
+ }
+      return ++__result;
+    }
+# 378 "/usr/include/c++/10.2.0/bits/stl_numeric.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryOperation>
+   
+    _OutputIterator
+    adjacent_difference(_InputIterator __first, _InputIterator __last,
+   _OutputIterator __result, _BinaryOperation __binary_op)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type _ValueType;
+
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      _ValueType __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ {
+   _ValueType __tmp = *__first;
+   *++__result = __binary_op(__tmp, __value);
+   __value = std::move(__tmp);
+ }
+      return ++__result;
+    }
+
+
+
+
+
+
+}
+# 63 "/usr/include/c++/10.2.0/numeric" 2 3
+# 79 "/usr/include/c++/10.2.0/numeric" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+namespace __detail
+{
+
+  template<typename _Tp>
+    constexpr
+    enable_if_t<__and_<is_integral<_Tp>, is_signed<_Tp>>::value, _Tp>
+    __abs_integral(_Tp __val)
+    { return __val < 0 ? -__val : __val; }
+
+  template<typename _Tp>
+    constexpr
+    enable_if_t<__and_<is_integral<_Tp>, is_unsigned<_Tp>>::value, _Tp>
+    __abs_integral(_Tp __val)
+    { return __val; }
+
+  void __abs_integral(bool) = delete;
+
+  template<typename _Mn, typename _Nn>
+    constexpr common_type_t<_Mn, _Nn>
+    __gcd(_Mn __m, _Nn __n)
+    {
+      return __m == 0 ? __detail::__abs_integral(__n)
+ : __n == 0 ? __detail::__abs_integral(__m)
+ : __detail::__gcd(__n, __m % __n);
+    }
+
+
+  template<typename _Mn, typename _Nn>
+    constexpr common_type_t<_Mn, _Nn>
+    __lcm(_Mn __m, _Nn __n)
+    {
+      return (__m != 0 && __n != 0)
+ ? (__detail::__abs_integral(__m) / __detail::__gcd(__m, __n))
+   * __detail::__abs_integral(__n)
+ : 0;
+    }
+}
+# 158 "/usr/include/c++/10.2.0/numeric" 3
+
+}
+# 34 "/usr/include/c++/10.2.0/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>
+      auto
+      linear_congruential_engine<_UIntType, __a, __c, __m>::
+      seed(_Sseq& __q)
+      -> _If_seed_seq<_Sseq>
+      {
+ 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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_istream<_CharT, _Traits>::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>
+      auto
+      mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
+         __s, __b, __t, __c, __l, __f>::
+      seed(_Sseq& __q)
+      -> _If_seed_seq<_Sseq>
+      {
+ 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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_istream<_CharT, _Traits>::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>
+      auto
+      subtract_with_carry_engine<_UIntType, __w, __s, __r>::
+      seed(_Sseq& __q)
+      -> _If_seed_seq<_Sseq>
+      {
+ 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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_istream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_istream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_istream<_CharT, _Traits>::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, typename _CharT, typename _Traits>
+    std::basic_ostream<_CharT, _Traits>&
+    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
+        const uniform_int_distribution<_IntType>& __x)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type
+ = typename uniform_int_distribution<_IntType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _IntType __a, __b;
+      if (__is >> __a >> __b)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type
+ = typename uniform_real_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      _RealType __a, __b;
+      if (__is >> __a >> __b)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type = typename geometric_distribution<_IntType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      double __p;
+      if (__is >> __p)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type
+ = typename negative_binomial_distribution<_IntType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      _IntType __k;
+      double __p;
+      if (__is >> __k >> __p >> __x._M_gd)
+ __x.param(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<double>(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);
+      }
+# 1265 "/usr/include/c++/10.2.0/bits/random.tcc" 3
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename poisson_distribution<_IntType>::result_type
+      poisson_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+   const param_type& __param)
+      {
+ __detail::_Adaptor<_UniformRandomNumberGenerator, double>
+   __aurng(__urng);
+
+ if (__param.mean() >= 12)
+   {
+     double __x;
+
+
+     const double __naf =
+       (1 - std::numeric_limits<double>::epsilon()) / 2;
+     const double __thr =
+       std::numeric_limits<_IntType>::max() + __naf;
+
+     const double __m = std::floor(__param.mean());
+
+     const double __spi_2 = 1.2533141373155002512078826424055226L;
+     const double __c1 = __param._M_sm * __spi_2;
+     const double __c2 = __param._M_c2b + __c1;
+     const double __c3 = __c2 + 1;
+     const double __c4 = __c3 + 1;
+
+     const double __178 = 0.0128205128205128205128205128205128L;
+
+     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;
+
+      __w = __178;
+    }
+  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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type = typename poisson_distribution<_IntType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::skipws);
+
+      double __mean;
+      if (__is >> __mean >> __x._M_nd)
+ __x.param(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<double>(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<double>(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;
+      }
+# 1520 "/usr/include/c++/10.2.0/bits/random.tcc" 3
+  template<typename _IntType>
+    template<typename _UniformRandomNumberGenerator>
+      typename binomial_distribution<_IntType>::result_type
+      binomial_distribution<_IntType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+   const param_type& __param)
+      {
+ result_type __ret;
+ const _IntType __t = __param.t();
+ const double __p = __param.p();
+ const double __p12 = __p <= 0.5 ? __p : 1.0 - __p;
+ __detail::_Adaptor<_UniformRandomNumberGenerator, double>
+   __aurng(__urng);
+
+
+ if (!__param._M_easy)
+   {
+     double __x;
+
+
+     const double __naf =
+       (1 - std::numeric_limits<double>::epsilon()) / 2;
+     const double __thr =
+       std::numeric_limits<_IntType>::max() + __naf;
+
+     const double __np = std::floor(__t * __p12);
+
+
+     const double __spi_2 = 1.2533141373155002512078826424055226L;
+     const double __a1 = __param._M_a1;
+     const double __a12 = __a1 + __param._M_s2 * __spi_2;
+     const double __a123 = __param._M_a123;
+     const double __s1s = __param._M_s1 * __param._M_s1;
+     const double __s2s = __param._M_s2 * __param._M_s2;
+
+     bool __reject;
+     do
+       {
+  const double __u = __param._M_s * __aurng();
+
+  double __v;
+
+  if (__u <= __a1)
+    {
+      const double __n = _M_nd(__urng);
+      const double __y = __param._M_s1 * std::abs(__n);
+      __reject = __y >= __param._M_d1;
+      if (!__reject)
+        {
+   const double __e = -std::log(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type = typename binomial_distribution<_IntType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _IntType __t;
+      double __p;
+      if (__is >> __t >> __p >> __x._M_nd)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type
+ = typename exponential_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __lambda;
+      if (__is >> __lambda)
+ __x.param(param_type(__lambda));
+
+      __is.flags(__flags);
+      return __is;
+    }
+# 1766 "/usr/include/c++/10.2.0/bits/random.tcc" 3
+  template<typename _RealType>
+    template<typename _UniformRandomNumberGenerator>
+      typename normal_distribution<_RealType>::result_type
+      normal_distribution<_RealType>::
+      operator()(_UniformRandomNumberGenerator& __urng,
+   const param_type& __param)
+      {
+ result_type __ret;
+ __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
+   __aurng(__urng);
+
+ if (_M_saved_available)
+   {
+     _M_saved_available = false;
+     __ret = _M_saved;
+   }
+ else
+   {
+     result_type __x, __y, __r2;
+     do
+       {
+  __x = result_type(2.0) * __aurng() - 1.0;
+  __y = result_type(2.0) * __aurng() - 1.0;
+  __r2 = __x * __x + __y * __y;
+       }
+     while (__r2 > 1.0 || __r2 == 0.0);
+
+     const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
+     _M_saved = __x * __mult;
+     _M_saved_available = true;
+     __ret = __y * __mult;
+   }
+
+ __ret = __ret * __param.stddev() + __param.mean();
+ return __ret;
+      }
+
+  template<typename _RealType>
+    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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type = typename normal_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      double __mean, __stddev;
+      bool __saved_avail;
+      if (__is >> __mean >> __stddev >> __saved_avail)
+ {
+   if (__saved_avail && (__is >> __x._M_saved))
+     {
+       __x._M_saved_available = __saved_avail;
+       __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type
+ = typename lognormal_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __m, __s;
+      if (__is >> __m >> __s >> __x._M_nd)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type
+ = typename chi_squared_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __n;
+      if (__is >> __n >> __x._M_gd)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type = typename cauchy_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __a, __b;
+      if (__is >> __a >> __b)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type
+ = typename fisher_f_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __m, __n;
+      if (__is >> __m >> __n >> __x._M_gd_x >> __x._M_gd_y)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type
+ = typename student_t_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __n;
+      if (__is >> __n >> __x._M_nd >> __x._M_gd)
+ __x.param(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.0331 * __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.0331 * __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.0331 * __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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type = typename gamma_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __alpha_val, __beta_val;
+      if (__is >> __alpha_val >> __beta_val >> __x._M_nd)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type = typename weibull_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __a, __b;
+      if (__is >> __a >> __b)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using param_type
+ = typename extreme_value_distribution<_RealType>::param_type;
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      _RealType __a, __b;
+      if (__is >> __a >> __b)
+ __x.param(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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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;
+    }
+
+namespace __detail
+{
+  template<typename _ValT, typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    __extract_params(basic_istream<_CharT, _Traits>& __is,
+       vector<_ValT>& __vals, size_t __n)
+    {
+      __vals.reserve(__n);
+      while (__n--)
+ {
+   _ValT __val;
+   if (__is >> __val)
+     __vals.push_back(__val);
+   else
+     break;
+ }
+      return __is;
+    }
+}
+
+  template<typename _IntType, typename _CharT, typename _Traits>
+    std::basic_istream<_CharT, _Traits>&
+    operator>>(std::basic_istream<_CharT, _Traits>& __is,
+        discrete_distribution<_IntType>& __x)
+    {
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      size_t __n;
+      if (__is >> __n)
+ {
+   std::vector<double> __prob_vec;
+   if (__detail::__extract_params(__is, __prob_vec, __n))
+     __x.param({__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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      size_t __n;
+      if (__is >> __n)
+ {
+   std::vector<_RealType> __int_vec;
+   if (__detail::__extract_params(__is, __int_vec, __n + 1))
+     {
+       std::vector<double> __den_vec;
+       if (__detail::__extract_params(__is, __den_vec, __n))
+  {
+    __x.param({ __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)
+    {
+      using __ios_base = typename basic_ostream<_CharT, _Traits>::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)
+    {
+      using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
+
+      const typename __ios_base::fmtflags __flags = __is.flags();
+      __is.flags(__ios_base::dec | __ios_base::skipws);
+
+      size_t __n;
+      if (__is >> __n)
+ {
+   vector<_RealType> __int_vec;
+   if (__detail::__extract_params(__is, __int_vec, __n + 1))
+     {
+       vector<double> __den_vec;
+       if (__detail::__extract_params(__is, __den_vec, __n + 1))
+  {
+    __x.param({ __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 must be 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);
+      const size_t __m = std::max<size_t>(1UL,
+       (__b + __log2r - 1UL) / __log2r);
+      _RealType __ret;
+      _RealType __sum = _RealType(0);
+      _RealType __tmp = _RealType(1);
+      for (size_t __k = __m; __k != 0; --__k)
+ {
+   __sum += _RealType(__urng() - __urng.min()) * __tmp;
+   __tmp *= __r;
+ }
+      __ret = __sum / __tmp;
+      if (__builtin_expect(__ret >= _RealType(1), 0))
+ {
+
+   __ret = std::nextafter(_RealType(1), _RealType(0));
+
+
+
+
+ }
+      return __ret;
+    }
+
+
+}
+# 52 "/usr/include/c++/10.2.0/random" 2 3
+# 21 "/home/ted/dev/openrct2/src/openrct2/scenario/../core/Random.hpp" 2
+
+
+
+# 23 "/home/ted/dev/openrct2/src/openrct2/scenario/../core/Random.hpp"
+namespace Random
+{
+    using namespace Numerics;
+
+
+
+
+    template<size_t _TNum = 0> class FixedSeedSequence
+    {
+    public:
+        using result_type = uint32_t;
+
+        static constexpr size_t N = _TNum;
+        static constexpr result_type default_seed = 0x1234567F;
+
+        explicit FixedSeedSequence()
+        {
+            std::fill(v.begin(), v.end(), default_seed);
+        }
+
+        template<
+            typename... _TTypes, typename std::enable_if<sizeof...(_TTypes) == N, int>::type = 0,
+            typename std::enable_if<Meta::all_convertible<result_type, _TTypes...>::value, int>::type = 0>
+        explicit FixedSeedSequence(_TTypes... s)
+            : v{ static_cast<result_type>(s)... }
+        {
+        }
+
+        template<typename _TIt, typename = decltype(*std::declval<_TIt&>(), ++std::declval<_TIt&>(), void())>
+        explicit FixedSeedSequence(_TIt begin, _TIt end)
+        {
+            std::copy(begin, end, v.begin());
+        }
+
+        template<typename _TType>
+        explicit FixedSeedSequence(std::initializer_list<_TType> il)
+            : FixedSeedSequence(il.begin(), il.end())
+        {
+        }
+
+        template<typename _TIt> void generate(_TIt begin, _TIt end) const
+        {
+            std::copy_n(v.begin(), std::min(static_cast<size_t>(end - begin), N), begin);
+        }
+
+        constexpr size_t size() const
+        {
+            return N;
+        }
+
+        template<typename _TIt> constexpr void param(_TIt ob) const
+        {
+            std::copy(v.begin(), v.end(), ob);
+        }
+
+    protected:
+        std::array<result_type, N> v;
+    };
+
+    template<typename _TUIntType> struct RotateEngineState
+    {
+        using value_type = _TUIntType;
+
+        value_type s0;
+        value_type s1;
+    };
+
+
+
+
+
+    template<typename _TUIntType, _TUIntType _TX, size_t _TR1, size_t _TR2>
+    class RotateEngine : protected RotateEngineState<_TUIntType>
+    {
+        static_assert(std::is_unsigned<_TUIntType>::value, "Type must be unsigned integral.");
+
+        using RotateEngineState<_TUIntType>::s0;
+        using RotateEngineState<_TUIntType>::s1;
+
+    public:
+        using result_type = _TUIntType;
+        using state_type = RotateEngineState<_TUIntType>;
+
+        static constexpr result_type x = _TX;
+        static constexpr size_t r1 = _TR1;
+        static constexpr size_t r2 = _TR2;
+        static constexpr result_type default_seed = 1;
+
+        static constexpr result_type min()
+        {
+            return std::numeric_limits<result_type>::min();
+        }
+
+        static constexpr result_type max()
+        {
+            return std::numeric_limits<result_type>::max();
+        }
+
+        explicit RotateEngine(result_type seed_value = default_seed)
+        {
+            seed(seed_value);
+        }
+
+        RotateEngine(RotateEngine& r)
+        {
+            s0 = r.s0;
+            s1 = r.s1;
+        }
+
+        template<typename _TSseq, typename = typename std::enable_if<!std::is_same<_TSseq, RotateEngine>::value>::type>
+        explicit RotateEngine(_TSseq& seed_seq)
+        {
+            seed(seed_seq);
+        }
+
+        void seed(result_type s = default_seed)
+        {
+            s0 = s;
+            s1 = s;
+        }
+
+        template<typename _TSseq> typename std::enable_if<std::is_class<_TSseq>::value, void>::type seed(_TSseq& seed_seq)
+        {
+            std::array<result_type, 2> s;
+            seed_seq.generate(s.begin(), s.end());
+            s0 = s[0];
+            s1 = s[1];
+        }
+
+        void discard(size_t n)
+        {
+            for (; n > 0; n--)
+                (*this)();
+        }
+        result_type operator()()
+        {
+            auto s0z = s0;
+            s0 += ror(s1 ^ x, r1);
+            s1 = ror(s0z, r2);
+            return s1;
+        }
+
+        const state_type& state() const
+        {
+            return *this;
+        }
+
+        friend bool operator==(const RotateEngine& lhs, const RotateEngine& rhs)
+        {
+            return lhs.s0 == rhs.s0 && lhs.s1 == rhs.s1;
+        }
+
+        friend std::ostream& operator<<(std::ostream& os, const RotateEngine& e)
+        {
+            os << e.s0 << ' ' << e.s1;
+            return os;
+        }
+
+        friend std::istream& operator>>(std::istream& is, RotateEngine& e)
+        {
+            is >> e.s0;
+            is >> e.s1;
+            return is;
+        }
+    };
+
+    namespace Rct2
+    {
+        using Engine = RotateEngine<uint32_t, 0x1234567F, 7, 3>;
+        using Seed = FixedSeedSequence<2>;
+        using State = Engine::state_type;
+    }
+}
+# 15 "/home/ted/dev/openrct2/src/openrct2/scenario/Scenario.h" 2
+
+
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../ride/Ride.h" 1
+# 21 "/home/ted/dev/openrct2/src/openrct2/scenario/Scenario.h" 2
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/Climate.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/Climate.h"
+       
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/../common.h" 1
+# 13 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/Climate.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/../drawing/Drawing.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/Climate.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/../util/Util.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/Climate.h" 2
+
+enum class ClimateType : uint8_t
+{
+    CoolAndWet,
+    Warm,
+    HotAndDry,
+    Cold,
+    Count
+};
+
+enum class WeatherType : uint8_t
+{
+    Sunny,
+    PartiallyCloudy,
+    Cloudy,
+    Rain,
+    HeavyRain,
+    Thunder,
+    Snow,
+    HeavySnow,
+    Blizzard,
+    Count
+};
+
+enum class WeatherEffectType : uint8_t
+{
+    None,
+    Rain,
+    Storm,
+    Snow,
+    Blizzard,
+};
+
+enum class WeatherLevel
+{
+    None,
+    Light,
+    Heavy,
+};
+
+struct WeatherState
+{
+    int8_t TemperatureDelta;
+    WeatherEffectType EffectLevel;
+    int8_t GloomLevel;
+    WeatherLevel Level;
+    uint32_t SpriteId;
+};
+
+struct ClimateState
+{
+    WeatherType Weather;
+    int8_t Temperature;
+    WeatherEffectType WeatherEffect;
+    uint8_t WeatherGloom;
+    WeatherLevel Level;
+};
+
+extern ClimateType gClimate;
+extern ClimateState gClimateCurrent;
+extern ClimateState gClimateNext;
+extern uint16_t gClimateUpdateTimer;
+extern uint16_t gClimateLightningFlash;
+
+int32_t climate_celsius_to_fahrenheit(int32_t celsius);
+void climate_reset(ClimateType climate);
+void climate_update();
+void climate_update_sound();
+void climate_force_weather(WeatherType weather);
+
+bool climate_is_raining();
+bool climate_is_snowing();
+bool WeatherIsDry(WeatherType);
+FilterPaletteID climate_get_weather_gloom_palette_id(const ClimateState& state);
+uint32_t climate_get_weather_sprite_id(const ClimateState& state);
+# 24 "/home/ted/dev/openrct2/src/openrct2/scenario/Scenario.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/EntityList.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/EntityList.h"
+       
+
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/Entity.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/Entity.h"
+       
+
+
+
+constexpr uint16_t MAX_ENTITIES = 65535;
+
+SpriteBase* try_get_sprite(size_t spriteIndex);
+SpriteBase* get_sprite(size_t sprite_idx);
+
+template<typename T = SpriteBase> T* GetEntity(size_t sprite_idx)
+{
+    auto spr = get_sprite(sprite_idx);
+    return spr != nullptr ? spr->As<T>() : nullptr;
+}
+
+template<typename T = SpriteBase> T* TryGetEntity(size_t sprite_idx)
+{
+    auto spr = try_get_sprite(sprite_idx);
+    return spr != nullptr ? spr->As<T>() : nullptr;
+}
+# 15 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/EntityList.h" 2
+
+
+
+
+
+
+enum class EntityListId : uint8_t
+{
+    Count = 6,
+};
+
+const std::list<uint16_t>& GetEntityList(const EntityType id);
+
+uint16_t GetEntityListCount(EntityType list);
+uint16_t GetMiscEntityCount();
+uint16_t GetNumFreeEntities();
+const std::vector<uint16_t>& GetEntityTileList(const CoordsXY& spritePos);
+
+template<typename T> class EntityTileIterator
+{
+private:
+    std::vector<uint16_t>::const_iterator iter;
+    std::vector<uint16_t>::const_iterator end;
+    T* Entity = nullptr;
+
+public:
+    EntityTileIterator(std::vector<uint16_t>::const_iterator _iter, std::vector<uint16_t>::const_iterator _end)
+        : iter(_iter)
+        , end(_end)
+    {
+        ++(*this);
+    }
+    EntityTileIterator& operator++()
+    {
+        Entity = nullptr;
+
+        while (iter != end && Entity == nullptr)
+        {
+            Entity = GetEntity<T>(*iter++);
+        }
+        return *this;
+    }
+
+    EntityTileIterator operator++(int)
+    {
+        EntityTileIterator retval = *this;
+        ++(*this);
+        return *iter;
+    }
+    bool operator==(EntityTileIterator other) const
+    {
+        return Entity == other.Entity;
+    }
+    bool operator!=(EntityTileIterator other) const
+    {
+        return !(*this == other);
+    }
+    T* operator*()
+    {
+        return Entity;
+    }
+
+    using difference_type = std::ptrdiff_t;
+    using value_type = T;
+    using pointer = const T*;
+    using reference = const T&;
+    using iterator_category = std::forward_iterator_tag;
+};
+
+template<typename T = SpriteBase> class EntityTileList
+{
+private:
+    const std::vector<uint16_t>& vec;
+
+public:
+    EntityTileList(const CoordsXY& loc)
+        : vec(GetEntityTileList(loc))
+    {
+    }
+
+    EntityTileIterator<T> begin()
+    {
+        return EntityTileIterator<T>(std::begin(vec), std::end(vec));
+    }
+    EntityTileIterator<T> end()
+    {
+        return EntityTileIterator<T>(std::end(vec), std::end(vec));
+    }
+};
+
+template<typename T> class EntityListIterator
+{
+private:
+    std::list<uint16_t>::const_iterator iter;
+    std::list<uint16_t>::const_iterator end;
+    T* Entity = nullptr;
+
+public:
+    EntityListIterator(std::list<uint16_t>::const_iterator _iter, std::list<uint16_t>::const_iterator _end)
+        : iter(_iter)
+        , end(_end)
+    {
+        ++(*this);
+    }
+    EntityListIterator& operator++()
+    {
+        Entity = nullptr;
+
+        while (iter != end && Entity == nullptr)
+        {
+            Entity = GetEntity<T>(*iter++);
+        }
+        return *this;
+    }
+
+    EntityListIterator operator++(int)
+    {
+        EntityListIterator retval = *this;
+        ++(*this);
+        return *iter;
+    }
+    bool operator==(EntityListIterator other) const
+    {
+        return Entity == other.Entity;
+    }
+    bool operator!=(EntityListIterator other) const
+    {
+        return !(*this == other);
+    }
+    T* operator*()
+    {
+        return Entity;
+    }
+
+    using difference_type = std::ptrdiff_t;
+    using value_type = T;
+    using pointer = const T*;
+    using reference = const T&;
+    using iterator_category = std::forward_iterator_tag;
+};
+
+template<typename T = SpriteBase> class EntityList
+{
+private:
+    using EntityListIterator_t = EntityListIterator<T>;
+    const std::list<uint16_t>& vec;
+
+public:
+    EntityList()
+        : vec(GetEntityList(T::cEntityType))
+    {
+    }
+
+    EntityListIterator_t begin()
+    {
+        return EntityListIterator_t(std::cbegin(vec), std::cend(vec));
+    }
+    EntityListIterator_t end()
+    {
+        return EntityListIterator_t(std::cend(vec), std::cend(vec));
+    }
+};
+# 25 "/home/ted/dev/openrct2/src/openrct2/scenario/Scenario.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/Map.h" 1
+# 26 "/home/ted/dev/openrct2/src/openrct2/scenario/Scenario.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/MapAnimation.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/scenario/../world/MapAnimation.h"
+       
+
+
+
+
+
+
+struct MapAnimation
+{
+    uint8_t type{};
+    CoordsXYZ location{};
+};
+
+enum
+{
+    MAP_ANIMATION_TYPE_RIDE_ENTRANCE,
+    MAP_ANIMATION_TYPE_QUEUE_BANNER,
+    MAP_ANIMATION_TYPE_SMALL_SCENERY,
+    MAP_ANIMATION_TYPE_PARK_ENTRANCE,
+    MAP_ANIMATION_TYPE_TRACK_WATERFALL,
+    MAP_ANIMATION_TYPE_TRACK_RAPIDS,
+    MAP_ANIMATION_TYPE_TRACK_ONRIDEPHOTO,
+    MAP_ANIMATION_TYPE_TRACK_WHIRLPOOL,
+    MAP_ANIMATION_TYPE_TRACK_SPINNINGTUNNEL,
+    MAP_ANIMATION_TYPE_REMOVE,
+    MAP_ANIMATION_TYPE_BANNER,
+    MAP_ANIMATION_TYPE_LARGE_SCENERY,
+    MAP_ANIMATION_TYPE_WALL_DOOR,
+    MAP_ANIMATION_TYPE_WALL,
+    MAP_ANIMATION_TYPE_COUNT
+};
+
+void map_animation_create(int32_t type, const CoordsXYZ& loc);
+void map_animation_invalidate_all();
+const std::vector<MapAnimation>& GetMapAnimations();
+void AutoCreateMapAnimations();
+# 27 "/home/ted/dev/openrct2/src/openrct2/scenario/Scenario.h" 2
+
+using random_engine_t = Random::Rct2::Engine;
+
+enum class EditorStep : uint8_t;
+
+struct ParkLoadResult;
+
+#pragma pack(push, 1)
+
+
+
+
+struct rct_s6_header
+{
+    uint8_t type;
+    uint8_t classic_flag;
+    uint16_t num_packed_objects;
+    uint32_t version;
+    uint32_t magic_number;
+    uint8_t pad_0C[0x14];
+};
+static_assert(sizeof(rct_s6_header) == (0x20), "Improper struct size");
+
+
+
+
+
+struct rct_s6_info
+{
+    EditorStep editor_step;
+    uint8_t category;
+    uint8_t objective_type;
+    uint8_t objective_arg_1;
+    int32_t objective_arg_2;
+    int16_t objective_arg_3;
+    uint8_t pad_00A[0x3E];
+    char name[64];
+    char details[256];
+    rct_object_entry entry;
+};
+static_assert(sizeof(rct_s6_info) == (0x198), "Improper struct size");
+
+enum class ScenarioSource : uint8_t
+{
+    RCT1,
+    RCT1_AA,
+    RCT1_LL,
+    RCT2,
+    RCT2_WW,
+    RCT2_TT,
+    Real,
+    Other
+};
+
+struct rct_stex_entry
+{
+    rct_string_id scenario_name;
+    rct_string_id park_name;
+    rct_string_id details;
+    uint8_t var_06;
+};
+static_assert(sizeof(rct_stex_entry) == (7), "Improper struct size");
+
+
+struct rct_s6_data
+{
+
+    rct_s6_header header;
+
+
+    rct_s6_info info;
+
+
+
+
+
+    rct_object_entry objects[RCT2_OBJECT_ENTRY_COUNT];
+
+
+    uint16_t elapsed_months;
+    uint16_t current_day;
+    uint32_t scenario_ticks;
+    uint32_t scenario_srand_0;
+    uint32_t scenario_srand_1;
+
+
+    RCT12TileElement tile_elements[RCT2_MAX_TILE_ELEMENTS];
+
+
+    uint32_t next_free_tile_element_pointer_index;
+    RCT2Sprite sprites[RCT2_MAX_SPRITES];
+    uint16_t sprite_lists_head[static_cast<uint8_t>(EntityListId::Count)];
+    uint16_t sprite_lists_count[static_cast<uint8_t>(EntityListId::Count)];
+    rct_string_id park_name;
+    uint8_t pad_013573D6[2];
+    uint32_t park_name_args;
+    money32 initial_cash;
+    money32 current_loan;
+    uint32_t park_flags;
+    money16 park_entrance_fee;
+    uint16_t rct1_park_entrance_x;
+    uint16_t rct1_park_entrance_y;
+    uint8_t pad_013573EE[2];
+    uint8_t rct1_park_entrance_z;
+    uint8_t pad_013573F1;
+    rct12_peep_spawn peep_spawns[RCT12_MAX_PEEP_SPAWNS];
+    uint8_t guest_count_change_modifier;
+    uint8_t current_research_level;
+    uint8_t pad_01357400[4];
+    uint32_t researched_ride_types[RCT2_MAX_RESEARCHED_RIDE_TYPE_QUADS];
+    uint32_t researched_ride_entries[RCT2_MAX_RESEARCHED_RIDE_ENTRY_QUADS];
+    uint32_t researched_track_types_a[128];
+    uint32_t researched_track_types_b[128];
+
+
+    uint16_t guests_in_park;
+    uint16_t guests_heading_for_park;
+
+
+    money32 expenditure_table[RCT12_EXPENDITURE_TABLE_MONTH_COUNT][RCT12_EXPENDITURE_TYPE_COUNT];
+
+
+    uint16_t last_guests_in_park;
+    uint8_t pad_01357BCA[3];
+    uint8_t handyman_colour;
+    uint8_t mechanic_colour;
+    uint8_t security_colour;
+
+
+    uint32_t researched_scenery_items[RCT2_MAX_RESEARCHED_SCENERY_ITEM_QUADS];
+
+
+    uint16_t park_rating;
+
+
+    uint8_t park_rating_history[32];
+    uint8_t guests_in_park_history[32];
+
+
+    uint8_t active_research_types;
+    uint8_t research_progress_stage;
+    uint32_t last_researched_item_subject;
+    uint8_t pad_01357CF8[1000];
+    uint32_t next_research_item;
+    uint16_t research_progress;
+    uint8_t next_research_category;
+    uint8_t next_research_expected_day;
+    uint8_t next_research_expected_month;
+    uint8_t guest_initial_happiness;
+    uint16_t park_size;
+    uint16_t guest_generation_probability;
+    uint16_t total_ride_value_for_money;
+    money32 maximum_loan;
+    money16 guest_initial_cash;
+    uint8_t guest_initial_hunger;
+    uint8_t guest_initial_thirst;
+    uint8_t objective_type;
+    uint8_t objective_year;
+    uint8_t pad_013580FA[2];
+    money32 objective_currency;
+    uint16_t objective_guests;
+    uint8_t campaign_weeks_left[20];
+    uint8_t campaign_ride_index[22];
+
+
+    money32 balance_history[RCT12_FINANCE_GRAPH_SIZE];
+
+
+    money32 current_expenditure;
+    money32 current_profit;
+    uint32_t weekly_profit_average_dividend;
+    uint16_t weekly_profit_average_divisor;
+    uint8_t pad_0135833A[2];
+
+
+    money32 weekly_profit_history[RCT12_FINANCE_GRAPH_SIZE];
+
+
+    money32 park_value;
+
+
+    money32 park_value_history[RCT12_FINANCE_GRAPH_SIZE];
+
+
+    money32 completed_company_value;
+    uint32_t total_admissions;
+    money32 income_from_admissions;
+    money32 company_value;
+    uint8_t peep_warning_throttle[16];
+    rct12_award awards[RCT12_MAX_AWARDS];
+    money16 land_price;
+    money16 construction_rights_price;
+    uint16_t word_01358774;
+    uint8_t pad_01358776[2];
+    uint32_t cd_key;
+    uint8_t pad_0135877C[64];
+    uint32_t game_version_number;
+    money32 completed_company_value_record;
+    uint32_t loan_hash;
+    uint16_t ride_count;
+    uint8_t pad_013587CA[6];
+    money32 historical_profit;
+    uint8_t pad_013587D4[4];
+    char scenario_completed_name[32];
+    money32 cash;
+    uint8_t pad_013587FC[50];
+    uint16_t park_rating_casualty_penalty;
+    uint16_t map_size_units;
+    uint16_t map_size_minus_2;
+    uint16_t map_size;
+    uint16_t map_max_xy;
+    uint32_t same_price_throughout;
+    uint16_t suggested_max_guests;
+    uint16_t park_rating_warning_days;
+    uint8_t last_entrance_style;
+    uint8_t rct1_water_colour;
+    uint8_t pad_01358842[2];
+    RCT12ResearchItem research_items[500];
+    uint16_t map_base_z;
+    char scenario_name[64];
+    char scenario_description[256];
+    uint8_t current_interest_rate;
+    uint8_t pad_0135934B;
+    uint32_t same_price_throughout_extended;
+    int16_t park_entrance_x[RCT12_MAX_PARK_ENTRANCES];
+    int16_t park_entrance_y[RCT12_MAX_PARK_ENTRANCES];
+    int16_t park_entrance_z[RCT12_MAX_PARK_ENTRANCES];
+    uint8_t park_entrance_direction[RCT12_MAX_PARK_ENTRANCES];
+    char scenario_filename[256];
+    uint8_t saved_expansion_pack_names[3256];
+    RCT12Banner banners[RCT2_MAX_BANNERS_IN_PARK];
+    char custom_strings[RCT12_MAX_USER_STRINGS][RCT12_USER_STRING_MAX_LENGTH];
+    uint32_t game_ticks_1;
+    rct2_ride rides[RCT12_MAX_RIDES_IN_PARK];
+    uint16_t saved_age;
+    int16_t saved_view_x;
+    int16_t saved_view_y;
+    uint8_t saved_view_zoom;
+    uint8_t saved_view_rotation;
+    RCT12MapAnimation map_animations[RCT2_MAX_ANIMATED_OBJECTS];
+    uint16_t num_map_animations;
+    uint8_t pad_0138B582[2];
+    RCT2RideRatingCalculationData ride_ratings_calc_data;
+    uint8_t pad_0138B5D0[60];
+    RCT12RideMeasurement ride_measurements[8];
+    uint32_t next_guest_index;
+    uint16_t grass_and_scenery_tilepos;
+    uint32_t patrol_areas[(RCT2_MAX_STAFF + RCT12_STAFF_TYPE_COUNT) * RCT12_PATROL_AREA_SIZE];
+    uint8_t staff_modes[RCT2_MAX_STAFF + RCT12_STAFF_TYPE_COUNT];
+    uint8_t pad_13CA73E;
+    uint8_t pad_13CA73F;
+    uint8_t byte_13CA740;
+    uint8_t pad_13CA741;
+    uint8_t byte_13CA742[4];
+    uint8_t climate;
+    uint8_t pad_013CA747;
+    uint16_t climate_update_timer;
+    uint8_t current_weather;
+    uint8_t next_weather;
+    uint8_t temperature;
+    uint8_t next_temperature;
+    uint8_t current_weather_effect;
+    uint8_t next_weather_effect;
+    uint8_t current_weather_gloom;
+    uint8_t next_weather_gloom;
+    uint8_t current_weather_level;
+    uint8_t next_weather_level;
+    rct12_news_item news_items[RCT12_MAX_NEWS_ITEMS];
+    char rct1_scenario_name[62];
+    uint16_t rct1_scenario_slot_index;
+    uint32_t rct1_scenario_flags;
+    uint16_t wide_path_tile_loop_x;
+    uint16_t wide_path_tile_loop_y;
+    uint8_t pad_13CE778[434];
+};
+static_assert(sizeof(rct_s6_data) == (0x46b44a), "Improper struct size");
+#pragma pack(pop)
+
+enum
+{
+    SCENARIO_FLAGS_VISIBLE = (1 << 0),
+    SCENARIO_FLAGS_COMPLETED = (1 << 1),
+    SCENARIO_FLAGS_SIXFLAGS = (1 << 2)
+};
+
+enum
+{
+    S6_TYPE_SAVEDGAME,
+    S6_TYPE_SCENARIO
+};
+
+
+
+
+enum SCENARIO_CATEGORY
+{
+
+    SCENARIO_CATEGORY_BEGINNER,
+    SCENARIO_CATEGORY_CHALLENGING,
+    SCENARIO_CATEGORY_EXPERT,
+    SCENARIO_CATEGORY_REAL,
+    SCENARIO_CATEGORY_OTHER,
+
+
+    SCENARIO_CATEGORY_DLC,
+    SCENARIO_CATEGORY_BUILD_YOUR_OWN,
+
+    SCENARIO_CATEGORY_COUNT
+};
+
+enum
+{
+    OBJECTIVE_NONE,
+    OBJECTIVE_GUESTS_BY,
+    OBJECTIVE_PARK_VALUE_BY,
+    OBJECTIVE_HAVE_FUN,
+    OBJECTIVE_BUILD_THE_BEST,
+    OBJECTIVE_10_ROLLERCOASTERS,
+    OBJECTIVE_GUESTS_AND_RATING,
+    OBJECTIVE_MONTHLY_RIDE_INCOME,
+    OBJECTIVE_10_ROLLERCOASTERS_LENGTH,
+    OBJECTIVE_FINISH_5_ROLLERCOASTERS,
+    OBJECTIVE_REPAY_LOAN_AND_PARK_VALUE,
+    OBJECTIVE_MONTHLY_FOOD_INCOME,
+
+    OBJECTIVE_COUNT
+};
+
+bool ObjectiveNeedsMoney(const uint8_t objective);
+
+enum class ObjectiveStatus : uint8_t
+{
+    Undecided,
+    Success,
+    Failure,
+};
+
+struct Objective
+{
+    uint8_t Type;
+    uint8_t Year;
+    union
+    {
+        uint16_t NumGuests;
+        rct_string_id RideId;
+        uint16_t MinimumLength;
+    };
+    union
+    {
+        money32 Currency;
+        uint16_t MinimumExcitement;
+    };
+
+    bool NeedsMoney() const
+    {
+        return ObjectiveNeedsMoney(Type);
+    }
+
+    bool IsValid(bool useMoney, bool canAskMoneyForRides) const
+    {
+        const bool objectiveAllowedByMoneyUsage = useMoney || !NeedsMoney();
+
+        const bool objectiveAllowedByPaymentSettings = (Type != OBJECTIVE_MONTHLY_RIDE_INCOME) || canAskMoneyForRides;
+        return objectiveAllowedByMoneyUsage && objectiveAllowedByPaymentSettings;
+    }
+
+    ObjectiveStatus Check() const;
+
+private:
+    ObjectiveStatus CheckGuestsBy() const;
+    ObjectiveStatus CheckParkValueBy() const;
+    ObjectiveStatus Check10RollerCoasters() const;
+    ObjectiveStatus CheckGuestsAndRating() const;
+    ObjectiveStatus CheckMonthlyRideIncome() const;
+    ObjectiveStatus Check10RollerCoastersLength() const;
+    ObjectiveStatus CheckFinish5RollerCoasters() const;
+    ObjectiveStatus CheckRepayLoanAndParkValue() const;
+    ObjectiveStatus CheckMonthlyFoodIncome() const;
+};
+
+enum
+{
+    SCENARIO_SELECT_MODE_DIFFICULTY,
+    SCENARIO_SELECT_MODE_ORIGIN,
+};
+
+enum
+{
+    AUTOSAVE_EVERY_MINUTE,
+    AUTOSAVE_EVERY_5MINUTES,
+    AUTOSAVE_EVERY_15MINUTES,
+    AUTOSAVE_EVERY_30MINUTES,
+    AUTOSAVE_EVERY_HOUR,
+    AUTOSAVE_NEVER
+};
+
+
+
+
+static constexpr money32 COMPANY_VALUE_ON_FAILED_OBJECTIVE = 0x80000001;
+
+extern const rct_string_id ScenarioCategoryStringIds[SCENARIO_CATEGORY_COUNT];
+
+extern uint32_t gScenarioTicks;
+extern random_engine_t gScenarioRand;
+
+extern Objective gScenarioObjective;
+extern bool gAllowEarlyCompletionInNetworkPlay;
+extern uint16_t gScenarioParkRatingWarningDays;
+extern money32 gScenarioCompletedCompanyValue;
+extern money32 gScenarioCompanyValueRecord;
+
+extern rct_s6_info gS6Info;
+extern std::string gScenarioName;
+extern std::string gScenarioDetails;
+extern std::string gScenarioCompletedBy;
+extern std::string gScenarioSavePath;
+extern bool gFirstTimeSaving;
+extern uint16_t gSavedAge;
+extern uint32_t gLastAutoSaveUpdate;
+
+extern char gScenarioFileName[260];
+
+void load_from_sc6(const char* path);
+void scenario_begin();
+void scenario_update();
+bool scenario_create_ducks();
+bool AllowEarlyCompletion();
+
+const random_engine_t::state_type& scenario_rand_state();
+void scenario_rand_seed(random_engine_t::result_type s0, random_engine_t::result_type s1);
+random_engine_t::result_type scenario_rand();
+uint32_t scenario_rand_max(uint32_t max);
+
+bool scenario_prepare_for_save();
+int32_t scenario_save(const utf8* path, int32_t flags);
+void scenario_remove_trackless_rides(rct_s6_data* s6);
+void scenario_fix_ghosts(rct_s6_data* s6);
+void scenario_failure();
+void scenario_success();
+void scenario_success_submit_name(const char* name);
+void scenario_autosave_check();
+# 36 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/Entrance.h" 1
+# 39 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/Map.h" 1
+# 40 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/Park.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/world/Park.h"
+       
+
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/../ride/Ride.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/world/Park.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/Map.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/world/Park.h" 2
+
+
+
+
+
+
+struct Peep;
+
+enum : uint32_t
+{
+    PARK_FLAGS_PARK_OPEN = (1 << 0),
+    PARK_FLAGS_SCENARIO_COMPLETE_NAME_INPUT = (1 << 1),
+    PARK_FLAGS_FORBID_LANDSCAPE_CHANGES = (1 << 2),
+    PARK_FLAGS_FORBID_TREE_REMOVAL = (1 << 3),
+    PARK_FLAGS_SHOW_REAL_GUEST_NAMES = (1 << 4),
+    PARK_FLAGS_FORBID_HIGH_CONSTRUCTION = (1 << 5),
+    PARK_FLAGS_PREF_LESS_INTENSE_RIDES = (1 << 6),
+    PARK_FLAGS_FORBID_MARKETING_CAMPAIGN = (1 << 7),
+    PARK_FLAGS_ANTI_CHEAT_DEPRECATED = (1 << 8),
+    PARK_FLAGS_PREF_MORE_INTENSE_RIDES = (1 << 9),
+    PARK_FLAGS_NO_MONEY = (1 << 11),
+    PARK_FLAGS_DIFFICULT_GUEST_GENERATION = (1 << 12),
+    PARK_FLAGS_PARK_FREE_ENTRY = (1 << 13),
+    PARK_FLAGS_DIFFICULT_PARK_RATING = (1 << 14),
+    PARK_FLAGS_LOCK_REAL_NAMES_OPTION_DEPRECATED = (1 << 15),
+    PARK_FLAGS_NO_MONEY_SCENARIO = (1 << 17),
+    PARK_FLAGS_SPRITES_INITIALISED = (1 << 18),
+    PARK_FLAGS_SIX_FLAGS_DEPRECATED = (1 << 19),
+    PARK_FLAGS_UNLOCK_ALL_PRICES = (1u << 31),
+};
+
+struct Peep;
+struct rct_ride;
+
+namespace OpenRCT2
+{
+    class Date;
+
+    class Park final
+    {
+    public:
+        std::string Name;
+
+        Park() = default;
+        Park(const Park&) = delete;
+
+        bool IsOpen() const;
+
+        uint16_t GetParkRating() const;
+        money32 GetParkValue() const;
+        money32 GetCompanyValue() const;
+
+        void Initialise();
+        void Update(const Date& date);
+
+        int32_t CalculateParkSize() const;
+        int32_t CalculateParkRating() const;
+        money32 CalculateParkValue() const;
+        money32 CalculateCompanyValue() const;
+        static uint8_t CalculateGuestInitialHappiness(uint8_t percentage);
+
+        Peep* GenerateGuest();
+
+        void ResetHistories();
+        void UpdateHistories();
+
+    private:
+        money32 CalculateRideValue(const Ride* ride) const;
+        money16 CalculateTotalRideValueForMoney() const;
+        uint32_t CalculateSuggestedMaxGuests() const;
+        uint32_t CalculateGuestGenerationProbability() const;
+
+        void GenerateGuests();
+        Peep* GenerateGuestFromCampaign(int32_t campaign);
+    };
+}
+
+extern uint32_t gParkFlags;
+extern uint16_t gParkRating;
+extern money16 gParkEntranceFee;
+extern uint16_t gParkSize;
+extern money16 gLandPrice;
+extern money16 gConstructionRightsPrice;
+
+extern uint32_t gTotalAdmissions;
+extern money32 gTotalIncomeFromAdmissions;
+
+extern money32 gParkValue;
+extern money32 gCompanyValue;
+
+extern int16_t gParkRatingCasualtyPenalty;
+extern uint8_t gParkRatingHistory[32];
+extern uint8_t gGuestsInParkHistory[32];
+extern int32_t _guestGenerationProbability;
+extern uint32_t _suggestedGuestMaximum;
+
+void set_forced_park_rating(int32_t rating);
+int32_t get_forced_park_rating();
+
+int32_t park_is_open();
+int32_t park_calculate_size();
+
+void update_park_fences(const CoordsXY& coords);
+void update_park_fences_around_tile(const CoordsXY& coords);
+
+uint8_t calculate_guest_initial_happiness(uint8_t percentage);
+
+void park_set_open(bool open);
+int32_t park_entrance_get_index(const CoordsXYZ& entrancePos);
+void park_set_entrance_fee(money32 value);
+money16 park_get_entrance_fee();
+
+bool park_ride_prices_unlocked();
+bool park_entry_price_unlocked();
+# 41 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/Sprite.h" 1
+# 14 "/home/ted/dev/openrct2/src/openrct2/world/Sprite.h"
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/../peep/Peep.h" 1
+# 15 "/home/ted/dev/openrct2/src/openrct2/world/Sprite.h" 2
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/../ride/Vehicle.h" 1
+# 16 "/home/ted/dev/openrct2/src/openrct2/world/Sprite.h" 2
+
+# 1 "/home/ted/dev/openrct2/src/openrct2/world/Fountain.h" 1
+# 10 "/home/ted/dev/openrct2/src/openrct2/world/Fountain.h"
+       
+
+
+
+
+
+enum class JumpingFountainType : uint8_t
+{
+    Water,
+    Snow
+};
+
+struct JumpingFountain : MiscEntity
+{
+    static constexpr auto cEntityType = EntityType::JumpingFountain;
+
+    JumpingFountainType FountainType;
+    uint8_t NumTicksAlive;
+    uint8_t FountainFlags;
+    int16_t TargetX;
+    int16_t TargetY;
+    uint16_t Iteration;
+    void Update();
+    static void StartAnimation(JumpingFountainType newType, const CoordsXY& newLoc, const TileElement* tileElement);
+
+private:
+    JumpingFountainType GetType() const;
+    void AdvanceAnimation();
+    void GoToEdge(const CoordsXYZ& newLoc, int32_t availableDirections) const;
+    void Bounce(const CoordsXYZ& newLoc, int32_t availableDirections);
+    void Split(const CoordsXYZ& newLoc, int32_t availableDirections) const;
+    void Random(const CoordsXYZ& newLoc, int32_t availableDirections) const;
+    void CreateNext(const CoordsXYZ& newLoc, int32_t direction) const;
+    static void Create(
+        JumpingFountainType newType, const CoordsXYZ& newLoc, int32_t direction, int32_t newFlags, int32_t iteration);
+    static bool IsJumpingFountain(JumpingFountainType newType, const CoordsXYZ& newLoc);
+};
+
+namespace FOUNTAIN_FLAG
+{
+    const uint32_t FAST = 1 << 0;
+    const uint32_t GOTO_EDGE = 1 << 1;
+    const uint32_t SPLIT = 1 << 2;
+    const uint32_t TERMINATE = 1 << 3;
+    const uint32_t BOUNCE = 1 << 4;
+    const uint32_t DIRECTION = 1 << 7;
+};
+# 18 "/home/ted/dev/openrct2/src/openrct2/world/Sprite.h" 2
+
+
+enum LitterType : uint8_t;
+
+struct Litter : SpriteBase
+{
+    static constexpr auto cEntityType = EntityType::Litter;
+    LitterType SubType;
+    uint32_t creationTick;
+};
+
+struct Balloon : MiscEntity
+{
+    static constexpr auto cEntityType = EntityType::Balloon;
+    uint16_t popped;
+    uint8_t time_to_move;
+    uint8_t colour;
+
+    void Update();
+    void Pop();
+    void Press();
+};
+
+struct Duck : MiscEntity
+{
+    static constexpr auto cEntityType = EntityType::Duck;
+    enum class DuckState : uint8_t
+    {
+        FlyToWater,
+        Swim,
+        Drink,
+        DoubleDrink,
+        FlyAway,
+    };
+    int16_t target_x;
+    int16_t target_y;
+    DuckState state;
+
+    void Update();
+    uint32_t GetFrameImage(int32_t direction) const;
+    bool IsFlying();
+    void Remove();
+
+private:
+    void UpdateFlyToWater();
+    void UpdateSwim();
+    void UpdateDrink();
+    void UpdateDoubleDrink();
+    void UpdateFlyAway();
+};
+
+struct MoneyEffect : MiscEntity
+{
+    static constexpr auto cEntityType = EntityType::MoneyEffect;
+    uint16_t MoveDelay;
+    uint8_t NumMovements;
+    uint8_t Vertical;
+    money32 Value;
+    int16_t OffsetX;
+    uint16_t Wiggle;
+
+    static void CreateAt(money32 value, const CoordsXYZ& effectPos, bool vertical);
+    static void Create(money32 value, const CoordsXYZ& loc);
+    void Update();
+    std::pair<rct_string_id, money32> GetStringId() const;
+};
+
+struct VehicleCrashParticle : MiscEntity
+{
+    static constexpr auto cEntityType = EntityType::CrashedVehicleParticle;
+    uint16_t time_to_live;
+    uint8_t colour[2];
+    uint16_t crashed_sprite_base;
+    int16_t velocity_x;
+    int16_t velocity_y;
+    int16_t velocity_z;
+    int32_t acceleration_x;
+    int32_t acceleration_y;
+    int32_t acceleration_z;
+
+    void Update();
+};
+
+struct ExplosionFlare : MiscEntity
+{
+    static constexpr auto cEntityType = EntityType::ExplosionFlare;
+    void Update();
+};
+
+struct ExplosionCloud : MiscEntity
+{
+    static constexpr auto cEntityType = EntityType::ExplosionCloud;
+    void Update();
+};
+
+struct CrashSplashParticle : MiscEntity
+{
+    static constexpr auto cEntityType = EntityType::CrashSplash;
+    void Update();
+};
+
+struct SteamParticle : MiscEntity
+{
+    static constexpr auto cEntityType = EntityType::SteamParticle;
+    uint16_t time_to_move;
+
+    void Update();
+};
+
+#pragma pack(push, 1)
+
+
+
+
+union rct_sprite
+{
+    uint8_t pad_00[0x200];
+    MiscEntity misc;
+    Peep peep;
+    Litter litter;
+    Vehicle vehicle;
+    Balloon balloon;
+    Duck duck;
+    JumpingFountain jumping_fountain;
+    MoneyEffect money_effect;
+    VehicleCrashParticle crashed_vehicle_particle;
+    CrashSplashParticle crash_splash;
+    SteamParticle steam_particle;
+
+
+    rct_sprite()
+        : pad_00()
+    {
+    }
+};
+static_assert(sizeof(rct_sprite) == (0x200), "Improper struct size");
+
+struct rct_sprite_checksum
+{
+    std::array<uint8_t, 20> raw;
+
+    std::string ToString() const;
+};
+
+#pragma pack(pop)
+
+enum
+{
+    SPRITE_FLAGS_IS_CRASHED_VEHICLE_SPRITE = 1 << 7,
+    SPRITE_FLAGS_PEEP_VISIBLE = 1 << 8,
+    SPRITE_FLAGS_PEEP_FLASHING = 1 << 9,
+};
+
+enum LitterType : uint8_t
+{
+    LITTER_TYPE_SICK,
+    LITTER_TYPE_SICK_ALT,
+    LITTER_TYPE_EMPTY_CAN,
+    LITTER_TYPE_RUBBISH,
+    LITTER_TYPE_EMPTY_BURGER_BOX,
+    LITTER_TYPE_EMPTY_CUP,
+    LITTER_TYPE_EMPTY_BOX,
+    LITTER_TYPE_EMPTY_BOTTLE,
+    LITTER_TYPE_EMPTY_BOWL_RED,
+    LITTER_TYPE_EMPTY_DRINK_CARTON,
+    LITTER_TYPE_EMPTY_JUICE_CUP,
+    LITTER_TYPE_EMPTY_BOWL_BLUE,
+};
+
+constexpr const uint32_t SPATIAL_INDEX_SIZE = (256 * 256) + 1;
+constexpr const uint32_t SPATIAL_INDEX_LOCATION_NULL = SPATIAL_INDEX_SIZE - 1;
+
+extern const rct_string_id litterNames[12];
+
+rct_sprite* create_sprite(EntityType type);
+template<typename T> T* CreateEntity()
+{
+    return reinterpret_cast<T*>(create_sprite(T::cEntityType));
+}
+
+
+SpriteBase* CreateEntityAt(const uint16_t index, const EntityType type);
+
+template<typename T> T* CreateEntityAt(const uint16_t index)
+{
+    return static_cast<T*>(CreateEntityAt(index, T::cEntityType));
+}
+void reset_sprite_list();
+void reset_sprite_spatial_index();
+void sprite_clear_all_unused();
+void sprite_misc_update_all();
+void sprite_set_coordinates(const CoordsXYZ& spritePos, SpriteBase* sprite);
+void sprite_remove(SpriteBase* sprite);
+void litter_create(const CoordsXYZD& litterPos, LitterType type);
+void litter_remove_at(const CoordsXYZ& litterPos);
+uint16_t remove_floating_sprites();
+void sprite_misc_explosion_cloud_create(const CoordsXYZ& cloudPos);
+void sprite_misc_explosion_flare_create(const CoordsXYZ& flarePos);
+
+
+
+
+void create_balloon(const CoordsXYZ& balloonPos, int32_t colour, bool isPopped);
+void balloon_update(Balloon* balloon);
+
+
+
+
+void create_duck(const CoordsXY& pos);
+void duck_press(Duck* duck);
+void duck_remove_all();
+
+
+
+
+void crashed_vehicle_particle_create(rct_vehicle_colour colours, const CoordsXYZ& vehiclePos);
+void crash_splash_create(const CoordsXYZ& splashPos);
+
+rct_sprite_checksum sprite_checksum();
+
+void sprite_set_flashing(SpriteBase* sprite, bool flashing);
+bool sprite_get_flashing(SpriteBase* sprite);
+
+class EntityTweener
+{
+    std::vector<SpriteBase*> Entities;
+    std::vector<CoordsXYZ> PrePos;
+    std::vector<CoordsXYZ> PostPos;
+
+private:
+    void PopulateEntities();
+
+public:
+    static EntityTweener& Get();
+
+    void PreTick();
+    void PostTick();
+    void RemoveEntity(SpriteBase* entity);
+    void Tween(float alpha);
+    void Restore();
+    void Reset();
+};
+# 42 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+
+
+# 1 "/usr/include/c++/10.2.0/ctime" 1 3
+# 39 "/usr/include/c++/10.2.0/ctime" 3
+       
+# 40 "/usr/include/c++/10.2.0/ctime" 3
+# 45 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 2
+
+
+
+
+using namespace OpenRCT2;
+
+namespace OpenRCT2
+{
+    constexpr uint32_t PARK_FILE_MAGIC = 0x4B524150;
+
+
+    constexpr uint32_t PARK_FILE_CURRENT_VERSION = 0x0;
+
+
+    constexpr uint32_t PARK_FILE_MIN_VERSION = 0x0;
+
+    namespace ParkFileChunkType
+    {
+
+
+
+        constexpr uint32_t AUTHORING = 0x01;
+        constexpr uint32_t OBJECTS = 0x02;
+        constexpr uint32_t SCENARIO = 0x03;
+        constexpr uint32_t GENERAL = 0x04;
+        constexpr uint32_t CLIMATE = 0x05;
+        constexpr uint32_t PARK = 0x06;
+
+        constexpr uint32_t RESEARCH = 0x08;
+        constexpr uint32_t NOTIFICATIONS = 0x09;
+
+        constexpr uint32_t INTERFACE = 0x20;
+
+
+        constexpr uint32_t TILES = 0x30;
+        constexpr uint32_t ENTITIES = 0x31;
+        constexpr uint32_t RIDES = 0x32;
+        constexpr uint32_t BANNERS = 0x33;
+
+
+        constexpr uint32_t CHEATS = 0x36;
+
+
+
+    };
+
+    class ParkFile
+    {
+    public:
+        ObjectList RequiredObjects;
+
+    private:
+        std::unique_ptr<OrcaStream> _os;
+
+    public:
+        void Load(const std::string_view& path)
+        {
+            FileStream fs(path, FILE_MODE_OPEN);
+            Load(fs);
+        }
+
+        void Load(IStream& stream)
+        {
+            _os = std::make_unique<OrcaStream>(stream, OrcaStream::Mode::READING);
+            RequiredObjects = {};
+            ReadWriteObjectsChunk(*_os);
+        }
+
+        void Import()
+        {
+            auto& os = *_os;
+            ReadWriteTilesChunk(os);
+            ReadWriteBannersChunk(os);
+            ReadWriteRidesChunk(os);
+            ReadWriteEntitiesChunk(os);
+            ReadWriteScenarioChunk(os);
+            ReadWriteGeneralChunk(os);
+            ReadWriteParkChunk(os);
+            ReadWriteClimateChunk(os);
+            ReadWriteResearchChunk(os);
+            ReadWriteNotificationsChunk(os);
+            ReadWriteInterfaceChunk(os);
+            ReadWriteCheatsChunk(os);
+
+
+            gInitialCash = gCash;
+            String::Set(gS6Info.name, sizeof(gS6Info.name), gScenarioName.c_str());
+            String::Set(gS6Info.details, sizeof(gS6Info.details), gScenarioName.c_str());
+
+            AutoDeriveVariables();
+        }
+
+        void Save(IStream& stream)
+        {
+            OrcaStream os(stream, OrcaStream::Mode::WRITING);
+
+            auto& header = os.GetHeader();
+            header.Magic = PARK_FILE_MAGIC;
+            header.TargetVersion = PARK_FILE_CURRENT_VERSION;
+            header.MinVersion = PARK_FILE_MIN_VERSION;
+
+            ReadWriteAuthoringChunk(os);
+            ReadWriteObjectsChunk(os);
+            ReadWriteTilesChunk(os);
+            ReadWriteBannersChunk(os);
+            ReadWriteRidesChunk(os);
+            ReadWriteEntitiesChunk(os);
+            ReadWriteScenarioChunk(os);
+            ReadWriteGeneralChunk(os);
+            ReadWriteParkChunk(os);
+            ReadWriteClimateChunk(os);
+            ReadWriteResearchChunk(os);
+            ReadWriteNotificationsChunk(os);
+            ReadWriteInterfaceChunk(os);
+            ReadWriteCheatsChunk(os);
+        }
+
+        void Save(const std::string_view& path)
+        {
+            FileStream fs(path, FILE_MODE_WRITE);
+            Save(fs);
+        }
+
+    private:
+        void ReadWriteAuthoringChunk(OrcaStream& os)
+        {
+
+            if (os.GetMode() == OrcaStream::Mode::WRITING)
+            {
+                os.ReadWriteChunk(ParkFileChunkType::AUTHORING, [](OrcaStream::ChunkStream& cs) {
+                    cs.Write(std::string_view(gVersionInfoFull));
+                    std::vector<std::string> authors;
+                    cs.ReadWriteVector(authors, [](std::string& s) {});
+                    cs.Write(std::string_view());
+                    cs.Write<uint64_t>(std::time(0));
+                    cs.Write<uint64_t>(std::time(0));
+                });
+            }
+        }
+
+        void ReadWriteObjectsChunk(OrcaStream& os)
+        {
+            static constexpr uint8_t DESCRIPTOR_NONE = 0;
+            static constexpr uint8_t DESCRIPTOR_DAT = 1;
+            static constexpr uint8_t DESCRIPTOR_JSON = 2;
+
+            if (os.GetMode() == OrcaStream::Mode::READING)
+            {
+                ObjectList requiredObjects;
+                os.ReadWriteChunk(ParkFileChunkType::OBJECTS, [&requiredObjects](OrcaStream::ChunkStream& cs) {
+                    auto numSubLists = cs.Read<uint16_t>();
+                    for (size_t i = 0; i < numSubLists; i++)
+                    {
+                        auto objectType = static_cast<ObjectType>(cs.Read<uint16_t>());
+                        auto subListSize = static_cast<ObjectEntryIndex>(cs.Read<uint32_t>());
+                        for (ObjectEntryIndex j = 0; j < subListSize; j++)
+                        {
+                            auto kind = cs.Read<uint8_t>();
+
+                            ObjectEntryDescriptor desc;
+                            switch (kind)
+                            {
+                                case DESCRIPTOR_NONE:
+                                    break;
+                                case DESCRIPTOR_DAT:
+                                    desc.Entry = cs.Read<rct_object_entry>();
+                                    requiredObjects.SetObject(j, desc);
+                                    break;
+                                case DESCRIPTOR_JSON:
+                                    desc.Type = objectType;
+                                    desc.Identifier = cs.Read<std::string>();
+                                    desc.Version = cs.Read<std::string>();
+                                    requiredObjects.SetObject(j, desc);
+                                    break;
+                                default:
+                                    throw std::runtime_error("Unknown object descriptor kind.");
+                            }
+                        }
+                    }
+                });
+                RequiredObjects = std::move(requiredObjects);
+            }
+            else
+            {
+                os.ReadWriteChunk(ParkFileChunkType::OBJECTS, [](OrcaStream::ChunkStream& cs) {
+                    auto& objManager = GetContext()->GetObjectManager();
+                    auto objectList = objManager.GetLoadedObjects();
+
+
+                    cs.Write(static_cast<uint16_t>(ObjectType::Count));
+                    for (auto objectType = ObjectType::Ride; objectType < ObjectType::Count; objectType++)
+                    {
+
+                        const auto& list = objectList.GetList(objectType);
+                        cs.Write(static_cast<uint16_t>(objectType));
+                        cs.Write(static_cast<uint32_t>(list.size()));
+                        for (const auto& entry : list)
+                        {
+                            if (entry.HasValue())
+                            {
+                                if (entry.Generation == ObjectGeneration::JSON)
+                                {
+                                    cs.Write(DESCRIPTOR_JSON);
+                                    cs.Write(entry.Identifier);
+                                    cs.Write("");
+                                }
+                                else
+                                {
+                                    cs.Write(DESCRIPTOR_DAT);
+                                    cs.Write(entry.Entry);
+                                }
+                            }
+                            else
+                            {
+                                cs.Write(DESCRIPTOR_NONE);
+                            }
+                        }
+                    }
+                });
+            }
+        }
+
+        void ReadWriteScenarioChunk(OrcaStream& os)
+        {
+            os.ReadWriteChunk(ParkFileChunkType::SCENARIO, [](OrcaStream::ChunkStream& cs) {
+                cs.ReadWriteAs<uint8_t, uint32_t>(gS6Info.category);
+                ReadWriteStringTable(cs, gScenarioName, "en-GB");
+
+                auto& park = GetContext()->GetGameState()->GetPark();
+                ReadWriteStringTable(cs, park.Name, "en-GB");
+
+                ReadWriteStringTable(cs, gScenarioDetails, "en-GB");
+# 287 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp"
+                cs.ReadWrite<Objective>(gScenarioObjective);
+
+                cs.ReadWrite(gScenarioParkRatingWarningDays);
+
+                cs.ReadWrite(gScenarioCompletedCompanyValue);
+                if (gScenarioCompletedCompanyValue == (static_cast<money32>(0x80000000))
+                    || gScenarioCompletedCompanyValue == COMPANY_VALUE_ON_FAILED_OBJECTIVE)
+                {
+                    cs.Write("");
+                }
+                else
+                {
+                    cs.ReadWrite(gScenarioCompletedBy);
+                }
+
+                if (cs.GetMode() == OrcaStream::Mode::READING)
+                {
+                    auto earlyCompletion = cs.Read<bool>();
+                    if (network_get_mode() == NETWORK_MODE_CLIENT)
+                    {
+                        gAllowEarlyCompletionInNetworkPlay = earlyCompletion;
+                    }
+                }
+                else
+                {
+                    cs.Write(AllowEarlyCompletion());
+                }
+            });
+        }
+
+        void ReadWriteGeneralChunk(OrcaStream& os)
+        {
+            auto found = os.ReadWriteChunk(ParkFileChunkType::GENERAL, [](OrcaStream::ChunkStream& cs) {
+                cs.ReadWrite(gGamePaused);
+                cs.ReadWriteAs<uint32_t, uint64_t>(gScenarioTicks);
+                cs.ReadWriteAs<uint16_t, uint32_t>(gDateMonthTicks);
+                cs.ReadWrite(gDateMonthsElapsed);
+
+                if (cs.GetMode() == OrcaStream::Mode::READING)
+                {
+                    uint32_t s0{}, s1{};
+                    cs.ReadWrite(s0);
+                    cs.ReadWrite(s1);
+                    Random::Rct2::Seed s{ s0, s1 };
+                    gScenarioRand.seed(s);
+                }
+                else
+                {
+                    auto randState = gScenarioRand.state();
+                    cs.Write(randState.s0);
+                    cs.Write(randState.s1);
+                }
+
+                cs.ReadWrite(gGuestInitialCash);
+                cs.ReadWrite(gGuestInitialHunger);
+                cs.ReadWrite(gGuestInitialThirst);
+
+                cs.ReadWrite(gNextGuestNumber);
+                cs.ReadWriteVector(gPeepSpawns, [&cs](PeepSpawn& spawn) {
+                    cs.ReadWrite(spawn.x);
+                    cs.ReadWrite(spawn.y);
+                    cs.ReadWrite(spawn.z);
+                    cs.ReadWrite(spawn.direction);
+                });
+
+                cs.ReadWrite(gLandPrice);
+                cs.ReadWrite(gConstructionRightsPrice);
+                cs.ReadWrite(gGrassSceneryTileLoopPosition);
+            });
+            if (!found)
+            {
+                throw std::runtime_error("No general chunk found.");
+            }
+        }
+
+        void ReadWriteInterfaceChunk(OrcaStream& os)
+        {
+            os.ReadWriteChunk(ParkFileChunkType::INTERFACE, [](OrcaStream::ChunkStream& cs) {
+                cs.ReadWrite(gSavedView);
+                cs.ReadWrite(gSavedViewZoom);
+                cs.ReadWrite(gSavedViewRotation);
+                cs.ReadWriteAs<uint8_t, uint32_t>(gLastEntranceStyle);
+            });
+        }
+
+        void ReadWriteCheatsChunk(OrcaStream& os)
+        {
+            os.ReadWriteChunk(ParkFileChunkType::CHEATS, [](OrcaStream::ChunkStream& cs) {
+                DataSerialiser ds(cs.GetMode() == OrcaStream::Mode::WRITING, cs.GetStream());
+                CheatsSerialise(ds);
+            });
+        }
+
+        void ReadWriteClimateChunk(OrcaStream& os)
+        {
+            os.ReadWriteChunk(ParkFileChunkType::CLIMATE, [](OrcaStream::ChunkStream& cs) {
+                cs.ReadWrite(gClimate);
+                cs.ReadWrite(gClimateUpdateTimer);
+
+                for (const auto* cl : { &gClimateCurrent, &gClimateNext })
+                {
+                    cs.ReadWrite(cl->Weather);
+                    cs.ReadWrite(cl->Temperature);
+                    cs.ReadWrite(cl->WeatherEffect);
+                    cs.ReadWrite(cl->WeatherGloom);
+                    cs.ReadWrite(cl->Level);
+                }
+            });
+        }
+
+        void ReadWriteParkChunk(OrcaStream& os)
+        {
+            os.ReadWriteChunk(ParkFileChunkType::PARK, [](OrcaStream::ChunkStream& cs) {
+                auto& park = GetContext()->GetGameState()->GetPark();
+                cs.ReadWrite(park.Name);
+                cs.ReadWrite(gCash);
+                cs.ReadWrite(gBankLoan);
+                cs.ReadWrite(gMaxBankLoan);
+                cs.ReadWriteAs<uint8_t, uint16_t>(gBankLoanInterestRate);
+                cs.ReadWriteAs<uint32_t, uint64_t>(gParkFlags);
+                cs.ReadWriteAs<money16, money32>(gParkEntranceFee);
+                cs.ReadWrite(gStaffHandymanColour);
+                cs.ReadWrite(gStaffMechanicColour);
+                cs.ReadWrite(gStaffSecurityColour);
+                cs.ReadWrite(gSamePriceThroughoutPark);
+
+
+                cs.ReadWriteVector(gMarketingCampaigns, [&cs](MarketingCampaign& campaign) {
+                    cs.ReadWrite(campaign.Type);
+                    cs.ReadWrite(campaign.WeeksLeft);
+                    cs.ReadWrite(campaign.Flags);
+                    cs.ReadWrite(campaign.RideId);
+                });
+
+
+                cs.ReadWriteArray(gCurrentAwards, [&cs](Award& award) {
+                    if (award.Time != 0)
+                    {
+                        cs.ReadWrite(award.Time);
+                        cs.ReadWrite(award.Type);
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                });
+
+                cs.ReadWriteAs<money32, money64>(gParkValue);
+                cs.ReadWriteAs<uint16_t, uint32_t>(gParkRating);
+                cs.ReadWrite(gParkRatingCasualtyPenalty);
+                cs.ReadWrite(gCurrentExpenditure);
+                cs.ReadWrite(gCurrentProfit);
+                cs.ReadWrite(gTotalAdmissions);
+                cs.ReadWrite(gTotalIncomeFromAdmissions);
+                cs.ReadWrite(_guestGenerationProbability);
+                cs.ReadWrite(_suggestedGuestMaximum);
+            });
+        }
+
+        void ReadWriteResearchChunk(OrcaStream& os)
+        {
+            os.ReadWriteChunk(ParkFileChunkType::RESEARCH, [](OrcaStream::ChunkStream& cs) {
+
+                cs.ReadWrite(gResearchFundingLevel);
+                cs.ReadWrite(gResearchPriorities);
+                cs.ReadWrite(gResearchProgressStage);
+                cs.ReadWrite(gResearchProgress);
+                cs.ReadWrite(gResearchExpectedMonth);
+                cs.ReadWrite(gResearchExpectedDay);
+                ReadWriteResearchItem(cs, gResearchLastItem);
+                ReadWriteResearchItem(cs, gResearchNextItem);
+
+
+                cs.ReadWriteVector(gResearchItemsUninvented, [&cs](ResearchItem& item) { ReadWriteResearchItem(cs, item); });
+                cs.ReadWriteVector(gResearchItemsInvented, [&cs](ResearchItem& item) { ReadWriteResearchItem(cs, item); });
+            });
+        }
+
+        static void ReadWriteResearchItem(OrcaStream::ChunkStream& cs, std::optional<ResearchItem>& item)
+        {
+            if (cs.GetMode() == OrcaStream::Mode::READING)
+            {
+                auto hasValue = cs.Read<bool>();
+                if (hasValue)
+                {
+                    ResearchItem placeholder;
+                    ReadWriteResearchItem(cs, placeholder);
+                    item = placeholder;
+                }
+            }
+            else
+            {
+                if (item)
+                {
+                    cs.Write<bool>(true);
+                    ReadWriteResearchItem(cs, *item);
+                }
+                else
+                {
+                    cs.Write<bool>(false);
+                }
+            }
+        }
+
+        static void ReadWriteResearchItem(OrcaStream::ChunkStream& cs, ResearchItem& item)
+        {
+            cs.ReadWrite(item.type);
+            cs.ReadWrite(item.baseRideType);
+            cs.ReadWrite(item.entryIndex);
+            cs.ReadWrite(item.flags);
+            cs.ReadWrite(item.category);
+        }
+
+        void ReadWriteNotificationsChunk(OrcaStream& os)
+        {
+            os.ReadWriteChunk(ParkFileChunkType::NOTIFICATIONS, [](OrcaStream::ChunkStream& cs) {
+                if (cs.GetMode() == OrcaStream::Mode::READING)
+                {
+                    gNewsItems.Clear();
+
+                    std::vector<News::Item> recent;
+                    cs.ReadWriteVector(recent, [&cs](News::Item& item) { ReadWriteNewsItem(cs, item); });
+                    for (size_t i = 0; i < std::min<size_t>(recent.size(), News::ItemHistoryStart); i++)
+                    {
+                        gNewsItems[i] = recent[i];
+                    }
+
+                    std::vector<News::Item> archived;
+                    cs.ReadWriteVector(archived, [&cs](News::Item& item) { ReadWriteNewsItem(cs, item); });
+                    size_t offset = News::ItemHistoryStart;
+                    for (size_t i = 0; i < std::min<size_t>(archived.size(), News::MaxItemsArchive); i++)
+                    {
+                        gNewsItems[offset + i] = archived[i];
+                    }
+                }
+                else
+                {
+                    std::vector<News::Item> recent(std::begin(gNewsItems.GetRecent()), std::end(gNewsItems.GetRecent()));
+                    cs.ReadWriteVector(recent, [&cs](News::Item& item) { ReadWriteNewsItem(cs, item); });
+
+                    std::vector<News::Item> archived(std::begin(gNewsItems.GetArchived()), std::end(gNewsItems.GetArchived()));
+                    cs.ReadWriteVector(archived, [&cs](News::Item& item) { ReadWriteNewsItem(cs, item); });
+                }
+            });
+        }
+
+        static void ReadWriteNewsItem(OrcaStream::ChunkStream& cs, News::Item& item)
+        {
+            cs.ReadWrite(item.Type);
+            cs.ReadWrite(item.Flags);
+            cs.ReadWrite(item.Assoc);
+            cs.ReadWrite(item.Ticks);
+            cs.ReadWrite(item.MonthYear);
+            cs.ReadWrite(item.Day);
+            if (cs.GetMode() == OrcaStream::Mode::READING)
+            {
+                auto s = cs.Read<std::string>();
+                item.Text = s;
+            }
+            else
+            {
+                cs.Write(std::string_view(item.Text));
+            }
+        }
+
+        void ReadWriteDerivedChunk(OrcaStream& os)
+        {
+            if (os.GetMode() == OrcaStream::Mode::WRITING)
+            {
+                os.ReadWriteChunk(ParkFileChunkType::NOTIFICATIONS, [](OrcaStream::ChunkStream& cs) {
+                    cs.Write<uint32_t>(gParkSize);
+                    cs.Write<uint32_t>(gNumGuestsInPark);
+                    cs.Write<uint32_t>(gNumGuestsHeadingForPark);
+                    cs.Write<uint32_t>(gCompanyValue);
+                    cs.Write<uint32_t>(gParkValue);
+                    cs.Write<uint32_t>(gParkRating);
+                });
+            }
+        }
+
+        void ReadWriteTilesChunk(OrcaStream& os)
+        {
+            auto found = os.ReadWriteChunk(ParkFileChunkType::TILES, [](OrcaStream::ChunkStream& cs) {
+                cs.ReadWriteAs<int16_t, uint32_t>(gMapSize);
+                cs.Write<uint32_t>(gMapSize);
+
+                if (cs.GetMode() == OrcaStream::Mode::READING)
+                {
+                    OpenRCT2::GetContext()->GetGameState()->InitAll(gMapSize);
+                }
+
+                std::vector<TileElement> tiles(std::begin(gTileElements), std::end(gTileElements));
+                cs.ReadWriteVector(tiles, [&cs](TileElement& el) { cs.ReadWrite(&el, sizeof(TileElement)); });
+                std::copy_n(tiles.data(), std::min(tiles.size(), std::size(gTileElements)), gTileElements);
+
+                map_update_tile_pointers();
+                UpdateParkEntranceLocations();
+            });
+            if (!found)
+            {
+                throw std::runtime_error("No tiles chunk found.");
+            }
+        }
+
+        void ReadWriteBannersChunk(OrcaStream& os)
+        {
+            os.ReadWriteChunk(ParkFileChunkType::BANNERS, [](OrcaStream::ChunkStream& cs) {
+                std::vector<Banner> banners;
+                if (cs.GetMode() == OrcaStream::Mode::WRITING)
+                {
+                    for (BannerIndex i = 0; i < MAX_BANNERS; i++)
+                    {
+                        banners.push_back(*GetBanner(i));
+                    }
+                }
+                cs.ReadWriteVector(banners, [&cs](Banner& banner) {
+                    cs.ReadWrite(banner.type);
+                    cs.ReadWrite(banner.flags);
+                    cs.ReadWrite(banner.text);
+                    cs.ReadWrite(banner.colour);
+                    cs.ReadWrite(banner.ride_index);
+                    cs.ReadWrite(banner.text_colour);
+                    cs.ReadWrite(banner.position);
+                });
+                if (cs.GetMode() == OrcaStream::Mode::READING)
+                {
+                    for (BannerIndex i = 0; i < MAX_BANNERS; i++)
+                    {
+                        auto banner = GetBanner(i);
+                        *banner = banners[i];
+                    }
+                }
+            });
+        }
+
+        void ReadWriteRidesChunk(OrcaStream& os)
+        {
+            os.ReadWriteChunk(ParkFileChunkType::RIDES, [](OrcaStream::ChunkStream& cs) {
+                std::vector<ride_id_t> rideIds;
+                if (cs.GetMode() == OrcaStream::Mode::READING)
+                {
+                    ride_init_all();
+                }
+                else
+                {
+                    for (const auto& ride : GetRideManager())
+                    {
+                        rideIds.push_back(ride.id);
+                    }
+                }
+                cs.ReadWriteVector(rideIds, [&cs](ride_id_t& rideId) {
+
+                    cs.ReadWrite(rideId);
+
+                    auto& ride = *GetOrAllocateRide(rideId);
+
+
+                    cs.ReadWrite(ride.type);
+                    cs.ReadWrite(ride.subtype);
+                    cs.ReadWrite(ride.mode);
+                    cs.ReadWrite(ride.status);
+                    cs.ReadWrite(ride.depart_flags);
+                    cs.ReadWrite(ride.lifecycle_flags);
+
+
+                    cs.ReadWrite(ride.custom_name);
+                    cs.ReadWrite(ride.default_name_number);
+
+                    cs.ReadWrite(ride.price[0]);
+                    cs.ReadWrite(ride.price[1]);
+
+
+                    cs.ReadWrite(ride.entrance_style);
+                    cs.ReadWrite(ride.colour_scheme_type);
+                    cs.ReadWriteArray(ride.track_colour, [&cs](TrackColour& tc) {
+                        cs.ReadWrite(tc.main);
+                        cs.ReadWrite(tc.additional);
+                        cs.ReadWrite(tc.supports);
+                        return true;
+                    });
+
+                    cs.ReadWriteArray(ride.vehicle_colours, [&cs](VehicleColour& vc) {
+                        cs.ReadWrite(vc);
+                        return true;
+                    });
+
+
+                    cs.ReadWrite(ride.num_stations);
+                    cs.ReadWriteArray(ride.stations, [&cs](RideStation& station) {
+                        cs.ReadWrite(station.Start);
+                        cs.ReadWrite(station.Height);
+                        cs.ReadWrite(station.Length);
+                        cs.ReadWrite(station.Depart);
+                        cs.ReadWrite(station.TrainAtStation);
+                        cs.ReadWrite(station.Entrance);
+                        cs.ReadWrite(station.Exit);
+                        cs.ReadWrite(station.SegmentLength);
+                        cs.ReadWrite(station.SegmentTime);
+                        cs.ReadWrite(station.QueueTime);
+                        cs.ReadWrite(station.QueueLength);
+                        cs.ReadWrite(station.LastPeepInQueue);
+                        return true;
+                    });
+
+                    cs.ReadWrite(ride.overall_view);
+
+
+                    cs.ReadWrite(ride.num_vehicles);
+                    cs.ReadWrite(ride.num_cars_per_train);
+                    cs.ReadWrite(ride.proposed_num_vehicles);
+                    cs.ReadWrite(ride.proposed_num_cars_per_train);
+                    cs.ReadWrite(ride.max_trains);
+                    cs.ReadWrite(ride.min_max_cars_per_train);
+                    cs.ReadWrite(ride.min_waiting_time);
+                    cs.ReadWrite(ride.max_waiting_time);
+                    cs.ReadWriteArray(ride.vehicles, [&cs](uint16_t& v) {
+                        cs.ReadWrite(v);
+                        return true;
+                    });
+
+
+                    cs.ReadWrite(ride.operation_option);
+                    cs.ReadWrite(ride.lift_hill_speed);
+                    cs.ReadWrite(ride.num_circuits);
+
+
+                    cs.ReadWrite(ride.boat_hire_return_direction);
+                    cs.ReadWrite(ride.boat_hire_return_position);
+                    cs.ReadWrite(ride.ChairliftBullwheelLocation[0]);
+                    cs.ReadWrite(ride.ChairliftBullwheelLocation[1]);
+                    cs.ReadWrite(ride.chairlift_bullwheel_rotation);
+                    cs.ReadWrite(ride.slide_in_use);
+                    cs.ReadWrite(ride.slide_peep);
+                    cs.ReadWrite(ride.slide_peep_t_shirt_colour);
+                    cs.ReadWrite(ride.spiral_slide_progress);
+                    cs.ReadWrite(ride.race_winner);
+                    cs.ReadWrite(ride.cable_lift);
+                    cs.ReadWrite(ride.CableLiftLoc);
+
+
+                    if (cs.GetMode() == OrcaStream::Mode::READING)
+                    {
+                        auto hasMeasurement = cs.Read<uint8_t>();
+                        if (hasMeasurement != 0)
+                        {
+                            ride.measurement = std::make_unique<RideMeasurement>();
+                            ReadWriteRideMeasurement(cs, *ride.measurement);
+                        }
+                    }
+                    else
+                    {
+                        if (ride.measurement == nullptr)
+                        {
+                            cs.Write<uint8_t>(0);
+                        }
+                        else
+                        {
+                            cs.Write<uint8_t>(1);
+                            ReadWriteRideMeasurement(cs, *ride.measurement);
+                        }
+                    }
+
+                    cs.ReadWrite(ride.special_track_elements);
+                    cs.ReadWrite(ride.max_speed);
+                    cs.ReadWrite(ride.average_speed);
+                    cs.ReadWrite(ride.current_test_segment);
+                    cs.ReadWrite(ride.average_speed_test_timeout);
+
+                    cs.ReadWrite(ride.max_positive_vertical_g);
+                    cs.ReadWrite(ride.max_negative_vertical_g);
+                    cs.ReadWrite(ride.max_lateral_g);
+                    cs.ReadWrite(ride.previous_vertical_g);
+                    cs.ReadWrite(ride.previous_lateral_g);
+
+                    cs.ReadWrite(ride.testing_flags);
+                    cs.ReadWrite(ride.CurTestTrackLocation);
+
+                    cs.ReadWrite(ride.turn_count_default);
+                    cs.ReadWrite(ride.turn_count_banked);
+                    cs.ReadWrite(ride.turn_count_sloped);
+
+                    cs.ReadWrite(ride.inversions);
+                    cs.ReadWrite(ride.drops);
+                    cs.ReadWrite(ride.start_drop_height);
+                    cs.ReadWrite(ride.highest_drop_height);
+                    cs.ReadWrite(ride.sheltered_length);
+                    cs.ReadWrite(ride.var_11C);
+                    cs.ReadWrite(ride.num_sheltered_sections);
+                    cs.ReadWrite(ride.current_test_station);
+                    cs.ReadWrite(ride.num_block_brakes);
+                    cs.ReadWrite(ride.total_air_time);
+
+                    cs.ReadWrite(ride.excitement);
+                    cs.ReadWrite(ride.intensity);
+                    cs.ReadWrite(ride.nausea);
+
+                    cs.ReadWrite(ride.value);
+
+                    cs.ReadWrite(ride.num_riders);
+                    cs.ReadWrite(ride.build_date);
+                    cs.ReadWrite(ride.upkeep_cost);
+
+                    cs.ReadWrite(ride.cur_num_customers);
+                    cs.ReadWrite(ride.num_customers_timeout);
+                    cs.ReadWrite(ride.num_customers);
+                    cs.ReadWrite(ride.total_customers);
+                    cs.ReadWrite(ride.total_profit);
+                    cs.ReadWrite(ride.popularity);
+                    cs.ReadWrite(ride.popularity_time_out);
+                    cs.ReadWrite(ride.popularity_next);
+                    cs.ReadWrite(ride.guests_favourite);
+                    cs.ReadWrite(ride.no_primary_items_sold);
+                    cs.ReadWrite(ride.no_secondary_items_sold);
+                    cs.ReadWrite(ride.income_per_hour);
+                    cs.ReadWrite(ride.profit);
+                    cs.ReadWrite(ride.satisfaction);
+                    cs.ReadWrite(ride.satisfaction_time_out);
+                    cs.ReadWrite(ride.satisfaction_next);
+
+
+                    cs.ReadWrite(ride.breakdown_reason_pending);
+                    cs.ReadWrite(ride.mechanic_status);
+                    cs.ReadWrite(ride.mechanic);
+                    cs.ReadWrite(ride.inspection_station);
+                    cs.ReadWrite(ride.broken_vehicle);
+                    cs.ReadWrite(ride.broken_car);
+                    cs.ReadWrite(ride.breakdown_reason);
+                    cs.ReadWrite(ride.reliability_subvalue);
+                    cs.ReadWrite(ride.reliability_percentage);
+                    cs.ReadWrite(ride.unreliability_factor);
+                    cs.ReadWrite(ride.downtime);
+                    cs.ReadWrite(ride.inspection_interval);
+                    cs.ReadWrite(ride.last_inspection);
+                    cs.ReadWrite(ride.downtime_history);
+                    cs.ReadWrite(ride.breakdown_sound_modifier);
+                    cs.ReadWrite(ride.not_fixed_timeout);
+                    cs.ReadWrite(ride.last_crash_type);
+                    cs.ReadWrite(ride.connected_message_throttle);
+
+                    cs.ReadWrite(ride.vehicle_change_timeout);
+
+                    cs.ReadWrite(ride.current_issues);
+                    cs.ReadWrite(ride.last_issue_time);
+
+
+                    cs.ReadWrite(ride.music);
+                    cs.ReadWrite(ride.music_tune_id);
+                    cs.ReadWrite(ride.music_position);
+                    return true;
+                });
+            });
+        }
+
+        static void ReadWriteRideMeasurement(OrcaStream::ChunkStream& cs, RideMeasurement& measurement)
+        {
+            cs.ReadWrite(measurement.flags);
+            cs.ReadWrite(measurement.last_use_tick);
+            cs.ReadWrite(measurement.num_items);
+            cs.ReadWrite(measurement.current_item);
+            cs.ReadWrite(measurement.vehicle_index);
+            cs.ReadWrite(measurement.current_station);
+            for (size_t i = 0; i < measurement.num_items; i++)
+            {
+                cs.ReadWrite(measurement.vertical[i]);
+                cs.ReadWrite(measurement.lateral[i]);
+                cs.ReadWrite(measurement.velocity[i]);
+                cs.ReadWrite(measurement.altitude[i]);
+            }
+        }
+
+        template<typename T> static void ReadWriteEntity(OrcaStream::ChunkStream& cs, T& entity);
+
+        static void ReadWriteEntityCommon(OrcaStream::ChunkStream& cs, SpriteBase& entity)
+        {
+            cs.ReadWrite(entity.sprite_index);
+            cs.ReadWrite(entity.sprite_height_negative);
+            cs.ReadWrite(entity.flags);
+            cs.ReadWrite(entity.x);
+            cs.ReadWrite(entity.y);
+            cs.ReadWrite(entity.z);
+            cs.ReadWrite(entity.sprite_width);
+            cs.ReadWrite(entity.sprite_height_positive);
+            cs.ReadWrite(entity.sprite_direction);
+        }
+
+        static void ReadWritePeep(OrcaStream::ChunkStream& cs, Peep& entity)
+        {
+            ReadWriteEntityCommon(cs, entity);
+            cs.ReadWrite(entity.Name);
+            cs.ReadWrite(entity.NextLoc);
+            cs.ReadWrite(entity.NextFlags);
+            cs.ReadWrite(entity.OutsideOfPark);
+            cs.ReadWrite(entity.State);
+            cs.ReadWrite(entity.SubState);
+            cs.ReadWrite(entity.SpriteType);
+            cs.ReadWrite(entity.GuestNumRides);
+            cs.ReadWrite(entity.TshirtColour);
+            cs.ReadWrite(entity.TrousersColour);
+            cs.ReadWrite(entity.DestinationX);
+            cs.ReadWrite(entity.DestinationY);
+            cs.ReadWrite(entity.DestinationTolerance);
+            cs.ReadWrite(entity.Var37);
+            cs.ReadWrite(entity.Energy);
+            cs.ReadWrite(entity.EnergyTarget);
+            cs.ReadWrite(entity.Happiness);
+            cs.ReadWrite(entity.HappinessTarget);
+            cs.ReadWrite(entity.Nausea);
+            cs.ReadWrite(entity.NauseaTarget);
+            cs.ReadWrite(entity.Hunger);
+            cs.ReadWrite(entity.Thirst);
+            cs.ReadWrite(entity.Toilet);
+            cs.ReadWrite(entity.Mass);
+            cs.ReadWrite(entity.TimeToConsume);
+            cs.ReadWrite(entity.Intensity);
+            cs.ReadWrite(entity.NauseaTolerance);
+            cs.ReadWrite(entity.WindowInvalidateFlags);
+            cs.ReadWrite(entity.PaidOnDrink);
+            cs.ReadWriteArray(entity.RideTypesBeenOn, [&cs](uint8_t& rideType) {
+                cs.ReadWrite(rideType);
+                return true;
+            });
+            cs.ReadWrite(entity.ItemFlags);
+            cs.ReadWrite(entity.Photo2RideRef);
+            cs.ReadWrite(entity.Photo3RideRef);
+            cs.ReadWrite(entity.Photo4RideRef);
+            cs.ReadWrite(entity.CurrentRide);
+            cs.ReadWrite(entity.CurrentRideStation);
+            cs.ReadWrite(entity.CurrentTrain);
+            cs.ReadWrite(entity.TimeToSitdown);
+            cs.ReadWrite(entity.SpecialSprite);
+            cs.ReadWrite(entity.ActionSpriteType);
+            cs.ReadWrite(entity.NextActionSpriteType);
+            cs.ReadWrite(entity.ActionSpriteImageOffset);
+            cs.ReadWrite(entity.Action);
+            cs.ReadWrite(entity.ActionFrame);
+            cs.ReadWrite(entity.StepProgress);
+            cs.ReadWrite(entity.GuestNextInQueue);
+            cs.ReadWrite(entity.PeepDirection);
+            cs.ReadWrite(entity.InteractionRideIndex);
+            cs.ReadWrite(entity.TimeInQueue);
+            cs.ReadWriteArray(entity.RidesBeenOn, [&cs](ride_id_t& rideId) {
+                cs.ReadWrite(rideId);
+                return true;
+            });
+            cs.ReadWrite(entity.Id);
+            cs.ReadWrite(entity.CashInPocket);
+            cs.ReadWrite(entity.CashSpent);
+
+            cs.ReadWrite(entity.ParkEntryTime);
+            cs.ReadWrite(entity.RejoinQueueTimeout);
+            cs.ReadWrite(entity.PreviousRide);
+            cs.ReadWrite(entity.PreviousRideTimeOut);
+            cs.ReadWriteArray(entity.Thoughts, [&cs](rct_peep_thought& thought) {
+                cs.ReadWrite(thought.type);
+                cs.ReadWrite(thought.item);
+                cs.ReadWrite(thought.freshness);
+                cs.ReadWrite(thought.fresh_timeout);
+                return true;
+            });
+            cs.ReadWrite(entity.PathCheckOptimisation);
+            cs.ReadWrite(entity.GuestHeadingToRideId);
+            cs.ReadWrite(entity.GuestIsLostCountdown);
+            cs.ReadWrite(entity.Photo1RideRef);
+            cs.ReadWrite(entity.PeepFlags);
+            cs.ReadWrite(entity.PathfindGoal);
+            for (size_t i = 0; i < std::size(entity.PathfindHistory); i++)
+            {
+                cs.ReadWrite(entity.PathfindHistory[i]);
+            }
+            cs.ReadWrite(entity.WalkingFrameNum);
+            cs.ReadWrite(entity.LitterCount);
+            cs.ReadWrite(entity.GuestTimeOnRide);
+            cs.ReadWrite(entity.DisgustingCount);
+            cs.ReadWrite(entity.PaidToEnter);
+            cs.ReadWrite(entity.PaidOnRides);
+            cs.ReadWrite(entity.PaidOnFood);
+            cs.ReadWrite(entity.PaidOnSouvenirs);
+            cs.ReadWrite(entity.AmountOfFood);
+            cs.ReadWrite(entity.AmountOfDrinks);
+            cs.ReadWrite(entity.AmountOfSouvenirs);
+            cs.ReadWrite(entity.VandalismSeen);
+            cs.ReadWrite(entity.VoucherType);
+            cs.ReadWrite(entity.VoucherRideId);
+            cs.ReadWrite(entity.SurroundingsThoughtTimeout);
+            cs.ReadWrite(entity.Angriness);
+            cs.ReadWrite(entity.TimeLost);
+            cs.ReadWrite(entity.DaysInQueue);
+            cs.ReadWrite(entity.BalloonColour);
+            cs.ReadWrite(entity.UmbrellaColour);
+            cs.ReadWrite(entity.HatColour);
+            cs.ReadWrite(entity.FavouriteRide);
+            cs.ReadWrite(entity.FavouriteRideRating);
+        }
+
+        template<typename T> void WriteEntitiesOfType(OrcaStream::ChunkStream& cs);
+        template<typename... T> void WriteEntitiesOfTypes(OrcaStream::ChunkStream& cs);
+
+        template<typename T> void ReadEntitiesOfType(OrcaStream::ChunkStream& cs);
+
+        template<typename... T> void ReadEntitiesOfTypes(OrcaStream::ChunkStream& cs);
+
+        void ReadWriteEntitiesChunk(OrcaStream& os);
+
+        void AutoDeriveVariables()
+        {
+            uint16_t numGuestsInPark = 0;
+            uint16_t numGuestsHeadingsForPark = 0;
+            for (auto guest : EntityList<Guest>())
+            {
+                if (guest->State == PeepState::EnteringPark)
+                {
+                    numGuestsHeadingsForPark++;
+                }
+                if (!guest->OutsideOfPark)
+                {
+                    numGuestsInPark++;
+                }
+            }
+
+            gNumGuestsInPark = numGuestsInPark;
+            gNumGuestsHeadingForPark = numGuestsHeadingsForPark;
+
+            auto& park = GetContext()->GetGameState()->GetPark();
+            gParkSize = park.CalculateParkSize();
+            gParkValue = park.CalculateParkValue();
+            gCompanyValue = park.CalculateCompanyValue();
+            gParkRating = park.CalculateParkRating();
+        }
+
+        static void ReadWriteStringTable(OrcaStream::ChunkStream& cs, std::string& value, const std::string_view& lcode)
+        {
+            std::vector<std::tuple<std::string, std::string>> table;
+            if (cs.GetMode() != OrcaStream::Mode::READING)
+            {
+                table.push_back(std::make_tuple(std::string(lcode), value));
+            }
+            cs.ReadWriteVector(table, [&cs](std::tuple<std::string, std::string>& v) {
+                cs.ReadWrite(std::get<0>(v));
+                cs.ReadWrite(std::get<1>(v));
+            });
+            if (cs.GetMode() == OrcaStream::Mode::READING)
+            {
+                auto fr = std::find_if(table.begin(), table.end(), [&lcode](const std::tuple<std::string, std::string>& v) {
+                    return std::get<0>(v) == lcode;
+                });
+                if (fr != table.end())
+                {
+                    value = std::get<1>(*fr);
+                }
+                else if (table.size() > 0)
+                {
+                    value = std::get<1>(table[0]);
+                }
+                else
+                {
+                    value = "";
+                }
+            }
+        }
+    };
+
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, Vehicle& entity)
+    {
+        ReadWriteEntityCommon(cs, entity);
+        cs.ReadWrite(entity.SubType);
+        cs.ReadWrite(entity.vehicle_sprite_type);
+        cs.ReadWrite(entity.bank_rotation);
+        cs.ReadWrite(entity.remaining_distance);
+        cs.ReadWrite(entity.velocity);
+        cs.ReadWrite(entity.acceleration);
+        cs.ReadWrite(entity.ride);
+        cs.ReadWrite(entity.vehicle_type);
+        cs.ReadWrite(entity.colours);
+        cs.ReadWrite(entity.track_progress);
+        cs.ReadWrite(entity.BoatLocation);
+        cs.ReadWrite(entity.TrackTypeAndDirection);
+        cs.ReadWrite(entity.TrackLocation.x);
+        cs.ReadWrite(entity.TrackLocation.y);
+        cs.ReadWrite(entity.TrackLocation.z);
+        cs.ReadWrite(entity.next_vehicle_on_train);
+        cs.ReadWrite(entity.prev_vehicle_on_ride);
+        cs.ReadWrite(entity.next_vehicle_on_ride);
+        cs.ReadWrite(entity.var_44);
+        cs.ReadWrite(entity.mass);
+        cs.ReadWrite(entity.update_flags);
+        cs.ReadWrite(entity.SwingSprite);
+        cs.ReadWrite(entity.current_station);
+        cs.ReadWrite(entity.current_time);
+        cs.ReadWrite(entity.crash_z);
+        cs.ReadWrite(entity.status);
+        cs.ReadWrite(entity.sub_state);
+        for (size_t i = 0; i < std::size(entity.peep); i++)
+        {
+            cs.ReadWrite(entity.peep[i]);
+            cs.ReadWrite(entity.peep_tshirt_colours[i]);
+        }
+        cs.ReadWrite(entity.num_seats);
+        cs.ReadWrite(entity.num_peeps);
+        cs.ReadWrite(entity.next_free_seat);
+        cs.ReadWrite(entity.restraints_position);
+        cs.ReadWrite(entity.crash_x);
+        cs.ReadWrite(entity.sound2_flags);
+        cs.ReadWrite(entity.spin_sprite);
+        cs.ReadWrite(entity.sound1_id);
+        cs.ReadWrite(entity.sound1_volume);
+        cs.ReadWrite(entity.sound2_id);
+        cs.ReadWrite(entity.sound2_volume);
+        cs.ReadWrite(entity.sound_vector_factor);
+        cs.ReadWrite(entity.time_waiting);
+        cs.ReadWrite(entity.speed);
+        cs.ReadWrite(entity.powered_acceleration);
+        cs.ReadWrite(entity.dodgems_collision_direction);
+        cs.ReadWrite(entity.animation_frame);
+        cs.ReadWrite(entity.var_C8);
+        cs.ReadWrite(entity.var_CA);
+        cs.ReadWrite(entity.scream_sound_id);
+        cs.ReadWrite(entity.TrackSubposition);
+        cs.ReadWrite(entity.var_CE);
+        cs.ReadWrite(entity.var_CF);
+        cs.ReadWrite(entity.lost_time_out);
+        cs.ReadWrite(entity.vertical_drop_countdown);
+        cs.ReadWrite(entity.var_D3);
+        cs.ReadWrite(entity.mini_golf_current_animation);
+        cs.ReadWrite(entity.mini_golf_flags);
+        cs.ReadWrite(entity.ride_subtype);
+        cs.ReadWrite(entity.colours_extended);
+        cs.ReadWrite(entity.seat_rotation);
+        cs.ReadWrite(entity.target_seat_rotation);
+    }
+
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, Guest& entity)
+    {
+        ReadWritePeep(cs, entity);
+    }
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, Staff& entity)
+    {
+        ReadWritePeep(cs, entity);
+    }
+
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, SteamParticle& steamParticle)
+    {
+        ReadWriteEntityCommon(cs, steamParticle);
+        cs.ReadWrite(steamParticle.time_to_move);
+        cs.ReadWrite(steamParticle.frame);
+    }
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, MoneyEffect& moneyEffect)
+    {
+        ReadWriteEntityCommon(cs, moneyEffect);
+        cs.ReadWrite(moneyEffect.MoveDelay);
+        cs.ReadWrite(moneyEffect.NumMovements);
+        cs.ReadWrite(moneyEffect.Vertical);
+        cs.ReadWrite(moneyEffect.Value);
+        cs.ReadWrite(moneyEffect.OffsetX);
+        cs.ReadWrite(moneyEffect.Wiggle);
+    }
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, VehicleCrashParticle& vehicleCrashParticle)
+    {
+        ReadWriteEntityCommon(cs, vehicleCrashParticle);
+        cs.ReadWrite(vehicleCrashParticle.frame);
+        cs.ReadWrite(vehicleCrashParticle.time_to_live);
+        cs.ReadWrite(vehicleCrashParticle.frame);
+        cs.ReadWrite(vehicleCrashParticle.colour[0]);
+        cs.ReadWrite(vehicleCrashParticle.colour[1]);
+        cs.ReadWrite(vehicleCrashParticle.crashed_sprite_base);
+        cs.ReadWrite(vehicleCrashParticle.velocity_x);
+        cs.ReadWrite(vehicleCrashParticle.velocity_y);
+        cs.ReadWrite(vehicleCrashParticle.velocity_z);
+        cs.ReadWrite(vehicleCrashParticle.acceleration_x);
+        cs.ReadWrite(vehicleCrashParticle.acceleration_y);
+        cs.ReadWrite(vehicleCrashParticle.acceleration_z);
+    }
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, ExplosionCloud& entity)
+    {
+        ReadWriteEntityCommon(cs, entity);
+        cs.ReadWrite(entity.frame);
+    }
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, CrashSplashParticle& entity)
+    {
+        ReadWriteEntityCommon(cs, entity);
+        cs.ReadWrite(entity.frame);
+    }
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, ExplosionFlare& entity)
+    {
+        ReadWriteEntityCommon(cs, entity);
+        cs.ReadWrite(entity.frame);
+    }
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, JumpingFountain& fountain)
+    {
+        ReadWriteEntityCommon(cs, fountain);
+        cs.ReadWrite(fountain.NumTicksAlive);
+        cs.ReadWrite(fountain.frame);
+        cs.ReadWrite(fountain.FountainFlags);
+        cs.ReadWrite(fountain.TargetX);
+        cs.ReadWrite(fountain.TargetY);
+        cs.ReadWrite(fountain.TargetY);
+        cs.ReadWrite(fountain.Iteration);
+    }
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, Balloon& balloon)
+    {
+        ReadWriteEntityCommon(cs, balloon);
+        cs.ReadWrite(balloon.popped);
+        cs.ReadWrite(balloon.time_to_move);
+        cs.ReadWrite(balloon.frame);
+        cs.ReadWrite(balloon.colour);
+    }
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, Duck& duck)
+    {
+        ReadWriteEntityCommon(cs, duck);
+        cs.ReadWrite(duck.frame);
+        cs.ReadWrite(duck.target_x);
+        cs.ReadWrite(duck.target_y);
+        cs.ReadWrite(duck.state);
+    }
+
+    template<> void ParkFile::ReadWriteEntity(OrcaStream::ChunkStream& cs, Litter& entity)
+    {
+        ReadWriteEntityCommon(cs, entity);
+        cs.ReadWrite(entity.SubType);
+        cs.ReadWrite(entity.creationTick);
+    }
+    template<typename T> void ParkFile::WriteEntitiesOfType(OrcaStream::ChunkStream& cs)
+    {
+        uint16_t count = GetEntityListCount(T::cEntityType);
+        cs.Write(T::cEntityType);
+        cs.Write(count);
+        for (auto* ent : EntityList<T>())
+        {
+            cs.Write(ent->sprite_index);
+            ReadWriteEntity(cs, *ent);
+        }
+    }
+
+    template<typename... T> void ParkFile::WriteEntitiesOfTypes(OrcaStream::ChunkStream& cs)
+    {
+        (WriteEntitiesOfType<T>(cs), ...);
+    }
+
+    template<typename T> void ParkFile::ReadEntitiesOfType(OrcaStream::ChunkStream& cs)
+    {
+        [[maybe_unused]] auto t = cs.Read<EntityType>();
+        
+# 1228 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 3 4
+       (static_cast <bool> (
+# 1228 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp"
+       t == T::cEntityType
+# 1228 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 3 4
+       ) ? void (0) : __assert_fail (
+# 1228 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp"
+       "t == T::cEntityType"
+# 1228 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp" 3 4
+       , "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp", 1228, __extension__ __PRETTY_FUNCTION__))
+# 1228 "/home/ted/dev/openrct2/src/openrct2/ParkFile.cpp"
+                                  ;
+        auto count = cs.Read<uint16_t>();
+        for (auto i = 0; i < count; ++i)
+        {
+            T placeholder{};
+
+            auto index = cs.Read<uint16_t>();
+            auto* ent = CreateEntityAt<T>(index);
+            if (ent == nullptr)
+            {
+
+                ent = &placeholder;
+            }
+            ReadWriteEntity(cs, *ent);
+        }
+    }
+
+    template<typename... T> void ParkFile::ReadEntitiesOfTypes(OrcaStream::ChunkStream& cs)
+    {
+        (ReadEntitiesOfType<T>(cs), ...);
+    }
+
+    void ParkFile::ReadWriteEntitiesChunk(OrcaStream& os)
+    {
+        os.ReadWriteChunk(ParkFileChunkType::ENTITIES, [this](OrcaStream::ChunkStream& cs) {
+            if (cs.GetMode() == OrcaStream::Mode::READING)
+            {
+                reset_sprite_list();
+            }
+
+            std::vector<uint16_t> entityIndices;
+            if (cs.GetMode() == OrcaStream::Mode::READING)
+            {
+                ReadEntitiesOfTypes<
+                    Vehicle, Guest, Staff, Litter, SteamParticle, MoneyEffect, VehicleCrashParticle, ExplosionCloud,
+                    CrashSplashParticle, ExplosionFlare, JumpingFountain, Balloon, Duck>(cs);
+            }
+            else
+            {
+                WriteEntitiesOfTypes<
+                    Vehicle, Guest, Staff, Litter, SteamParticle, MoneyEffect, VehicleCrashParticle, ExplosionCloud,
+                    CrashSplashParticle, ExplosionFlare, JumpingFountain, Balloon, Duck>(cs);
+            }
+        });
+    }
+}
+
+void ParkFileExporter::Export(std::string_view path)
+{
+    map_reorganise_elements();
+
+    auto parkFile = std::make_unique<OpenRCT2::ParkFile>();
+    parkFile->Save(path);
+}
+
+void ParkFileExporter::Export(IStream& stream)
+{
+    map_reorganise_elements();
+
+    auto parkFile = std::make_unique<OpenRCT2::ParkFile>();
+    parkFile->Save(stream);
+}
+
+enum : uint32_t
+{
+    S6_SAVE_FLAG_EXPORT = 1 << 0,
+    S6_SAVE_FLAG_SCENARIO = 1 << 1,
+    S6_SAVE_FLAG_AUTOMATIC = 1u << 31,
+};
+
+int32_t scenario_save(const utf8* path, int32_t flags)
+{
+    if (flags & S6_SAVE_FLAG_SCENARIO)
+    {
+        diagnostic_log(DiagnosticLevel::Verbose, "saving scenario");
+    }
+    else
+    {
+        diagnostic_log(DiagnosticLevel::Verbose, "saving game");
+    }
+
+    if (!(flags & S6_SAVE_FLAG_AUTOMATIC))
+    {
+        window_close_construction_windows();
+    }
+
+    map_reorganise_elements();
+    viewport_set_saved_view();
+
+    bool result = false;
+    auto parkFile = std::make_unique<OpenRCT2::ParkFile>();
+    try
+    {
+
+
+
+
+
+
+
+        if (flags & S6_SAVE_FLAG_SCENARIO)
+        {
+
+        }
+        else
+        {
+
+        }
+        parkFile->Save(path);
+        result = true;
+    }
+    catch (const std::exception&)
+    {
+    }
+
+    gfx_invalidate_screen();
+
+    if (result && !(flags & S6_SAVE_FLAG_AUTOMATIC))
+    {
+        gScreenAge = 0;
+    }
+    return result;
+}
+
+class ParkFileImporter : public IParkImporter
+{
+private:
+
+
+
+    const IObjectRepository& _objectRepository;
+    std::unique_ptr<OpenRCT2::ParkFile> _parkFile;
+
+public:
+    ParkFileImporter(IObjectRepository& objectRepository)
+        : _objectRepository(objectRepository)
+    {
+    }
+
+    ParkLoadResult Load(const utf8* path) override
+    {
+        _parkFile = std::make_unique<OpenRCT2::ParkFile>();
+        _parkFile->Load(path);
+        return ParkLoadResult(std::move(_parkFile->RequiredObjects));
+    }
+
+    ParkLoadResult LoadSavedGame(const utf8* path, bool skipObjectCheck = false) override
+    {
+        return Load(path);
+    }
+
+    ParkLoadResult LoadScenario(const utf8* path, bool skipObjectCheck = false) override
+    {
+        return Load(path);
+    }
+
+    ParkLoadResult LoadFromStream(
+        OpenRCT2::IStream* stream, bool isScenario, bool skipObjectCheck = false, const utf8* path = String::Empty) override
+    {
+        _parkFile = std::make_unique<OpenRCT2::ParkFile>();
+        _parkFile->Load(*stream);
+        return ParkLoadResult(std::move(_parkFile->RequiredObjects));
+    }
+
+    void Import() override
+    {
+        _parkFile->Import();
+    }
+
+    bool GetDetails(scenario_index_entry* dst) override
+    {
+        return false;
+    }
+};
+
+std::unique_ptr<IParkImporter> ParkImporter::CreateParkFile(IObjectRepository& objectRepository)
+{
+    return std::make_unique<ParkFileImporter>(objectRepository);
+}
diff --git a/src/openrct2/ParkFile.cpp b/src/openrct2/ParkFile.cpp
index 8fd1ab69aa..b5ae354084 100644
--- a/src/openrct2/ParkFile.cpp
+++ b/src/openrct2/ParkFile.cpp
@@ -83,8 +83,6 @@ namespace OpenRCT2
 //        constexpr uint32_t ANIMATIONS       = 0x34;
 //        constexpr uint32_t STAFF            = 0x35;
         constexpr uint32_t CHEATS           = 0x36;
-
-//        constexpr uint32_t DERIVED          = 0x50;
         // clang-format on
     }; // namespace ParkFileChunkType
 
@@ -130,8 +128,6 @@ namespace OpenRCT2
             gInitialCash = gCash;
             String::Set(gS6Info.name, sizeof(gS6Info.name), gScenarioName.c_str());
             String::Set(gS6Info.details, sizeof(gS6Info.details), gScenarioName.c_str());
-
-            AutoDeriveVariables();
         }
 
         void Save(IStream& stream)
@@ -175,9 +171,9 @@ namespace OpenRCT2
                     cs.Write(std::string_view(gVersionInfoFull));
                     std::vector<std::string> authors;
                     cs.ReadWriteVector(authors, [](std::string& s) {});
-                    cs.Write(std::string_view());     // custom notes that can be attached to the save
-                    cs.Write<uint64_t>(std::time(0)); // date started
-                    cs.Write<uint64_t>(std::time(0)); // date modified
+                    cs.Write(std::string_view());                  // custom notes that can be attached to the save
+                    cs.Write(static_cast<uint64_t>(std::time(0))); // date started
+                    cs.Write(static_cast<uint64_t>(std::time(0))); // date modified
                 });
             }
         }
@@ -207,7 +203,7 @@ namespace OpenRCT2
                                 case DESCRIPTOR_NONE:
                                     break;
                                 case DESCRIPTOR_DAT:
-                                    desc.Entry = cs.Read<rct_object_entry>();
+                                    cs.Read(&desc.Entry, sizeof(rct_object_entry));
                                     requiredObjects.SetObject(j, desc);
                                     break;
                                 case DESCRIPTOR_JSON:
@@ -251,7 +247,7 @@ namespace OpenRCT2
                                 else
                                 {
                                     cs.Write(DESCRIPTOR_DAT);
-                                    cs.Write(entry.Entry);
+                                    cs.Write(&entry.Entry, sizeof(rct_object_entry));
                                 }
                             }
                             else
@@ -267,7 +263,7 @@ namespace OpenRCT2
         void ReadWriteScenarioChunk(OrcaStream& os)
         {
             os.ReadWriteChunk(ParkFileChunkType::SCENARIO, [](OrcaStream::ChunkStream& cs) {
-                cs.ReadWriteAs<uint8_t, uint32_t>(gS6Info.category);
+                cs.ReadWrite(gS6Info.category);
                 ReadWriteStringTable(cs, gScenarioName, "en-GB");
 
                 auto& park = GetContext()->GetGameState()->GetPark();
@@ -284,7 +280,10 @@ namespace OpenRCT2
                 //                cs.ReadWrite<money32>(gScenarioObjectiveCurrency);               // park value
                 //                cs.ReadWrite<money32>(gScenarioObjectiveCurrency);               // ride profit
                 //                cs.ReadWrite<money32>(gScenarioObjectiveCurrency);               // shop profit
-                cs.ReadWrite<Objective>(gScenarioObjective);
+                cs.ReadWrite(gScenarioObjective.Type);
+                cs.ReadWrite(gScenarioObjective.Year);
+                cs.ReadWrite(gScenarioObjective.NumGuests);
+                cs.ReadWrite(gScenarioObjective.Currency);
 
                 cs.ReadWrite(gScenarioParkRatingWarningDays);
 
@@ -318,8 +317,8 @@ namespace OpenRCT2
         {
             auto found = os.ReadWriteChunk(ParkFileChunkType::GENERAL, [](OrcaStream::ChunkStream& cs) {
                 cs.ReadWrite(gGamePaused);
-                cs.ReadWriteAs<uint32_t, uint64_t>(gScenarioTicks);
-                cs.ReadWriteAs<uint16_t, uint32_t>(gDateMonthTicks);
+                cs.ReadWrite(gScenarioTicks);
+                cs.ReadWrite(gDateMonthTicks);
                 cs.ReadWrite(gDateMonthsElapsed);
 
                 if (cs.GetMode() == OrcaStream::Mode::READING)
@@ -362,10 +361,18 @@ namespace OpenRCT2
         void ReadWriteInterfaceChunk(OrcaStream& os)
         {
             os.ReadWriteChunk(ParkFileChunkType::INTERFACE, [](OrcaStream::ChunkStream& cs) {
-                cs.ReadWrite(gSavedView);
-                cs.ReadWrite(gSavedViewZoom);
+                cs.ReadWrite(gSavedView.x);
+                cs.ReadWrite(gSavedView.y);
+                if (cs.GetMode() == OrcaStream::Mode::READING)
+                {
+                    gSavedViewZoom = static_cast<ZoomLevel>(cs.Read<int8_t>());
+                }
+                else
+                {
+                    cs.Write(static_cast<int8_t>(gSavedViewZoom));
+                }
                 cs.ReadWrite(gSavedViewRotation);
-                cs.ReadWriteAs<uint8_t, uint32_t>(gLastEntranceStyle);
+                cs.ReadWrite(gLastEntranceStyle);
             });
         }
 
@@ -383,7 +390,7 @@ namespace OpenRCT2
                 cs.ReadWrite(gClimate);
                 cs.ReadWrite(gClimateUpdateTimer);
 
-                for (const auto* cl : { &gClimateCurrent, &gClimateNext })
+                for (auto* cl : { &gClimateCurrent, &gClimateNext })
                 {
                     cs.ReadWrite(cl->Weather);
                     cs.ReadWrite(cl->Temperature);
@@ -402,9 +409,9 @@ namespace OpenRCT2
                 cs.ReadWrite(gCash);
                 cs.ReadWrite(gBankLoan);
                 cs.ReadWrite(gMaxBankLoan);
-                cs.ReadWriteAs<uint8_t, uint16_t>(gBankLoanInterestRate);
-                cs.ReadWriteAs<uint32_t, uint64_t>(gParkFlags);
-                cs.ReadWriteAs<money16, money32>(gParkEntranceFee);
+                cs.ReadWrite(gBankLoanInterestRate);
+                cs.ReadWrite(gParkFlags);
+                cs.ReadWrite(gParkEntranceFee);
                 cs.ReadWrite(gStaffHandymanColour);
                 cs.ReadWrite(gStaffMechanicColour);
                 cs.ReadWrite(gStaffSecurityColour);
@@ -432,8 +439,12 @@ namespace OpenRCT2
                     }
                 });
 
-                cs.ReadWriteAs<money32, money64>(gParkValue);
-                cs.ReadWriteAs<uint16_t, uint32_t>(gParkRating);
+                cs.ReadWrite(gParkValue);
+                cs.ReadWrite(gCompanyValue);
+                cs.ReadWrite(gParkSize);
+                cs.ReadWrite(gNumGuestsInPark);
+                cs.ReadWrite(gNumGuestsHeadingForPark);
+                cs.ReadWrite(gParkRating);
                 cs.ReadWrite(gParkRatingCasualtyPenalty);
                 cs.ReadWrite(gCurrentExpenditure);
                 cs.ReadWrite(gCurrentProfit);
@@ -550,26 +561,11 @@ namespace OpenRCT2
             }
         }
 
-        void ReadWriteDerivedChunk(OrcaStream& os)
-        {
-            if (os.GetMode() == OrcaStream::Mode::WRITING)
-            {
-                os.ReadWriteChunk(ParkFileChunkType::NOTIFICATIONS, [](OrcaStream::ChunkStream& cs) {
-                    cs.Write<uint32_t>(gParkSize);
-                    cs.Write<uint32_t>(gNumGuestsInPark);
-                    cs.Write<uint32_t>(gNumGuestsHeadingForPark);
-                    cs.Write<uint32_t>(gCompanyValue);
-                    cs.Write<uint32_t>(gParkValue);
-                    cs.Write<uint32_t>(gParkRating);
-                });
-            }
-        }
-
         void ReadWriteTilesChunk(OrcaStream& os)
         {
             auto found = os.ReadWriteChunk(ParkFileChunkType::TILES, [](OrcaStream::ChunkStream& cs) {
-                cs.ReadWriteAs<int16_t, uint32_t>(gMapSize); // x
-                cs.Write<uint32_t>(gMapSize);                // y
+                cs.ReadWrite(gMapSize); // x
+                cs.Write(gMapSize);     // y
 
                 if (cs.GetMode() == OrcaStream::Mode::READING)
                 {
@@ -607,7 +603,8 @@ namespace OpenRCT2
                     cs.ReadWrite(banner.colour);
                     cs.ReadWrite(banner.ride_index);
                     cs.ReadWrite(banner.text_colour);
-                    cs.ReadWrite(banner.position);
+                    cs.ReadWrite(banner.position.x);
+                    cs.ReadWrite(banner.position.y);
                 });
                 if (cs.GetMode() == OrcaStream::Mode::READING)
                 {
@@ -667,7 +664,9 @@ namespace OpenRCT2
                     });
 
                     cs.ReadWriteArray(ride.vehicle_colours, [&cs](VehicleColour& vc) {
-                        cs.ReadWrite(vc);
+                        cs.ReadWrite(vc.Body);
+                        cs.ReadWrite(vc.Trim);
+                        cs.ReadWrite(vc.Ternary);
                         return true;
                     });
 
@@ -689,7 +688,8 @@ namespace OpenRCT2
                         return true;
                     });
 
-                    cs.ReadWrite(ride.overall_view);
+                    cs.ReadWrite(ride.overall_view.x);
+                    cs.ReadWrite(ride.overall_view.y);
 
                     // Vehicles
                     cs.ReadWrite(ride.num_vehicles);
@@ -789,7 +789,12 @@ namespace OpenRCT2
 
                     cs.ReadWrite(ride.cur_num_customers);
                     cs.ReadWrite(ride.num_customers_timeout);
-                    cs.ReadWrite(ride.num_customers);
+
+                    cs.ReadWriteArray(ride.num_customers, [&cs](uint16_t& v) {
+                        cs.ReadWrite(v);
+                        return true;
+                    });
+
                     cs.ReadWrite(ride.total_customers);
                     cs.ReadWrite(ride.total_profit);
                     cs.ReadWrite(ride.popularity);
@@ -818,7 +823,12 @@ namespace OpenRCT2
                     cs.ReadWrite(ride.downtime);
                     cs.ReadWrite(ride.inspection_interval);
                     cs.ReadWrite(ride.last_inspection);
-                    cs.ReadWrite(ride.downtime_history);
+
+                    cs.ReadWriteArray(ride.downtime_history, [&cs](uint8_t& v) {
+                        cs.ReadWrite(v);
+                        return true;
+                    });
+
                     cs.ReadWrite(ride.breakdown_sound_modifier);
                     cs.ReadWrite(ride.not_fixed_timeout);
                     cs.ReadWrite(ride.last_crash_type);
@@ -873,7 +883,15 @@ namespace OpenRCT2
         static void ReadWritePeep(OrcaStream::ChunkStream& cs, Peep& entity)
         {
             ReadWriteEntityCommon(cs, entity);
-            cs.ReadWrite(entity.Name);
+            if (cs.GetMode() == OrcaStream::Mode::READING)
+            {
+                auto name = cs.Read<std::string>();
+                entity.SetName(name);
+            }
+            else
+            {
+                cs.Write(static_cast<const char*>(entity.Name));
+            }
             cs.ReadWrite(entity.NextLoc);
             cs.ReadWrite(entity.NextFlags);
             cs.ReadWrite(entity.OutsideOfPark);
@@ -898,7 +916,16 @@ namespace OpenRCT2
             cs.ReadWrite(entity.Toilet);
             cs.ReadWrite(entity.Mass);
             cs.ReadWrite(entity.TimeToConsume);
-            cs.ReadWrite(entity.Intensity);
+
+            if (cs.GetMode() == OrcaStream::Mode::READING)
+            {
+                entity.Intensity = IntensityRange(cs.Read<uint8_t>());
+            }
+            else
+            {
+                cs.Write(static_cast<uint8_t>(entity.Intensity));
+            }
+
             cs.ReadWrite(entity.NauseaTolerance);
             cs.ReadWrite(entity.WindowInvalidateFlags);
             cs.ReadWrite(entity.PaidOnDrink);
@@ -949,10 +976,16 @@ namespace OpenRCT2
             cs.ReadWrite(entity.GuestIsLostCountdown);
             cs.ReadWrite(entity.Photo1RideRef);
             cs.ReadWrite(entity.PeepFlags);
-            cs.ReadWrite(entity.PathfindGoal);
+            cs.ReadWrite(entity.PathfindGoal.x);
+            cs.ReadWrite(entity.PathfindGoal.y);
+            cs.ReadWrite(entity.PathfindGoal.z);
+            cs.ReadWrite(entity.PathfindGoal.direction);
             for (size_t i = 0; i < std::size(entity.PathfindHistory); i++)
             {
-                cs.ReadWrite(entity.PathfindHistory[i]);
+                cs.ReadWrite(entity.PathfindHistory[i].x);
+                cs.ReadWrite(entity.PathfindHistory[i].y);
+                cs.ReadWrite(entity.PathfindHistory[i].z);
+                cs.ReadWrite(entity.PathfindHistory[i].direction);
             }
             cs.ReadWrite(entity.WalkingFrameNum);
             cs.ReadWrite(entity.LitterCount);
@@ -988,32 +1021,6 @@ namespace OpenRCT2
 
         void ReadWriteEntitiesChunk(OrcaStream& os);
 
-        void AutoDeriveVariables()
-        {
-            uint16_t numGuestsInPark = 0;
-            uint16_t numGuestsHeadingsForPark = 0;
-            for (auto guest : EntityList<Guest>())
-            {
-                if (guest->State == PeepState::EnteringPark)
-                {
-                    numGuestsHeadingsForPark++;
-                }
-                if (!guest->OutsideOfPark)
-                {
-                    numGuestsInPark++;
-                }
-            }
-
-            gNumGuestsInPark = numGuestsInPark;
-            gNumGuestsHeadingForPark = numGuestsHeadingsForPark;
-
-            auto& park = GetContext()->GetGameState()->GetPark();
-            gParkSize = park.CalculateParkSize();
-            gParkValue = park.CalculateParkValue();
-            gCompanyValue = park.CalculateCompanyValue();
-            gParkRating = park.CalculateParkRating();
-        }
-
         static void ReadWriteStringTable(OrcaStream::ChunkStream& cs, std::string& value, const std::string_view& lcode)
         {
             std::vector<std::tuple<std::string, std::string>> table;
@@ -1057,7 +1064,8 @@ namespace OpenRCT2
         cs.ReadWrite(entity.acceleration);
         cs.ReadWrite(entity.ride);
         cs.ReadWrite(entity.vehicle_type);
-        cs.ReadWrite(entity.colours);
+        cs.ReadWrite(entity.colours.body_colour);
+        cs.ReadWrite(entity.colours.trim_colour);
         cs.ReadWrite(entity.track_progress);
         cs.ReadWrite(entity.BoatLocation);
         cs.ReadWrite(entity.TrackTypeAndDirection);
diff --git a/src/openrct2/core/OrcaStream.hpp b/src/openrct2/core/OrcaStream.hpp
index 9f2eb5cbb1..127de3c0d8 100644
--- a/src/openrct2/core/OrcaStream.hpp
+++ b/src/openrct2/core/OrcaStream.hpp
@@ -9,6 +9,7 @@
 
 #pragma once
 
+#include "../world/Location.hpp"
 #include "Crypt.h"
 #include "FileStream.h"
 #include "MemoryStream.h"
@@ -19,6 +20,7 @@
 #include <fstream>
 #include <sstream>
 #include <stack>
+#include <type_traits>
 #include <vector>
 
 namespace OpenRCT2
@@ -98,7 +100,8 @@ namespace OpenRCT2
                 if (_header.Compression == COMPRESSION_GZIP)
                 {
                     size_t outUncompressedSize{};
-                    auto uncompressedData = util_zlib_inflate(reinterpret_cast<const uint8_t*>(_buffer.GetData()), _buffer.GetLength(), &outUncompressedSize);
+                    auto uncompressedData = util_zlib_inflate(
+                        reinterpret_cast<const uint8_t*>(_buffer.GetData()), _buffer.GetLength(), &outUncompressedSize);
                     if (_header.UncompressedSize != outUncompressedSize)
                     {
                         // Warning?
@@ -270,26 +273,98 @@ namespace OpenRCT2
                 }
             }
 
-            template<typename T> void ReadWrite(T& v)
+            void Read(void* addr, size_t len)
             {
-                ReadWrite(const_cast<void*>(reinterpret_cast<const void*>(&v)), sizeof(T));
-            }
-
-            template<typename TMem, typename TSave> void ReadWriteAs(TMem& v)
-            {
-                TSave sv;
-                if (_mode != Mode::READING)
-                {
-                    sv = v;
-                }
-                ReadWrite(reinterpret_cast<void*>(&sv), sizeof(TSave));
                 if (_mode == Mode::READING)
                 {
-                    v = static_cast<TMem>(sv);
+                    ReadBuffer(addr, len);
+                }
+                else
+                {
+                    throw std::runtime_error("Incorrect mode");
                 }
             }
 
-            template<typename T> T Read()
+            void Write(const void* addr, size_t len)
+            {
+                if (_mode == Mode::READING)
+                {
+                    throw std::runtime_error("Incorrect mode");
+                }
+                else
+                {
+                    WriteBuffer(addr, len);
+                }
+            }
+
+            template<typename T, std::enable_if_t<std::is_integral<T>::value, bool> = true> void ReadWrite(T& v)
+            {
+                if (_mode == Mode::READING)
+                {
+                    v = ReadInteger<T>();
+                }
+                else
+                {
+                    WriteInteger(v);
+                }
+            }
+
+            template<typename T, std::enable_if_t<std::is_enum<T>::value, bool> = true> void ReadWrite(T& v)
+            {
+                using underlying = typename std::underlying_type<T>::type;
+                if (_mode == Mode::READING)
+                {
+                    v = static_cast<T>(ReadInteger<underlying>());
+                }
+                else
+                {
+                    WriteInteger(static_cast<underlying>(v));
+                }
+            }
+
+            void ReadWrite(CoordsXY& coords)
+            {
+                ReadWrite(coords.x);
+                ReadWrite(coords.y);
+            }
+
+            void ReadWrite(CoordsXYZ& coords)
+            {
+                ReadWrite(coords.x);
+                ReadWrite(coords.y);
+                ReadWrite(coords.z);
+            }
+
+            void ReadWrite(CoordsXYZD& coords)
+            {
+                ReadWrite(coords.x);
+                ReadWrite(coords.y);
+                ReadWrite(coords.z);
+                ReadWrite(coords.direction);
+            }
+
+            void ReadWrite(TileCoordsXY& coords)
+            {
+                ReadWrite(coords.x);
+                ReadWrite(coords.y);
+            }
+
+            void ReadWrite(TileCoordsXYZ& coords)
+            {
+                ReadWrite(coords.x);
+                ReadWrite(coords.y);
+                ReadWrite(coords.z);
+            }
+
+            void ReadWrite(TileCoordsXYZD& coords)
+            {
+                ReadWrite(coords.x);
+                ReadWrite(coords.y);
+                ReadWrite(coords.z);
+                ReadWrite(coords.direction);
+            }
+
+            template<typename T, typename = std::enable_if<std::is_integral<T>::value>> T Read()
             {
                 T v{};
                 ReadWrite(v);
@@ -313,7 +388,7 @@ namespace OpenRCT2
                 }
             }
 
-            template<typename T> void Write(const T& v)
+            template<typename T, typename = std::enable_if<std::is_integral<T>::value>> void Write(T v)
             {
                 if (_mode == Mode::READING)
                 {
@@ -326,6 +401,14 @@ namespace OpenRCT2
                 }
             }
 
+            void Write(const char* v)
+            {
+                std::string_view sv;
+                if (v != nullptr)
+                    sv = v;
+                Write(sv);
+            }
+
 #if defined(_MSC_VER)
             template<>
 #endif
@@ -420,6 +503,78 @@ namespace OpenRCT2
                 _buffer.Write(buffer, len);
             }
 
+            template<typename T, typename = std::enable_if<std::is_integral<T>::value>> T ReadInteger()
+            {
+                if (sizeof(T) > 4)
+                {
+                    if (std::is_signed<T>())
+                    {
+                        int64_t raw{};
+                        Read(&raw, sizeof(raw));
+                        return static_cast<T>(raw);
+                    }
+                    else
+                    {
+                        uint64_t raw{};
+                        Read(&raw, sizeof(raw));
+                        return static_cast<T>(raw);
+                    }
+                }
+                else
+                {
+                    if (std::is_signed<T>())
+                    {
+                        int32_t raw{};
+                        Read(&raw, sizeof(raw));
+                        if (raw < std::numeric_limits<T>::min() || raw > std::numeric_limits<T>::max())
+                        {
+                            throw std::runtime_error("Value is incompatible with internal type.");
+                        }
+                        return static_cast<T>(raw);
+                    }
+                    else
+                    {
+                        uint32_t raw{};
+                        Read(&raw, sizeof(raw));
+                        if (raw > std::numeric_limits<T>::max())
+                        {
+                            throw std::runtime_error("Value is incompatible with internal type.");
+                        }
+                        return static_cast<T>(raw);
+                    }
+                }
+            }
+
+            template<typename T, typename = std::enable_if<std::is_integral<T>::value>> void WriteInteger(T value)
+            {
+                if (sizeof(T) > 4)
+                {
+                    if (std::is_signed<T>())
+                    {
+                        auto raw = static_cast<int64_t>(value);
+                        Write(&raw, sizeof(raw));
+                    }
+                    else
+                    {
+                        auto raw = static_cast<uint64_t>(value);
+                        Write(&raw, sizeof(raw));
+                    }
+                }
+                else
+                {
+                    if (std::is_signed<T>())
+                    {
+                        auto raw = static_cast<int32_t>(value);
+                        Write(&raw, sizeof(raw));
+                    }
+                    else
+                    {
+                        auto raw = static_cast<uint32_t>(value);
+                        Write(&raw, sizeof(raw));
+                    }
+                }
+            }
+
             std::string ReadString()
             {
                 std::string buffer;
diff --git a/src/openrct2/scenario/Scenario.cpp b/src/openrct2/scenario/Scenario.cpp
index 1a9bd8f4e0..3f2b61ae41 100644
--- a/src/openrct2/scenario/Scenario.cpp
+++ b/src/openrct2/scenario/Scenario.cpp
@@ -67,7 +67,7 @@ bool gFirstTimeSaving = true;
 uint16_t gSavedAge;
 uint32_t gLastAutoSaveUpdate = 0;
 
-uint32_t gScenarioTicks;
+uint64_t gScenarioTicks;
 random_engine_t gScenarioRand;
 
 Objective gScenarioObjective;
diff --git a/src/openrct2/scenario/Scenario.h b/src/openrct2/scenario/Scenario.h
index 362479d6fd..84defbb5dd 100644
--- a/src/openrct2/scenario/Scenario.h
+++ b/src/openrct2/scenario/Scenario.h
@@ -427,7 +427,7 @@ static constexpr money32 COMPANY_VALUE_ON_FAILED_OBJECTIVE = 0x80000001;
 
 extern const rct_string_id ScenarioCategoryStringIds[SCENARIO_CATEGORY_COUNT];
 
-extern uint32_t gScenarioTicks;
+extern uint64_t gScenarioTicks;
 extern random_engine_t gScenarioRand;
 
 extern Objective gScenarioObjective;
diff --git a/src/openrct2/world/Park.cpp b/src/openrct2/world/Park.cpp
index 794a2d4850..b1793a8b18 100644
--- a/src/openrct2/world/Park.cpp
+++ b/src/openrct2/world/Park.cpp
@@ -45,18 +45,18 @@
 
 using namespace OpenRCT2;
 
-uint32_t gParkFlags;
+uint64_t gParkFlags;
 uint16_t gParkRating;
 money16 gParkEntranceFee;
 uint16_t gParkSize;
 money16 gLandPrice;
 money16 gConstructionRightsPrice;
 
-uint32_t gTotalAdmissions;
-money32 gTotalIncomeFromAdmissions;
+uint64_t gTotalAdmissions;
+money64 gTotalIncomeFromAdmissions;
 
-money32 gParkValue;
-money32 gCompanyValue;
+money64 gParkValue;
+money64 gCompanyValue;
 
 int16_t gParkRatingCasualtyPenalty;
 uint8_t gParkRatingHistory[32];
diff --git a/src/openrct2/world/Park.h b/src/openrct2/world/Park.h
index 46f159089c..43c1cbf59a 100644
--- a/src/openrct2/world/Park.h
+++ b/src/openrct2/world/Park.h
@@ -89,18 +89,18 @@ namespace OpenRCT2
     };
 } // namespace OpenRCT2
 
-extern uint32_t gParkFlags;
+extern uint64_t gParkFlags;
 extern uint16_t gParkRating;
 extern money16 gParkEntranceFee;
 extern uint16_t gParkSize;
 extern money16 gLandPrice;
 extern money16 gConstructionRightsPrice;
 
-extern uint32_t gTotalAdmissions;
-extern money32 gTotalIncomeFromAdmissions;
+extern uint64_t gTotalAdmissions;
+extern money64 gTotalIncomeFromAdmissions;
 
-extern money32 gParkValue;
-extern money32 gCompanyValue;
+extern money64 gParkValue;
+extern money64 gCompanyValue;
 
 extern int16_t gParkRatingCasualtyPenalty;
 extern uint8_t gParkRatingHistory[32];