text: /****************************************************************************
  **
  ** Copyright (C) 2019 The Qt Company Ltd.
  ** Copyright (C) 2019 Intel Corporation.
  ** Contact: https://www.qt.io/licensing/
  **
  ** This file is part of the QtCore module of the Qt Toolkit.
  **
  ** $QT_BEGIN_LICENSE:LGPL$
  ** Commercial License Usage
  ** Licensees holding valid commercial Qt licenses may use this file in
  ** accordance with the commercial license agreement provided with the
  ** Software or, alternatively, in accordance with the terms contained in
  ** a written agreement between you and The Qt Company. For licensing terms
  ** and conditions see https://www.qt.io/terms-conditions. For further
  ** information use the contact form at https://www.qt.io/contact-us.
  **
  ** GNU Lesser General Public License Usage
  ** Alternatively, this file may be used under the terms of the GNU Lesser
  ** General Public License version 3 as published by the Free Software
  ** Foundation and appearing in the file LICENSE.LGPL3 included in the
  ** packaging of this file. Please review the following information to
  ** ensure the GNU Lesser General Public License version 3 requirements
  ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
  **
  ** GNU General Public License Usage
  ** Alternatively, this file may be used under the terms of the GNU
  ** General Public License version 2.0 or (at your option) the GNU General
  ** Public license version 3 or any later version approved by the KDE Free
  ** Qt Foundation. The licenses are as published by the Free Software
  ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
  ** included in the packaging of this file. Please review the following
  ** information to ensure the GNU General Public License requirements will
  ** be met: https://www.gnu.org/licenses/gpl-2.0.html and
  ** https://www.gnu.org/licenses/gpl-3.0.html.
  **
  ** $QT_END_LICENSE$
  **
  ****************************************************************************/
  
  #ifndef QGLOBAL_H
  #define QGLOBAL_H
  
  #ifdef __cplusplus
  #  include <type_traits>
  #  include <cstddef>
  #  include <utility>
  #endif
  #ifndef __ASSEMBLER__
  #  include <assert.h>
  #  include <stddef.h>
  #endif
  
  /*
     QT_VERSION is (major << 16) + (minor << 8) + patch.
  */
  #define QT_VERSION      QT_VERSION_CHECK(QT_VERSION_MAJOR, QT_VERSION_MINOR, QT_VERSION_PATCH)
  /*
     can be used like #if (QT_VERSION >= QT_VERSION_CHECK(4, 4, 0))
  */
  #define QT_VERSION_CHECK(major, minor, patch) ((major<<16)|(minor<<8)|(patch))
  
  #ifdef QT_BOOTSTRAPPED
  #include <QtCore/qconfig-bootstrapped.h>
  #else
  #include <QtCore/qconfig.h>
  #include <QtCore/qtcore-config.h>
  #endif
  
  // The QT_SUPPORTS macro is deprecated. Don't use it in new code.
  // Instead, use QT_CONFIG(feature)
  // ### Qt6: remove macro
  #ifdef _MSC_VER
  #  define QT_SUPPORTS(FEATURE) (!defined QT_NO_##FEATURE)
  #else
  #  define QT_SUPPORTS(FEATURE) (!defined(QT_NO_##FEATURE))
  #endif
  
  /*
      The QT_CONFIG macro implements a safe compile time check for features of Qt.
      Features can be in three states:
          0 or undefined: This will lead to a compile error when testing for it
          -1: The feature is not available
          1: The feature is available
  */
  #define QT_CONFIG(feature) (1/QT_FEATURE_##feature == 1)
  #define QT_REQUIRE_CONFIG(feature) Q_STATIC_ASSERT_X(QT_FEATURE_##feature == 1, "Required feature " #feature " for file " __FILE__ " not available.")
  
  #if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
  #  define QT_NO_UNSHARABLE_CONTAINERS
  #  define QT6_VIRTUAL virtual
  #  define QT6_NOT_VIRTUAL
  #else
  #  define QT6_VIRTUAL
  #  define QT6_NOT_VIRTUAL virtual
  #endif
  
  /* These two macros makes it possible to turn the builtin line expander into a
   * string literal. */
  #define QT_STRINGIFY2(x) #x
  #define QT_STRINGIFY(x) QT_STRINGIFY2(x)
  
  #include <QtCore/qsystemdetection.h>
  #include <QtCore/qprocessordetection.h>
  #include <QtCore/qcompilerdetection.h>
  
  #if defined (__ELF__)
  #  define Q_OF_ELF
  #endif
  #if defined (__MACH__) && defined (__APPLE__)
  #  define Q_OF_MACH_O
  #endif
  
  /*
     Avoid "unused parameter" warnings
  */
  #define Q_UNUSED(x) (void)x;
  
  #if defined(__cplusplus) && defined(Q_COMPILER_STATIC_ASSERT)
  #  define Q_STATIC_ASSERT(Condition) static_assert(bool(Condition), #Condition)
  #  define Q_STATIC_ASSERT_X(Condition, Message) static_assert(bool(Condition), Message)
  #elif defined(Q_COMPILER_STATIC_ASSERT)
  // C11 mode - using the _S version in case <assert.h> doesn't do the right thing
  #  define Q_STATIC_ASSERT(Condition) _Static_assert(!!(Condition), #Condition)
  #  define Q_STATIC_ASSERT_X(Condition, Message) _Static_assert(!!(Condition), Message)
  #else
  // C89 & C99 version
  #  define Q_STATIC_ASSERT_PRIVATE_JOIN(A, B) Q_STATIC_ASSERT_PRIVATE_JOIN_IMPL(A, B)
  #  define Q_STATIC_ASSERT_PRIVATE_JOIN_IMPL(A, B) A ## B
  #  ifdef __COUNTER__
  #  define Q_STATIC_ASSERT(Condition) \
      typedef char Q_STATIC_ASSERT_PRIVATE_JOIN(q_static_assert_result, __COUNTER__) [(Condition) ? 1 : -1];
  #  else
  #  define Q_STATIC_ASSERT(Condition) \
      typedef char Q_STATIC_ASSERT_PRIVATE_JOIN(q_static_assert_result, __LINE__) [(Condition) ? 1 : -1];
  #  endif /* __COUNTER__ */
  #  define Q_STATIC_ASSERT_X(Condition, Message) Q_STATIC_ASSERT(Condition)
  #endif
  
  #ifdef __cplusplus
  
  #include <algorithm>
  
  #if !defined(QT_NAMESPACE) || defined(Q_MOC_RUN) /* user namespace */
  
  # define QT_PREPEND_NAMESPACE(name) ::name
  # define QT_USE_NAMESPACE
  # define QT_BEGIN_NAMESPACE
  # define QT_END_NAMESPACE
  # define QT_BEGIN_INCLUDE_NAMESPACE
  # define QT_END_INCLUDE_NAMESPACE
  #ifndef QT_BEGIN_MOC_NAMESPACE
  # define QT_BEGIN_MOC_NAMESPACE
  #endif
  #ifndef QT_END_MOC_NAMESPACE
  # define QT_END_MOC_NAMESPACE
  #endif
  # define QT_FORWARD_DECLARE_CLASS(name) class name;
  # define QT_FORWARD_DECLARE_STRUCT(name) struct name;
  # define QT_MANGLE_NAMESPACE(name) name
  
  #else /* user namespace */
  
  # define QT_PREPEND_NAMESPACE(name) ::QT_NAMESPACE::name
  # define QT_USE_NAMESPACE using namespace ::QT_NAMESPACE;
  # define QT_BEGIN_NAMESPACE namespace QT_NAMESPACE {
  # define QT_END_NAMESPACE }
  # define QT_BEGIN_INCLUDE_NAMESPACE }
  # define QT_END_INCLUDE_NAMESPACE namespace QT_NAMESPACE {
  #ifndef QT_BEGIN_MOC_NAMESPACE
  # define QT_BEGIN_MOC_NAMESPACE QT_USE_NAMESPACE
  #endif
  #ifndef QT_END_MOC_NAMESPACE
  # define QT_END_MOC_NAMESPACE
  #endif
  # define QT_FORWARD_DECLARE_CLASS(name) \
      QT_BEGIN_NAMESPACE class name; QT_END_NAMESPACE \
      using QT_PREPEND_NAMESPACE(name);
  
  # define QT_FORWARD_DECLARE_STRUCT(name) \
      QT_BEGIN_NAMESPACE struct name; QT_END_NAMESPACE \
      using QT_PREPEND_NAMESPACE(name);
  
  # define QT_MANGLE_NAMESPACE0(x) x
  # define QT_MANGLE_NAMESPACE1(a, b) a##_##b
  # define QT_MANGLE_NAMESPACE2(a, b) QT_MANGLE_NAMESPACE1(a,b)
  # define QT_MANGLE_NAMESPACE(name) QT_MANGLE_NAMESPACE2( \
          QT_MANGLE_NAMESPACE0(name), QT_MANGLE_NAMESPACE0(QT_NAMESPACE))
  
  namespace QT_NAMESPACE {}
  
  # ifndef QT_BOOTSTRAPPED
  # ifndef QT_NO_USING_NAMESPACE
     /*
      This expands to a "using QT_NAMESPACE" also in _header files_.
      It is the only way the feature can be used without too much
      pain, but if people _really_ do not want it they can add
      DEFINES += QT_NO_USING_NAMESPACE to their .pro files.
      */
     QT_USE_NAMESPACE
  # endif
  # endif
  
  #endif /* user namespace */
  
  #else /* __cplusplus */
  
  # define QT_BEGIN_NAMESPACE
  # define QT_END_NAMESPACE
  # define QT_USE_NAMESPACE
  # define QT_BEGIN_INCLUDE_NAMESPACE
  # define QT_END_INCLUDE_NAMESPACE
  
  #endif /* __cplusplus */
  
  // ### Qt6: remove me.
  #define QT_BEGIN_HEADER
  #define QT_END_HEADER
  
  #if defined(Q_OS_DARWIN) && !defined(QT_LARGEFILE_SUPPORT)
  #  define QT_LARGEFILE_SUPPORT 64
  #endif
  
  #ifndef __ASSEMBLER__
  QT_BEGIN_NAMESPACE
  
  /*
     Size-dependent types (architechture-dependent byte order)
  
     Make sure to update QMetaType when changing these typedefs
  */
  
  typedef signed char qint8;         /* 8 bit signed */
  typedef unsigned char quint8;      /* 8 bit unsigned */
  typedef short qint16;              /* 16 bit signed */
  typedef unsigned short quint16;    /* 16 bit unsigned */
  typedef int qint32;                /* 32 bit signed */
  typedef unsigned int quint32;      /* 32 bit unsigned */
  #if defined(Q_OS_WIN) && !defined(Q_CC_GNU)
  #  define Q_INT64_C(c) c ## i64    /* signed 64 bit constant */
  #  define Q_UINT64_C(c) c ## ui64   /* unsigned 64 bit constant */
  typedef __int64 qint64;            /* 64 bit signed */
  typedef unsigned __int64 quint64;  /* 64 bit unsigned */
  #else
  #ifdef __cplusplus
  #  define Q_INT64_C(c) static_cast<long long>(c ## LL)     /* signed 64 bit constant */
  #  define Q_UINT64_C(c) static_cast<unsigned long long>(c ## ULL) /* unsigned 64 bit constant */
  #else
  #  define Q_INT64_C(c) ((long long)(c ## LL))               /* signed 64 bit constant */
  #  define Q_UINT64_C(c) ((unsigned long long)(c ## ULL))    /* unsigned 64 bit constant */
  #endif
  typedef long long qint64;           /* 64 bit signed */
  typedef unsigned long long quint64; /* 64 bit unsigned */
  #endif
  
  typedef qint64 qlonglong;
  typedef quint64 qulonglong;
  
  #ifndef __cplusplus
  // In C++ mode, we define below using QIntegerForSize template
  Q_STATIC_ASSERT_X(sizeof(ptrdiff_t) == sizeof(size_t), "Weird ptrdiff_t and size_t definitions");
  typedef ptrdiff_t qptrdiff;
  typedef ptrdiff_t qsizetype;
  typedef ptrdiff_t qintptr;
  typedef size_t quintptr;
  #endif
  
  /*
     Useful type definitions for Qt
  */
  
  QT_BEGIN_INCLUDE_NAMESPACE
  typedef unsigned char uchar;
  typedef unsigned short ushort;
  typedef unsigned int uint;
  typedef unsigned long ulong;
  QT_END_INCLUDE_NAMESPACE
  
  #if defined(QT_COORD_TYPE)
  typedef QT_COORD_TYPE qreal;
  #else
  typedef double qreal;
  #endif
  
  #if defined(QT_NO_DEPRECATED)
  #  undef QT_DEPRECATED
  #  undef QT_DEPRECATED_X
  #  undef QT_DEPRECATED_VARIABLE
  #  undef QT_DEPRECATED_CONSTRUCTOR
  #elif !defined(QT_NO_DEPRECATED_WARNINGS)
  #  undef QT_DEPRECATED
  #  define QT_DEPRECATED Q_DECL_DEPRECATED
  #  undef QT_DEPRECATED_X
  #  define QT_DEPRECATED_X(text) Q_DECL_DEPRECATED_X(text)
  #  undef QT_DEPRECATED_VARIABLE
  #  define QT_DEPRECATED_VARIABLE Q_DECL_VARIABLE_DEPRECATED
  #  undef QT_DEPRECATED_CONSTRUCTOR
  #  define QT_DEPRECATED_CONSTRUCTOR explicit Q_DECL_CONSTRUCTOR_DEPRECATED
  #else
  #  undef QT_DEPRECATED
  #  define QT_DEPRECATED
  #  undef QT_DEPRECATED_X
  #  define QT_DEPRECATED_X(text)
  #  undef QT_DEPRECATED_VARIABLE
  #  define QT_DEPRECATED_VARIABLE
  #  undef QT_DEPRECATED_CONSTRUCTOR
  #  define QT_DEPRECATED_CONSTRUCTOR
  #endif
  
  #ifndef QT_DEPRECATED_WARNINGS_SINCE
  # ifdef QT_DISABLE_DEPRECATED_BEFORE
  #  define QT_DEPRECATED_WARNINGS_SINCE QT_DISABLE_DEPRECATED_BEFORE
  # else
  #  define QT_DEPRECATED_WARNINGS_SINCE QT_VERSION
  # endif
  #endif
  
  #ifndef QT_DISABLE_DEPRECATED_BEFORE
  #define QT_DISABLE_DEPRECATED_BEFORE QT_VERSION_CHECK(5, 0, 0)
  #endif
  
  /*
      QT_DEPRECATED_SINCE(major, minor) evaluates as true if the Qt version is greater than
      the deprecation point specified.
  
      Use it to specify from which version of Qt a function or class has been deprecated
  
      Example:
          #if QT_DEPRECATED_SINCE(5,1)
              QT_DEPRECATED void deprecatedFunction(); //function deprecated since Qt 5.1
          #endif
  
  */
  #ifdef QT_DEPRECATED
  #define QT_DEPRECATED_SINCE(major, minor) (QT_VERSION_CHECK(major, minor, 0) > QT_DISABLE_DEPRECATED_BEFORE)
  #else
  #define QT_DEPRECATED_SINCE(major, minor) 0
  #endif
  
  /*
    QT_DEPRECATED_VERSION(major, minor) and QT_DEPRECATED_VERSION_X(major, minor, text)
    outputs a deprecation warning if QT_DEPRECATED_WARNINGS_SINCE is equal or greater
    than the version specified as major, minor. This makes it possible to deprecate a
    function without annoying a user who needs to stick at a specified minimum version
    and therefore can't use the new function.
  */
  #if QT_DEPRECATED_WARNINGS_SINCE >= QT_VERSION_CHECK(5, 12, 0)
  # define QT_DEPRECATED_VERSION_X_5_12(text) QT_DEPRECATED_X(text)
  # define QT_DEPRECATED_VERSION_5_12         QT_DEPRECATED
  #else
  # define QT_DEPRECATED_VERSION_X_5_12(text)
  # define QT_DEPRECATED_VERSION_5_12
  #endif
  
  #if QT_DEPRECATED_WARNINGS_SINCE >= QT_VERSION_CHECK(5, 13, 0)
  # define QT_DEPRECATED_VERSION_X_5_13(text) QT_DEPRECATED_X(text)
  # define QT_DEPRECATED_VERSION_5_13         QT_DEPRECATED
  #else
  # define QT_DEPRECATED_VERSION_X_5_13(text)
  # define QT_DEPRECATED_VERSION_5_13
  #endif
  
  #if QT_DEPRECATED_WARNINGS_SINCE >= QT_VERSION_CHECK(5, 14, 0)
  # define QT_DEPRECATED_VERSION_X_5_14(text) QT_DEPRECATED_X(text)
  # define QT_DEPRECATED_VERSION_5_14         QT_DEPRECATED
  #else
  # define QT_DEPRECATED_VERSION_X_5_14(text)
  # define QT_DEPRECATED_VERSION_5_14
  #endif
  
  #if QT_DEPRECATED_WARNINGS_SINCE >= QT_VERSION_CHECK(5, 15, 0)
  # define QT_DEPRECATED_VERSION_X_5_15(text) QT_DEPRECATED_X(text)
  # define QT_DEPRECATED_VERSION_5_15         QT_DEPRECATED
  #else
  # define QT_DEPRECATED_VERSION_X_5_15(text)
  # define QT_DEPRECATED_VERSION_5_15
  #endif
  
  #define QT_DEPRECATED_VERSION_X_5(minor, text)      QT_DEPRECATED_VERSION_X_5_##minor(text)
  #define QT_DEPRECATED_VERSION_X(major, minor, text) QT_DEPRECATED_VERSION_X_##major(minor, text)
  
  #define QT_DEPRECATED_VERSION_5(minor)      QT_DEPRECATED_VERSION_5_##minor
  #define QT_DEPRECATED_VERSION(major, minor) QT_DEPRECATED_VERSION_##major(minor)
  
  #ifdef __cplusplus
  // A tag to help mark stuff deprecated (cf. QStringViewLiteral)
  namespace QtPrivate {
  enum class Deprecated_t {};
  constexpr Q_DECL_UNUSED Deprecated_t Deprecated = {};
  }
  #endif
  
  /*
     The Qt modules' export macros.
     The options are:
      - defined(QT_STATIC): Qt was built or is being built in static mode
      - defined(QT_SHARED): Qt was built or is being built in shared/dynamic mode
     If neither was defined, then QT_SHARED is implied. If Qt was compiled in static
     mode, QT_STATIC is defined in qconfig.h. In shared mode, QT_STATIC is implied
     for the bootstrapped tools.
  */
  
  #ifdef QT_BOOTSTRAPPED
  #  ifdef QT_SHARED
  #    error "QT_SHARED and QT_BOOTSTRAPPED together don't make sense. Please fix the build"
  #  elif !defined(QT_STATIC)
  #    define QT_STATIC
  #  endif
  #endif
  
  #if defined(QT_SHARED) || !defined(QT_STATIC)
  #  ifdef QT_STATIC
  #    error "Both QT_SHARED and QT_STATIC defined, please make up your mind"
  #  endif
  #  ifndef QT_SHARED
  #    define QT_SHARED
  #  endif
  #  if defined(QT_BUILD_CORE_LIB)
  #    define Q_CORE_EXPORT Q_DECL_EXPORT
  #  else
  #    define Q_CORE_EXPORT Q_DECL_IMPORT
  #  endif
  #else
  #  define Q_CORE_EXPORT
  #endif
  
  /*
     Some classes do not permit copies to be made of an object. These
     classes contains a private copy constructor and assignment
     operator to disable copying (the compiler gives an error message).
  */
  #define Q_DISABLE_COPY(Class) \
      Class(const Class &) = delete;\
      Class &operator=(const Class &) = delete;
  
  #define Q_DISABLE_MOVE(Class) \
      Class(Class &&) = delete; \
      Class &operator=(Class &&) = delete;
  
  #define Q_DISABLE_COPY_MOVE(Class) \
      Q_DISABLE_COPY(Class) \
      Q_DISABLE_MOVE(Class)
  
  /*
     No, this is not an evil backdoor. QT_BUILD_INTERNAL just exports more symbols
     for Qt's internal unit tests. If you want slower loading times and more
     symbols that can vanish from version to version, feel free to define QT_BUILD_INTERNAL.
  */
  #if defined(QT_BUILD_INTERNAL) && defined(QT_BUILDING_QT) && defined(QT_SHARED)
  #    define Q_AUTOTEST_EXPORT Q_DECL_EXPORT
  #elif defined(QT_BUILD_INTERNAL) && defined(QT_SHARED)
  #    define Q_AUTOTEST_EXPORT Q_DECL_IMPORT
  #else
  #    define Q_AUTOTEST_EXPORT
  #endif
  
  #define Q_INIT_RESOURCE(name) \
      do { extern int QT_MANGLE_NAMESPACE(qInitResources_ ## name) ();       \
          QT_MANGLE_NAMESPACE(qInitResources_ ## name) (); } while (false)
  #define Q_CLEANUP_RESOURCE(name) \
      do { extern int QT_MANGLE_NAMESPACE(qCleanupResources_ ## name) ();    \
          QT_MANGLE_NAMESPACE(qCleanupResources_ ## name) (); } while (false)
  
  /*
   * If we're compiling C++ code:
   *  - and this is a non-namespace build, declare qVersion as extern "C"
   *  - and this is a namespace build, declare it as a regular function
   *    (we're already inside QT_BEGIN_NAMESPACE / QT_END_NAMESPACE)
   * If we're compiling C code, simply declare the function. If Qt was compiled
   * in a namespace, qVersion isn't callable anyway.
   */
  #if !defined(QT_NAMESPACE) && defined(__cplusplus) && !defined(Q_QDOC)
  extern "C"
  #endif
  Q_CORE_EXPORT Q_DECL_CONST_FUNCTION const char *qVersion(void) Q_DECL_NOEXCEPT;
  
  #if defined(__cplusplus)
  
  #ifndef Q_CONSTRUCTOR_FUNCTION
  # define Q_CONSTRUCTOR_FUNCTION0(AFUNC) \
      namespace { \
      static const struct AFUNC ## _ctor_class_ { \
          inline AFUNC ## _ctor_class_() { AFUNC(); } \
      } AFUNC ## _ctor_instance_; \
      }
  
  # define Q_CONSTRUCTOR_FUNCTION(AFUNC) Q_CONSTRUCTOR_FUNCTION0(AFUNC)
  #endif
  
  #ifndef Q_DESTRUCTOR_FUNCTION
  # define Q_DESTRUCTOR_FUNCTION0(AFUNC) \
      namespace { \
      static const struct AFUNC ## _dtor_class_ { \
          inline AFUNC ## _dtor_class_() { } \
          inline ~ AFUNC ## _dtor_class_() { AFUNC(); } \
      } AFUNC ## _dtor_instance_; \
      }
  # define Q_DESTRUCTOR_FUNCTION(AFUNC) Q_DESTRUCTOR_FUNCTION0(AFUNC)
  #endif
  
  namespace QtPrivate {
      template <class T>
      struct AlignOfHelper
      {
          char c;
          T type;
  
          AlignOfHelper();
          ~AlignOfHelper();
      };
  
      template <class T>
      struct AlignOf_Default
      {
          enum { Value = sizeof(AlignOfHelper<T>) - sizeof(T) };
      };
  
      template <class T> struct AlignOf : AlignOf_Default<T> { };
      template <class T> struct AlignOf<T &> : AlignOf<T> {};
      template <class T> struct AlignOf<T &&> : AlignOf<T> {};
      template <size_t N, class T> struct AlignOf<T[N]> : AlignOf<T> {};
  
  #if defined(Q_PROCESSOR_X86_32) && !defined(Q_OS_WIN)
      template <class T> struct AlignOf_WorkaroundForI386Abi { enum { Value = sizeof(T) }; };
  
      // x86 ABI weirdness
      // Alignment of naked type is 8, but inside struct has alignment 4.
      template <> struct AlignOf<double>  : AlignOf_WorkaroundForI386Abi<double> {};
      template <> struct AlignOf<qint64>  : AlignOf_WorkaroundForI386Abi<qint64> {};
      template <> struct AlignOf<quint64> : AlignOf_WorkaroundForI386Abi<quint64> {};
  #ifdef Q_CC_CLANG
      // GCC and Clang seem to disagree wrt to alignment of arrays
      template <size_t N> struct AlignOf<double[N]>   : AlignOf_Default<double> {};
      template <size_t N> struct AlignOf<qint64[N]>   : AlignOf_Default<qint64> {};
      template <size_t N> struct AlignOf<quint64[N]>  : AlignOf_Default<quint64> {};
  #endif
  #endif
  } // namespace QtPrivate
  
  #define QT_EMULATED_ALIGNOF(T) \
      (size_t(QT_PREPEND_NAMESPACE(QtPrivate)::AlignOf<T>::Value))
  
  #ifndef Q_ALIGNOF
  #define Q_ALIGNOF(T) QT_EMULATED_ALIGNOF(T)
  #endif
  
  
  /*
    quintptr and qptrdiff is guaranteed to be the same size as a pointer, i.e.
  
        sizeof(void *) == sizeof(quintptr)
        && sizeof(void *) == sizeof(qptrdiff)
  
    size_t and qsizetype are not guaranteed to be the same size as a pointer, but
    they usually are.
  */
  template <int> struct QIntegerForSize;
  template <>    struct QIntegerForSize<1> { typedef quint8  Unsigned; typedef qint8  Signed; };
  template <>    struct QIntegerForSize<2> { typedef quint16 Unsigned; typedef qint16 Signed; };
  template <>    struct QIntegerForSize<4> { typedef quint32 Unsigned; typedef qint32 Signed; };
  template <>    struct QIntegerForSize<8> { typedef quint64 Unsigned; typedef qint64 Signed; };
  #if defined(Q_CC_GNU) && defined(__SIZEOF_INT128__)
  template <>    struct QIntegerForSize<16> { __extension__ typedef unsigned __int128 Unsigned; __extension__ typedef __int128 Signed; };
  #endif
  template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
  typedef QIntegerForSize<Q_PROCESSOR_WORDSIZE>::Signed qregisterint;
  typedef QIntegerForSize<Q_PROCESSOR_WORDSIZE>::Unsigned qregisteruint;
  typedef QIntegerForSizeof<void*>::Unsigned quintptr;
  typedef QIntegerForSizeof<void*>::Signed qptrdiff;
  typedef qptrdiff qintptr;
  using qsizetype = QIntegerForSizeof<std::size_t>::Signed;
  
  /* moc compats (signals/slots) */
  #ifndef QT_MOC_COMPAT
  #  define QT_MOC_COMPAT
  #else
  #  undef QT_MOC_COMPAT
  #  define QT_MOC_COMPAT
  #endif
  
  #ifdef QT_ASCII_CAST_WARNINGS
  #  define QT_ASCII_CAST_WARN Q_DECL_DEPRECATED_X("Use fromUtf8, QStringLiteral, or QLatin1String")
  #else
  #  define QT_ASCII_CAST_WARN
  #endif
  
  #ifdef Q_PROCESSOR_X86_32
  #  if defined(Q_CC_GNU)
  #    define QT_FASTCALL __attribute__((regparm(3)))
  #  elif defined(Q_CC_MSVC)
  #    define QT_FASTCALL __fastcall
  #  else
  #     define QT_FASTCALL
  #  endif
  #else
  #  define QT_FASTCALL
  #endif
  
  // enable gcc warnings for printf-style functions
  #if defined(Q_CC_GNU) && !defined(__INSURE__)
  #  if defined(Q_CC_MINGW) && !defined(Q_CC_CLANG)
  #    define Q_ATTRIBUTE_FORMAT_PRINTF(A, B) \
           __attribute__((format(gnu_printf, (A), (B))))
  #  else
  #    define Q_ATTRIBUTE_FORMAT_PRINTF(A, B) \
           __attribute__((format(printf, (A), (B))))
  #  endif
  #else
  #  define Q_ATTRIBUTE_FORMAT_PRINTF(A, B)
  #endif
  
  #ifdef Q_CC_MSVC
  #  define Q_NEVER_INLINE __declspec(noinline)
  #  define Q_ALWAYS_INLINE __forceinline
  #elif defined(Q_CC_GNU)
  #  define Q_NEVER_INLINE __attribute__((noinline))
  #  define Q_ALWAYS_INLINE inline __attribute__((always_inline))
  #else
  #  define Q_NEVER_INLINE
  #  define Q_ALWAYS_INLINE inline
  #endif
  
  #if defined(Q_CC_GNU) && defined(Q_OS_WIN) && !defined(QT_NO_DATA_RELOCATION)
  // ### Qt6: you can remove me
  #  define QT_INIT_METAOBJECT __attribute__((init_priority(101)))
  #else
  #  define QT_INIT_METAOBJECT
  #endif
  
  //defines the type for the WNDPROC on windows
  //the alignment needs to be forced for sse2 to not crash with mingw
  #if defined(Q_OS_WIN)
  #  if defined(Q_CC_MINGW) && !defined(Q_OS_WIN64)
  #    define QT_ENSURE_STACK_ALIGNED_FOR_SSE __attribute__ ((force_align_arg_pointer))
  #  else
  #    define QT_ENSURE_STACK_ALIGNED_FOR_SSE
  #  endif
  #  define QT_WIN_CALLBACK CALLBACK QT_ENSURE_STACK_ALIGNED_FOR_SSE
  #endif
  
  typedef int QNoImplicitBoolCast;
  
  /*
     Utility macros and inline functions
  */
  
  template <typename T>
  Q_DECL_CONSTEXPR inline T qAbs(const T &t) { return t >= 0 ? t : -t; }
  
  Q_DECL_CONSTEXPR inline int qRound(double d)
  { return d >= 0.0 ? int(d + 0.5) : int(d - double(int(d-1)) + 0.5) + int(d-1); }
  Q_DECL_CONSTEXPR inline int qRound(float d)
  { return d >= 0.0f ? int(d + 0.5f) : int(d - float(int(d-1)) + 0.5f) + int(d-1); }
  
  Q_DECL_CONSTEXPR inline qint64 qRound64(double d)
  { return d >= 0.0 ? qint64(d + 0.5) : qint64(d - double(qint64(d-1)) + 0.5) + qint64(d-1); }
  Q_DECL_CONSTEXPR inline qint64 qRound64(float d)
  { return d >= 0.0f ? qint64(d + 0.5f) : qint64(d - float(qint64(d-1)) + 0.5f) + qint64(d-1); }
  
  template <typename T>
  constexpr inline const T &qMin(const T &a, const T &b) { return (a < b) ? a : b; }
  template <typename T>
  constexpr inline const T &qMax(const T &a, const T &b) { return (a < b) ? b : a; }
  template <typename T>
  constexpr inline const T &qBound(const T &min, const T &val, const T &max)
  { return qMax(min, qMin(max, val)); }
  
  #ifndef Q_FORWARD_DECLARE_OBJC_CLASS
  #  ifdef __OBJC__
  #    define Q_FORWARD_DECLARE_OBJC_CLASS(classname) @class classname
  #  else
  #    define Q_FORWARD_DECLARE_OBJC_CLASS(classname) typedef struct objc_object classname
  #  endif
  #endif
  #ifndef Q_FORWARD_DECLARE_CF_TYPE
  #  define Q_FORWARD_DECLARE_CF_TYPE(type) typedef const struct __ ## type * type ## Ref
  #endif
  #ifndef Q_FORWARD_DECLARE_MUTABLE_CF_TYPE
  #  define Q_FORWARD_DECLARE_MUTABLE_CF_TYPE(type) typedef struct __ ## type * type ## Ref
  #endif
  #ifndef Q_FORWARD_DECLARE_CG_TYPE
  #define Q_FORWARD_DECLARE_CG_TYPE(type) typedef const struct type *type ## Ref;
  #endif
  #ifndef Q_FORWARD_DECLARE_MUTABLE_CG_TYPE
  #define Q_FORWARD_DECLARE_MUTABLE_CG_TYPE(type) typedef struct type *type ## Ref;
  #endif
  
  #ifdef Q_OS_DARWIN
  #  define QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios, tvos, watchos) \
      ((defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && macos != __MAC_NA && __MAC_OS_X_VERSION_MAX_ALLOWED >= macos) || \
       (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && ios != __IPHONE_NA && __IPHONE_OS_VERSION_MAX_ALLOWED >= ios) || \
       (defined(__TV_OS_VERSION_MAX_ALLOWED) && tvos != __TVOS_NA && __TV_OS_VERSION_MAX_ALLOWED >= tvos) || \
       (defined(__WATCH_OS_VERSION_MAX_ALLOWED) && watchos != __WATCHOS_NA && __WATCH_OS_VERSION_MAX_ALLOWED >= watchos))
  
  #  define QT_DARWIN_DEPLOYMENT_TARGET_BELOW(macos, ios, tvos, watchos) \
      ((defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && macos != __MAC_NA && __MAC_OS_X_VERSION_MIN_REQUIRED < macos) || \
       (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && ios != __IPHONE_NA && __IPHONE_OS_VERSION_MIN_REQUIRED < ios) || \
       (defined(__TV_OS_VERSION_MIN_REQUIRED) && tvos != __TVOS_NA && __TV_OS_VERSION_MIN_REQUIRED < tvos) || \
       (defined(__WATCH_OS_VERSION_MIN_REQUIRED) && watchos != __WATCHOS_NA && __WATCH_OS_VERSION_MIN_REQUIRED < watchos))
  
  #  define QT_MACOS_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios) \
        QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios, __TVOS_NA, __WATCHOS_NA)
  #  define QT_MACOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos) \
        QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, __IPHONE_NA, __TVOS_NA, __WATCHOS_NA)
  #  define QT_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(ios) \
        QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_NA, ios, __TVOS_NA, __WATCHOS_NA)
  #  define QT_TVOS_PLATFORM_SDK_EQUAL_OR_ABOVE(tvos) \
        QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_NA, __IPHONE_NA, tvos, __WATCHOS_NA)
  #  define QT_WATCHOS_PLATFORM_SDK_EQUAL_OR_ABOVE(watchos) \
        QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_NA, __IPHONE_NA, __TVOS_NA, watchos)
  
  #  define QT_MACOS_IOS_DEPLOYMENT_TARGET_BELOW(macos, ios) \
        QT_DARWIN_DEPLOYMENT_TARGET_BELOW(macos, ios, __TVOS_NA, __WATCHOS_NA)
  #  define QT_MACOS_DEPLOYMENT_TARGET_BELOW(macos) \
        QT_DARWIN_DEPLOYMENT_TARGET_BELOW(macos, __IPHONE_NA, __TVOS_NA, __WATCHOS_NA)
  #  define QT_IOS_DEPLOYMENT_TARGET_BELOW(ios) \
        QT_DARWIN_DEPLOYMENT_TARGET_BELOW(__MAC_NA, ios, __TVOS_NA, __WATCHOS_NA)
  #  define QT_TVOS_DEPLOYMENT_TARGET_BELOW(tvos) \
        QT_DARWIN_DEPLOYMENT_TARGET_BELOW(__MAC_NA, __IPHONE_NA, tvos, __WATCHOS_NA)
  #  define QT_WATCHOS_DEPLOYMENT_TARGET_BELOW(watchos) \
        QT_DARWIN_DEPLOYMENT_TARGET_BELOW(__MAC_NA, __IPHONE_NA, __TVOS_NA, watchos)
  
  // Compatibility synonyms, do not use
  #  define QT_MAC_PLATFORM_SDK_EQUAL_OR_ABOVE(osx, ios) QT_MACOS_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(osx, ios)
  #  define QT_MAC_DEPLOYMENT_TARGET_BELOW(osx, ios) QT_MACOS_IOS_DEPLOYMENT_TARGET_BELOW(osx, ios)
  #  define QT_OSX_PLATFORM_SDK_EQUAL_OR_ABOVE(osx) QT_MACOS_PLATFORM_SDK_EQUAL_OR_ABOVE(osx)
  #  define QT_OSX_DEPLOYMENT_TARGET_BELOW(osx) QT_MACOS_DEPLOYMENT_TARGET_BELOW(osx)
  
  // Implemented in qcore_mac_objc.mm
  class Q_CORE_EXPORT QMacAutoReleasePool
  {
  public:
      QMacAutoReleasePool();
      ~QMacAutoReleasePool();
  private:
      Q_DISABLE_COPY(QMacAutoReleasePool)
      void *pool;
  };
  
  #else
  
  #define QT_DARWIN_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios, tvos, watchos) (0)
  #define QT_MACOS_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos, ios) (0)
  #define QT_MACOS_PLATFORM_SDK_EQUAL_OR_ABOVE(macos) (0)
  #define QT_IOS_PLATFORM_SDK_EQUAL_OR_ABOVE(ios) (0)
  #define QT_TVOS_PLATFORM_SDK_EQUAL_OR_ABOVE(tvos) (0)
  #define QT_WATCHOS_PLATFORM_SDK_EQUAL_OR_ABOVE(watchos) (0)
  
  #define QT_MAC_PLATFORM_SDK_EQUAL_OR_ABOVE(osx, ios) (0)
  #define QT_OSX_PLATFORM_SDK_EQUAL_OR_ABOVE(osx) (0)
  
  #endif // Q_OS_DARWIN
  
  /*
     Data stream functions are provided by many classes (defined in qdatastream.h)
  */
  
  class QDataStream;
  
  inline void qt_noop(void) {}
  
  /* These wrap try/catch so we can switch off exceptions later.
  
     Beware - do not use more than one QT_CATCH per QT_TRY, and do not use
     the exception instance in the catch block.
     If you can't live with those constraints, don't use these macros.
     Use the QT_NO_EXCEPTIONS macro to protect your code instead.
  */
  
  #if !defined(QT_NO_EXCEPTIONS)
  #  if !defined(Q_MOC_RUN)
  #    if (defined(Q_CC_CLANG) && !defined(Q_CC_INTEL) && !__has_feature(cxx_exceptions)) || \
          (defined(Q_CC_GNU) && !defined(__EXCEPTIONS))
  #      define QT_NO_EXCEPTIONS
  #    endif
  #  elif defined(QT_BOOTSTRAPPED)
  #    define QT_NO_EXCEPTIONS
  #  endif
  #endif
  
  #ifdef QT_NO_EXCEPTIONS
  #  define QT_TRY if (true)
  #  define QT_CATCH(A) else
  #  define QT_THROW(A) qt_noop()
  #  define QT_RETHROW qt_noop()
  #  define QT_TERMINATE_ON_EXCEPTION(expr) do { expr; } while (false)
  #else
  #  define QT_TRY try
  #  define QT_CATCH(A) catch (A)
  #  define QT_THROW(A) throw A
  #  define QT_RETHROW throw
  Q_NORETURN Q_DECL_COLD_FUNCTION Q_CORE_EXPORT void qTerminate() noexcept;
  #  ifdef Q_COMPILER_NOEXCEPT
  #    define QT_TERMINATE_ON_EXCEPTION(expr) do { expr; } while (false)
  #  else
  #    define QT_TERMINATE_ON_EXCEPTION(expr) do { try { expr; } catch (...) { qTerminate(); } } while (false)
  #  endif
  #endif
  
  Q_CORE_EXPORT Q_DECL_CONST_FUNCTION bool qSharedBuild() noexcept;
  
  #ifndef Q_OUTOFLINE_TEMPLATE
  #  define Q_OUTOFLINE_TEMPLATE
  #endif
  #ifndef Q_INLINE_TEMPLATE
  #  define Q_INLINE_TEMPLATE inline
  #endif
  
  /*
     Debugging and error handling
  */
  
  #if !defined(QT_NO_DEBUG) && !defined(QT_DEBUG)
  #  define QT_DEBUG
  #endif
  
  // QtPrivate::asString defined in qstring.h
  #ifndef qPrintable
  #  define qPrintable(string) QtPrivate::asString(string).toLocal8Bit().constData()
  #endif
  
  #ifndef qUtf8Printable
  #  define qUtf8Printable(string) QtPrivate::asString(string).toUtf8().constData()
  #endif
  
  /*
      Wrap QString::utf16() with enough casts to allow passing it
      to QString::asprintf("%ls") without warnings.
  */
  #ifndef qUtf16Printable
  #  define qUtf16Printable(string) \
      static_cast<const wchar_t*>(static_cast<const void*>(QString(string).utf16()))
  #endif
  
  class QString;
  Q_DECL_COLD_FUNCTION
  Q_CORE_EXPORT QString qt_error_string(int errorCode = -1);
  
  #ifndef Q_CC_MSVC
  Q_NORETURN
  #endif
  Q_DECL_COLD_FUNCTION
  Q_CORE_EXPORT void qt_assert(const char *assertion, const char *file, int line) noexcept;
  
  #if !defined(Q_ASSERT)
  #  if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
  #    define Q_ASSERT(cond) static_cast<void>(false && (cond))
  #  else
  #    define Q_ASSERT(cond) ((cond) ? static_cast<void>(0) : qt_assert(#cond, __FILE__, __LINE__))
  #  endif
  #endif
  
  #ifndef Q_CC_MSVC
  Q_NORETURN
  #endif
  Q_DECL_COLD_FUNCTION
  Q_CORE_EXPORT void qt_assert_x(const char *where, const char *what, const char *file, int line) noexcept;
  
  #if !defined(Q_ASSERT_X)
  #  if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
  #    define Q_ASSERT_X(cond, where, what) static_cast<void>(false && (cond))
  #  else
  #    define Q_ASSERT_X(cond, where, what) ((cond) ? static_cast<void>(0) : qt_assert_x(where, what, __FILE__, __LINE__))
  #  endif
  #endif
  
  Q_NORETURN Q_CORE_EXPORT void qt_check_pointer(const char *, int) noexcept;
  Q_DECL_COLD_FUNCTION
  Q_CORE_EXPORT void qBadAlloc();
  
  #ifdef QT_NO_EXCEPTIONS
  #  if defined(QT_NO_DEBUG) && !defined(QT_FORCE_ASSERTS)
  #    define Q_CHECK_PTR(p) qt_noop()
  #  else
  #    define Q_CHECK_PTR(p) do {if (!(p)) qt_check_pointer(__FILE__,__LINE__);} while (false)
  #  endif
  #else
  #  define Q_CHECK_PTR(p) do { if (!(p)) qBadAlloc(); } while (false)
  #endif
  
  template <typename T>
  inline T *q_check_ptr(T *p) { Q_CHECK_PTR(p); return p; }
  
  typedef void (*QFunctionPointer)();
  
  #if !defined(Q_UNIMPLEMENTED)
  #  define Q_UNIMPLEMENTED() qWarning("Unimplemented code.")
  #endif
  
  Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED bool qFuzzyCompare(double p1, double p2)
  {
      return (qAbs(p1 - p2) * 1000000000000. <= qMin(qAbs(p1), qAbs(p2)));
  }
  
  Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED bool qFuzzyCompare(float p1, float p2)
  {
      return (qAbs(p1 - p2) * 100000.f <= qMin(qAbs(p1), qAbs(p2)));
  }
  
  Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED bool qFuzzyIsNull(double d)
  {
      return qAbs(d) <= 0.000000000001;
  }
  
  Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED  bool qFuzzyIsNull(float f)
  {
      return qAbs(f) <= 0.00001f;
  }
  
  QT_WARNING_PUSH
  QT_WARNING_DISABLE_CLANG("-Wfloat-equal")
  QT_WARNING_DISABLE_GCC("-Wfloat-equal")
  QT_WARNING_DISABLE_INTEL(1572)
  
  Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED bool qIsNull(double d) noexcept
  {
      return d == 0.0;
  }
  
  Q_REQUIRED_RESULT Q_DECL_CONSTEXPR static inline Q_DECL_UNUSED bool qIsNull(float f) noexcept
  {
      return f == 0.0f;
  }
  
  QT_WARNING_POP
  
  /*
     Compilers which follow outdated template instantiation rules
     require a class to have a comparison operator to exist when
     a QList of this type is instantiated. It's not actually
     used in the list, though. Hence the dummy implementation.
     Just in case other code relies on it we better trigger a warning
     mandating a real implementation.
  */
  
  #ifdef Q_FULL_TEMPLATE_INSTANTIATION
  #  define Q_DUMMY_COMPARISON_OPERATOR(C) \
      bool operator==(const C&) const { \
          qWarning(#C"::operator==(const "#C"&) was called"); \
          return false; \
      }
  #else
  
  #  define Q_DUMMY_COMPARISON_OPERATOR(C)
  #endif
  
  QT_WARNING_PUSH
  // warning: noexcept-expression evaluates to 'false' because of a call to 'void swap(..., ...)'
  QT_WARNING_DISABLE_GCC("-Wnoexcept")
  
  namespace QtPrivate
  {
  namespace SwapExceptionTester { // insulate users from the "using std::swap" below
      using std::swap; // import std::swap
      template <typename T>
      void checkSwap(T &t)
          noexcept(noexcept(swap(t, t)));
      // declared, but not implemented (only to be used in unevaluated contexts (noexcept operator))
  }
  } // namespace QtPrivate
  
  template <typename T>
  inline void qSwap(T &value1, T &value2)
      noexcept(noexcept(QtPrivate::SwapExceptionTester::checkSwap(value1)))
  {
      using std::swap;
      swap(value1, value2);
  }
  
  QT_WARNING_POP
  
  #if QT_DEPRECATED_SINCE(5, 0)
  Q_CORE_EXPORT QT_DEPRECATED void *qMalloc(size_t size) Q_ALLOC_SIZE(1);
  Q_CORE_EXPORT QT_DEPRECATED void qFree(void *ptr);
  Q_CORE_EXPORT QT_DEPRECATED void *qRealloc(void *ptr, size_t size) Q_ALLOC_SIZE(2);
  Q_CORE_EXPORT QT_DEPRECATED void *qMemCopy(void *dest, const void *src, size_t n);
  Q_CORE_EXPORT QT_DEPRECATED void *qMemSet(void *dest, int c, size_t n);
  #endif
  Q_CORE_EXPORT void *qMallocAligned(size_t size, size_t alignment) Q_ALLOC_SIZE(1);
  Q_CORE_EXPORT void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment) Q_ALLOC_SIZE(2);
  Q_CORE_EXPORT void qFreeAligned(void *ptr);
  
  
  /*
     Avoid some particularly useless warnings from some stupid compilers.
     To get ALL C++ compiler warnings, define QT_CC_WARNINGS or comment out
     the line "#define QT_NO_WARNINGS".
  */
  #if !defined(QT_CC_WARNINGS)
  #  define QT_NO_WARNINGS
  #endif
  #if defined(QT_NO_WARNINGS)
  #  if defined(Q_CC_MSVC)
  QT_WARNING_DISABLE_MSVC(4251) /* class 'type' needs to have dll-interface to be used by clients of class 'type2' */
  QT_WARNING_DISABLE_MSVC(4244) /* conversion from 'type1' to 'type2', possible loss of data */
  QT_WARNING_DISABLE_MSVC(4275) /* non - DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier' */
  QT_WARNING_DISABLE_MSVC(4514) /* unreferenced inline function has been removed */
  QT_WARNING_DISABLE_MSVC(4800) /* 'type' : forcing value to bool 'true' or 'false' (performance warning) */
  QT_WARNING_DISABLE_MSVC(4097) /* typedef-name 'identifier1' used as synonym for class-name 'identifier2' */
  QT_WARNING_DISABLE_MSVC(4706) /* assignment within conditional expression */
  QT_WARNING_DISABLE_MSVC(4355) /* 'this' : used in base member initializer list */
  QT_WARNING_DISABLE_MSVC(4710) /* function not inlined */
  QT_WARNING_DISABLE_MSVC(4530) /* C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc */
  #  elif defined(Q_CC_BOR)
  #    pragma option -w-inl
  #    pragma option -w-aus
  #    pragma warn -inl
  #    pragma warn -pia
  #    pragma warn -ccc
  #    pragma warn -rch
  #    pragma warn -sig
  #  endif
  #endif
  
  // Work around MSVC warning about use of 3-arg algorithms
  // until we can depend on the C++14 4-arg ones.
  //
  // These algortithms do NOT check for equal length.
  // They need to be treated as if they called the 3-arg version (which they do)!
  #ifdef Q_CC_MSVC
  # define QT_3ARG_ALG(alg, f1, l1, f2, l2) \
      std::alg(f1, l1, f2, l2)
  #else
  # define QT_3ARG_ALG(alg, f1, l1, f2, l2)     \
      [&f1, &l1, &f2, &l2]() {                  \
          Q_UNUSED(l2);                         \
          return std::alg(f1, l1, f2);          \
      }()
  #endif
  template <typename ForwardIterator1, typename ForwardIterator2>
  inline bool qt_is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2)
  {
      return QT_3ARG_ALG(is_permutation, first1, last1, first2, last2);
  }
  #undef QT_3ARG_ALG
  
  // this adds const to non-const objects (like std::as_const)
  template <typename T>
  Q_DECL_CONSTEXPR typename std::add_const<T>::type &qAsConst(T &t) noexcept { return t; }
  // prevent rvalue arguments:
  template <typename T>
  void qAsConst(const T &&) = delete;
  
  // like std::exchange
  template <typename T, typename U = T>
  Q_DECL_RELAXED_CONSTEXPR T qExchange(T &t, U &&newValue)
  {
      T old = std::move(t);
      t = std::forward<U>(newValue);
      return old;
  }
  
  #ifndef QT_NO_FOREACH
  
  namespace QtPrivate {
  
  template <typename T>
  class QForeachContainer {
      Q_DISABLE_COPY(QForeachContainer)
  public:
      QForeachContainer(const T &t) : c(t), i(qAsConst(c).begin()), e(qAsConst(c).end()) {}
      QForeachContainer(T &&t) : c(std::move(t)), i(qAsConst(c).begin()), e(qAsConst(c).end())  {}
  
      QForeachContainer(QForeachContainer &&other)
          : c(std::move(other.c)),
            i(qAsConst(c).begin()),
            e(qAsConst(c).end()),
            control(std::move(other.control))
      {
      }
  
      QForeachContainer &operator=(QForeachContainer &&other)
      {
          c = std::move(other.c);
          i = qAsConst(c).begin();
          e = qAsConst(c).end();
          control = std::move(other.control);
          return *this;
      }
  
      T c;
      typename T::const_iterator i, e;
      int control = 1;
  };
  
  template<typename T>
  QForeachContainer<typename std::decay<T>::type> qMakeForeachContainer(T &&t)
  {
      return QForeachContainer<typename std::decay<T>::type>(std::forward<T>(t));
  }
  
  }
  
  #if __cplusplus >= 201703L
  // Use C++17 if statement with initializer. User's code ends up in a else so
  // scoping of different ifs is not broken
  #define Q_FOREACH(variable, container)                                   \
  for (auto _container_ = QtPrivate::qMakeForeachContainer(container);     \
       _container_.i != _container_.e;  ++_container_.i)                   \
      if (variable = *_container_.i; false) {} else
  #else
  // Explanation of the control word:
  //  - it's initialized to 1
  //  - that means both the inner and outer loops start
  //  - if there were no breaks, at the end of the inner loop, it's set to 0, which
  //    causes it to exit (the inner loop is run exactly once)
  //  - at the end of the outer loop, it's inverted, so it becomes 1 again, allowing
  //    the outer loop to continue executing
  //  - if there was a break inside the inner loop, it will exit with control still
  //    set to 1; in that case, the outer loop will invert it to 0 and will exit too
  #define Q_FOREACH(variable, container)                                \
  for (auto _container_ = QtPrivate::qMakeForeachContainer(container); \
       _container_.control && _container_.i != _container_.e;         \
       ++_container_.i, _container_.control ^= 1)                     \
      for (variable = *_container_.i; _container_.control; _container_.control = 0)
  #endif
  #endif // QT_NO_FOREACH
  
  #define Q_FOREVER for(;;)
  #ifndef QT_NO_KEYWORDS
  # ifndef QT_NO_FOREACH
  #  ifndef foreach
  #    define foreach Q_FOREACH
  #  endif
  # endif // QT_NO_FOREACH
  #  ifndef forever
  #    define forever Q_FOREVER
  #  endif
  #endif
  
  template <typename T> inline T *qGetPtrHelper(T *ptr) { return ptr; }
  template <typename Ptr> inline auto qGetPtrHelper(Ptr &ptr) -> decltype(ptr.operator->()) { return ptr.operator->(); }
  
  // The body must be a statement:
  #define Q_CAST_IGNORE_ALIGN(body) QT_WARNING_PUSH QT_WARNING_DISABLE_GCC("-Wcast-align") body QT_WARNING_POP
  #define Q_DECLARE_PRIVATE(Class) \
      inline Class##Private* d_func() \
      { Q_CAST_IGNORE_ALIGN(return reinterpret_cast<Class##Private *>(qGetPtrHelper(d_ptr));) } \
      inline const Class##Private* d_func() const \
      { Q_CAST_IGNORE_ALIGN(return reinterpret_cast<const Class##Private *>(qGetPtrHelper(d_ptr));) } \
      friend class Class##Private;
  
  #define Q_DECLARE_PRIVATE_D(Dptr, Class) \
      inline Class##Private* d_func() \
      { Q_CAST_IGNORE_ALIGN(return reinterpret_cast<Class##Private *>(qGetPtrHelper(Dptr));) } \
      inline const Class##Private* d_func() const \
      { Q_CAST_IGNORE_ALIGN(return reinterpret_cast<const Class##Private *>(qGetPtrHelper(Dptr));) } \
      friend class Class##Private;
  
  #define Q_DECLARE_PUBLIC(Class)                                    \
      inline Class* q_func() { return static_cast<Class *>(q_ptr); } \
      inline const Class* q_func() const { return static_cast<const Class *>(q_ptr); } \
      friend class Class;
  
  #define Q_D(Class) Class##Private * const d = d_func()
  #define Q_Q(Class) Class * const q = q_func()
  
  #define QT_TR_NOOP(x) x
  #define QT_TR_NOOP_UTF8(x) x
  #define QT_TRANSLATE_NOOP(scope, x) x
  #define QT_TRANSLATE_NOOP_UTF8(scope, x) x
  #define QT_TRANSLATE_NOOP3(scope, x, comment) {x, comment}
  #define QT_TRANSLATE_NOOP3_UTF8(scope, x, comment) {x, comment}
  
  #ifndef QT_NO_TRANSLATION // ### Qt6: This should enclose the NOOPs above
  
  #define QT_TR_N_NOOP(x) x
  #define QT_TRANSLATE_N_NOOP(scope, x) x
  #define QT_TRANSLATE_N_NOOP3(scope, x, comment) {x, comment}
  
  // Defined in qcoreapplication.cpp
  // The better name qTrId() is reserved for an upcoming function which would
  // return a much more powerful QStringFormatter instead of a QString.
  Q_CORE_EXPORT QString qtTrId(const char *id, int n = -1);
  
  #define QT_TRID_NOOP(id) id
  
  #endif // QT_NO_TRANSLATION
  
  /*
     When RTTI is not available, define this macro to force any uses of
     dynamic_cast to cause a compile failure.
  */
  
  #if defined(QT_NO_DYNAMIC_CAST) && !defined(dynamic_cast)
  #  define dynamic_cast QT_PREPEND_NAMESPACE(qt_dynamic_cast_check)
  
    template<typename T, typename X>
    T qt_dynamic_cast_check(X, T* = 0)
    { return T::dynamic_cast_will_always_fail_because_rtti_is_disabled; }
  #endif
  
  
  #ifdef Q_QDOC
  
  // Just for documentation generation
  template<typename T>
  auto qOverload(T functionPointer);
  template<typename T>
  auto qConstOverload(T memberFunctionPointer);
  template<typename T>
  auto qNonConstOverload(T memberFunctionPointer);
  
  #elif defined(Q_COMPILER_VARIADIC_TEMPLATES)
  
  template <typename... Args>
  struct QNonConstOverload
  {
      template <typename R, typename T>
      Q_DECL_CONSTEXPR auto operator()(R (T::*ptr)(Args...)) const noexcept -> decltype(ptr)
      { return ptr; }
  
      template <typename R, typename T>
      static Q_DECL_CONSTEXPR auto of(R (T::*ptr)(Args...)) noexcept -> decltype(ptr)
      { return ptr; }
  };
  
  template <typename... Args>
  struct QConstOverload
  {
      template <typename R, typename T>
      Q_DECL_CONSTEXPR auto operator()(R (T::*ptr)(Args...) const) const noexcept -> decltype(ptr)
      { return ptr; }
  
      template <typename R, typename T>
      static Q_DECL_CONSTEXPR auto of(R (T::*ptr)(Args...) const) noexcept -> decltype(ptr)
      { return ptr; }
  };
  
  template <typename... Args>
  struct QOverload : QConstOverload<Args...>, QNonConstOverload<Args...>
  {
      using QConstOverload<Args...>::of;
      using QConstOverload<Args...>::operator();
      using QNonConstOverload<Args...>::of;
      using QNonConstOverload<Args...>::operator();
  
      template <typename R>
      Q_DECL_CONSTEXPR auto operator()(R (*ptr)(Args...)) const noexcept -> decltype(ptr)
      { return ptr; }
  
      template <typename R>
      static Q_DECL_CONSTEXPR auto of(R (*ptr)(Args...)) noexcept -> decltype(ptr)
      { return ptr; }
  };
  
  #if defined(__cpp_variable_templates) && __cpp_variable_templates >= 201304 // C++14
  template <typename... Args> Q_CONSTEXPR Q_DECL_UNUSED QOverload<Args...> qOverload = {};
  template <typename... Args> Q_CONSTEXPR Q_DECL_UNUSED QConstOverload<Args...> qConstOverload = {};
  template <typename... Args> Q_CONSTEXPR Q_DECL_UNUSED QNonConstOverload<Args...> qNonConstOverload = {};
  #endif
  
  #endif
  
  
  class QByteArray;
  Q_CORE_EXPORT QByteArray qgetenv(const char *varName);
  // need it as two functions because QString is only forward-declared here
  Q_CORE_EXPORT QString qEnvironmentVariable(const char *varName);
  Q_CORE_EXPORT QString qEnvironmentVariable(const char *varName, const QString &defaultValue);
  Q_CORE_EXPORT bool qputenv(const char *varName, const QByteArray& value);
  Q_CORE_EXPORT bool qunsetenv(const char *varName);
  
  Q_CORE_EXPORT bool qEnvironmentVariableIsEmpty(const char *varName) noexcept;
  Q_CORE_EXPORT bool qEnvironmentVariableIsSet(const char *varName) noexcept;
  Q_CORE_EXPORT int  qEnvironmentVariableIntValue(const char *varName, bool *ok=nullptr) noexcept;
  
  inline int qIntCast(double f) { return int(f); }
  inline int qIntCast(float f) { return int(f); }
  
  /*
    Reentrant versions of basic rand() functions for random number generation
  */
  #if QT_DEPRECATED_SINCE(5, 15)
  Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_5_15("use QRandomGenerator instead") void qsrand(uint seed);
  Q_CORE_EXPORT QT_DEPRECATED_VERSION_X_5_15("use QRandomGenerator instead") int qrand();
  #endif
  
  #define QT_MODULE(x)
  
  #if !defined(QT_BOOTSTRAPPED) && defined(QT_REDUCE_RELOCATIONS) && defined(__ELF__) && \
      (!defined(__PIC__) || (defined(__PIE__) && defined(Q_CC_GNU) && Q_CC_GNU >= 500))
  #  error "You must build your code with position independent code if Qt was built with -reduce-relocations. "\
           "Compile your code with -fPIC (-fPIE is not enough)."
  #endif
  
  namespace QtPrivate {
  //like std::enable_if
  template <bool B, typename T = void> struct QEnableIf;
  template <typename T> struct QEnableIf<true, T> { typedef T Type; };
  }
  
  QT_END_NAMESPACE
  
  // We need to keep QTypeInfo, QSysInfo, QFlags, qDebug & family in qglobal.h for compatibility with Qt 4.
  // Be careful when changing the order of these files.
  #include <QtCore/qtypeinfo.h>
  #include <QtCore/qsysinfo.h>
  #include <QtCore/qlogging.h>
  
  #include <QtCore/qflags.h>
  
  #include <QtCore/qatomic.h>
  #include <QtCore/qglobalstatic.h>
  #include <QtCore/qnumeric.h>
  #include <QtCore/qversiontagging.h>
  
  #endif /* __cplusplus */
  #endif /* !__ASSEMBLER__ */
  
  #endif /* QGLOBAL_H */
  