diff --git a/include/vulkan/vulkan_funcs.hpp b/include/vulkan/vulkan_funcs.hpp
index a3d1293..656154a 100644
--- a/include/vulkan/vulkan_funcs.hpp
+++ b/include/vulkan/vulkan_funcs.hpp
@@ -15652,35 +15652,6 @@ namespace VULKAN_HPP_NAMESPACE
   }
 
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-  template <typename Dispatch>
-  VULKAN_HPP_DEPRECATED( "This function is deprecated. Use one of the other flavours of it." )
-  VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
-    typename ResultValueType<uint64_t>::type Device::getCalibratedTimestampsEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
-      ArrayProxy<uint64_t> const &                                               timestamps,
-      Dispatch const &                                                           d ) const
-  {
-    VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
-#  ifdef VULKAN_HPP_NO_EXCEPTIONS
-    VULKAN_HPP_ASSERT( timestampInfos.size() == timestamps.size() );
-#  else
-    if ( timestampInfos.size() != timestamps.size() )
-    {
-      throw LogicError( VULKAN_HPP_NAMESPACE_STRING
-                        "::VkDevice::getCalibratedTimestampsEXT: timestampInfos.size() != timestamps.size()" );
-    }
-#  endif /*VULKAN_HPP_NO_EXCEPTIONS*/
-    uint64_t maxDeviation;
-    Result   result = static_cast<Result>(
-      d.vkGetCalibratedTimestampsEXT( m_device,
-                                      timestampInfos.size(),
-                                      reinterpret_cast<const VkCalibratedTimestampInfoEXT *>( timestampInfos.data() ),
-                                      timestamps.data(),
-                                      &maxDeviation ) );
-    return createResultValue(
-      result, maxDeviation, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
-  }
-
   template <typename Uint64_tAllocator, typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::pair<std::vector<uint64_t, Uint64_tAllocator>, uint64_t>>::type
@@ -15728,6 +15699,7 @@ namespace VULKAN_HPP_NAMESPACE
                                       &maxDeviation ) );
     return createResultValue( result, data, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" );
   }
+
   template <typename Dispatch>
   VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
     typename ResultValueType<std::pair<uint64_t, uint64_t>>::type
diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp
index 741f759..d735a72 100644
--- a/include/vulkan/vulkan_handles.hpp
+++ b/include/vulkan/vulkan_handles.hpp
@@ -11040,11 +11040,6 @@ namespace VULKAN_HPP_NAMESPACE
       uint64_t *                                               pMaxDeviation,
       Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
 #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
-    template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
-    VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<uint64_t>::type getCalibratedTimestampsEXT(
-      ArrayProxy<const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT> const & timestampInfos,
-      ArrayProxy<uint64_t> const &                                               timestamps,
-      Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
     template <typename Uint64_tAllocator = std::allocator<uint64_t>,
               typename Dispatch          = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
     VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS
diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp
index 7a9cc4a..705936f 100644
--- a/include/vulkan/vulkan_hash.hpp
+++ b/include/vulkan/vulkan_hash.hpp
@@ -994,9 +994,15 @@ namespace std
       std::size_t seed = 0;
       VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType );
       VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pApplicationName );
+      for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion );
-      VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pEngineName );
+      for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion );
       VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion );
       return seed;
@@ -2196,7 +2202,10 @@ namespace std
       VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags );
       VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage );
       VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module );
-      VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pName );
+      for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo );
       return seed;
     }
@@ -2421,7 +2430,10 @@ namespace std
       VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType );
       VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext );
       VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module );
-      VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pName );
+      for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       return seed;
     }
   };
@@ -2493,7 +2505,10 @@ namespace std
       std::size_t seed = 0;
       VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType );
       VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pMarkerName );
+      for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       for ( size_t i = 0; i < 4; ++i )
       {
         VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] );
@@ -2513,7 +2528,10 @@ namespace std
       VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext );
       VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType );
       VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object );
-      VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pObjectName );
+      for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       return seed;
     }
   };
@@ -2561,7 +2579,10 @@ namespace std
       std::size_t seed = 0;
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType );
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext );
-      VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pLabelName );
+      for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       for ( size_t i = 0; i < 4; ++i )
       {
         VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] );
@@ -2581,7 +2602,10 @@ namespace std
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext );
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType );
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle );
-      VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pObjectName );
+      for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       return seed;
     }
   };
@@ -2596,9 +2620,15 @@ namespace std
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType );
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext );
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags );
-      VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pMessageIdName );
+      for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber );
-      VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pMessage );
+      for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount );
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels );
       VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount );
@@ -3089,9 +3119,21 @@ namespace std
       VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount );
       VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos );
       VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledLayerCount );
-      VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.ppEnabledLayerNames );
+      for ( size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i )
+      {
+        for ( const char * p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p )
+        {
+          VULKAN_HPP_HASH_COMBINE( seed, *p );
+        }
+      }
       VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount );
-      VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.ppEnabledExtensionNames );
+      for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i )
+      {
+        for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p )
+        {
+          VULKAN_HPP_HASH_COMBINE( seed, *p );
+        }
+      }
       VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures );
       return seed;
     }
@@ -3630,7 +3672,10 @@ namespace std
     {
       std::size_t seed = 0;
       VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display );
-      VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.displayName );
+      for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p )
+      {
+        VULKAN_HPP_HASH_COMBINE( seed, *p );
+      }
       VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions );
       VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution );
       VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms );
@@ -5411,9 +5456,21 @@ namespace std
       VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags );
       VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo );
       VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount );
-      VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.ppEnabledLayerNames );
+      for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i )
+      {
+        for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p )
+        {
+          VULKAN_HPP_HASH_COMBINE( seed, *p );
+        }
+      }
       VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount );
-      VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.ppEnabledExtensionNames );
+      for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i )
+      {
+        for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p )
+        {
+          VULKAN_HPP_HASH_COMBINE( seed, *p );
+        }
+      }
       return seed;
     }
   };
diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp
index bc87d15..d029dbf 100644
--- a/include/vulkan/vulkan_structs.hpp
+++ b/include/vulkan/vulkan_structs.hpp
@@ -96,27 +96,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAabbPositionsKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<float const &, float const &, float const &, float const &, float const &, float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( minX, minY, minZ, maxX, maxY, maxZ );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AabbPositionsKHR const & ) const = default;
 #else
     bool operator==( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( minX == rhs.minX ) && ( minY == rhs.minY ) && ( minZ == rhs.minZ ) && ( maxX == rhs.maxX ) &&
+             ( maxY == rhs.maxY ) && ( maxZ == rhs.maxZ );
+#  endif
     }
 
     bool operator!=( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -178,8 +185,8 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress;
     const void *                        hostAddress;
 #else
-    VkDeviceAddress deviceAddress;
-    const void *    hostAddress;
+    VkDeviceAddress                                 deviceAddress;
+    const void *                                    hostAddress;
 #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
   };
 
@@ -297,9 +304,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureGeometryTrianglesDataKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Format const &,
@@ -309,12 +317,13 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::IndexType const &,
                VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
                VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType        = StructureType::eAccelerationStructureGeometryTrianglesDataKHR;
@@ -412,18 +421,20 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureGeometryAabbsDataKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, data, stride );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType               sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR;
@@ -516,18 +527,20 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureGeometryInstancesDataKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, arrayOfPointers, data );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType           = StructureType::eAccelerationStructureGeometryInstancesDataKHR;
@@ -689,19 +702,21 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureGeometryKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::GeometryTypeKHR const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR const &,
                VULKAN_HPP_NAMESPACE::GeometryFlagsKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, geometryType, geometry, flags );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType   sType        = StructureType::eAccelerationStructureGeometryKHR;
@@ -766,8 +781,8 @@ namespace VULKAN_HPP_NAMESPACE
     VULKAN_HPP_NAMESPACE::DeviceAddress deviceAddress;
     void *                              hostAddress;
 #else
-    VkDeviceAddress deviceAddress;
-    void *          hostAddress;
+    VkDeviceAddress                                 deviceAddress;
+    void *                                          hostAddress;
 #endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/
   };
 
@@ -962,9 +977,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureBuildGeometryInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR const &,
@@ -976,7 +992,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR * const &,
                const VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR * const * const &,
                VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -991,6 +1007,7 @@ namespace VULKAN_HPP_NAMESPACE
                        ppGeometries,
                        scratchData );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR;
@@ -1097,27 +1114,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureBuildRangeInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( primitiveCount, primitiveOffset, firstVertex, transformOffset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureBuildRangeInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( primitiveCount == rhs.primitiveCount ) && ( primitiveOffset == rhs.primitiveOffset ) &&
+             ( firstVertex == rhs.firstVertex ) && ( transformOffset == rhs.transformOffset );
+#  endif
     }
 
     bool operator!=( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -1213,31 +1237,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureBuildSizesInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureBuildSizesInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( accelerationStructureSize == rhs.accelerationStructureSize ) &&
+             ( updateScratchSize == rhs.updateScratchSize ) && ( buildScratchSize == rhs.buildScratchSize );
+#  endif
     }
 
     bool operator!=( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -1367,9 +1399,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureCreateFlagsKHR const &,
@@ -1378,23 +1411,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureTypeKHR const &,
                VULKAN_HPP_NAMESPACE::DeviceAddress const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureCreateInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) &&
+             ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( size == rhs.size ) && ( type == rhs.type ) &&
+             ( deviceAddress == rhs.deviceAddress );
+#  endif
     }
 
     bool operator!=( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -1565,9 +1605,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeometryTrianglesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
@@ -1581,7 +1622,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::IndexType const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -1598,18 +1639,28 @@ namespace VULKAN_HPP_NAMESPACE
                        transformData,
                        transformOffset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeometryTrianglesNV const & ) const = default;
 #else
     bool operator==( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexData == rhs.vertexData ) &&
+             ( vertexOffset == rhs.vertexOffset ) && ( vertexCount == rhs.vertexCount ) &&
+             ( vertexStride == rhs.vertexStride ) && ( vertexFormat == rhs.vertexFormat ) &&
+             ( indexData == rhs.indexData ) && ( indexOffset == rhs.indexOffset ) && ( indexCount == rhs.indexCount ) &&
+             ( indexType == rhs.indexType ) && ( transformData == rhs.transformData ) &&
+             ( transformOffset == rhs.transformOffset );
+#  endif
     }
 
     bool operator!=( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -1716,32 +1767,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeometryAABBNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, aabbData, numAABBs, stride, offset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeometryAABBNV const & ) const = default;
 #else
     bool operator==( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) &&
+             ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) && ( offset == rhs.offset );
+#  endif
     }
 
     bool operator!=( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -1818,27 +1876,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeometryDataNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const &, VULKAN_HPP_NAMESPACE::GeometryAABBNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( triangles, aabbs );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeometryDataNV const & ) const = default;
 #else
     bool operator==( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs );
+#  endif
     }
 
     bool operator!=( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -1923,31 +1987,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeometryNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::GeometryTypeKHR const &,
                VULKAN_HPP_NAMESPACE::GeometryDataNV const &,
                VULKAN_HPP_NAMESPACE::GeometryFlagsKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, geometryType, geometry, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeometryNV const & ) const = default;
 #else
     bool operator==( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) &&
+             ( geometry == rhs.geometry ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -2086,9 +2157,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureTypeNV const &,
@@ -2096,23 +2168,30 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::GeometryNV * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureInfoNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) &&
+             ( instanceCount == rhs.instanceCount ) && ( geometryCount == rhs.geometryCount ) &&
+             ( pGeometries == rhs.pGeometries );
+#  endif
     }
 
     bool operator!=( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -2205,30 +2284,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, compactedSize, info );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureCreateInfoNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) &&
+             ( info == rhs.info );
+#  endif
     }
 
     bool operator!=( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -2313,29 +2399,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureDeviceAddressInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, accelerationStructure );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure );
+#  endif
     }
 
     bool operator!=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -2421,17 +2513,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureGeometryMotionTrianglesDataNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, vertexData );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV;
@@ -2498,27 +2592,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkTransformMatrixKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ArrayWrapper2D<float, 3, 4> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( matrix );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( TransformMatrixKHR const & ) const = default;
 #else
     bool operator==( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( matrix == rhs.matrix );
+#  endif
     }
 
     bool operator!=( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -2623,16 +2723,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureInstanceKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &,
                uint32_t const &,
                uint32_t const &,
                uint32_t const &,
                VkGeometryInstanceFlagsKHR const &,
                uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( transform,
@@ -2642,18 +2743,26 @@ namespace VULKAN_HPP_NAMESPACE
                        flags,
                        accelerationStructureReference );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureInstanceKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( transform == rhs.transform ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) &&
+             ( mask == rhs.mask ) &&
+             ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) &&
+             ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference );
+#  endif
     }
 
     bool operator!=( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -2777,9 +2886,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureMatrixMotionInstanceNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &,
                VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &,
                uint32_t const &,
@@ -2787,7 +2897,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                VkGeometryInstanceFlagsKHR const &,
                uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( transformT0,
@@ -2798,18 +2908,26 @@ namespace VULKAN_HPP_NAMESPACE
                        flags,
                        accelerationStructureReference );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureMatrixMotionInstanceNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) &&
+             ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) &&
+             ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) &&
+             ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference );
+#  endif
     }
 
     bool operator!=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -2902,30 +3020,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureMemoryRequirementsInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsTypeNV const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, type, accelerationStructure );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) &&
+             ( accelerationStructure == rhs.accelerationStructure );
+#  endif
     }
 
     bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -3017,30 +3142,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureMotionInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoFlagsNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxInstances, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureMotionInfoNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) &&
+             ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -3226,9 +3358,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSRTDataNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<float const &,
                float const &,
                float const &,
@@ -3245,23 +3378,31 @@ namespace VULKAN_HPP_NAMESPACE
                float const &,
                float const &,
                float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sx, a, b, pvx, sy, c, pvy, sz, pvz, qx, qy, qz, qw, tx, ty, tz );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SRTDataNV const & ) const = default;
 #else
     bool operator==( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sx == rhs.sx ) && ( a == rhs.a ) && ( b == rhs.b ) && ( pvx == rhs.pvx ) && ( sy == rhs.sy ) &&
+             ( c == rhs.c ) && ( pvy == rhs.pvy ) && ( sz == rhs.sz ) && ( pvz == rhs.pvz ) && ( qx == rhs.qx ) &&
+             ( qy == rhs.qy ) && ( qz == rhs.qz ) && ( qw == rhs.qw ) && ( tx == rhs.tx ) && ( ty == rhs.ty ) &&
+             ( tz == rhs.tz );
+#  endif
     }
 
     bool operator!=( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -3392,9 +3533,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureSRTMotionInstanceNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::SRTDataNV const &,
                VULKAN_HPP_NAMESPACE::SRTDataNV const &,
                uint32_t const &,
@@ -3402,7 +3544,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                VkGeometryInstanceFlagsKHR const &,
                uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( transformT0,
@@ -3413,18 +3555,26 @@ namespace VULKAN_HPP_NAMESPACE
                        flags,
                        accelerationStructureReference );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureSRTMotionInstanceNV const & ) const = default;
 #else
     bool operator==( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) &&
+             ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) &&
+             ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) &&
+             ( flags == rhs.flags ) && ( accelerationStructureReference == rhs.accelerationStructureReference );
+#  endif
     }
 
     bool operator!=( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -3580,17 +3730,19 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureMotionInstanceNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceFlagsNV const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( type, flags, data );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceTypeNV type =
@@ -3663,27 +3815,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAccelerationStructureVersionInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, const uint8_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pVersionData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AccelerationStructureVersionInfoKHR const & ) const = default;
 #else
     bool operator==( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData );
+#  endif
     }
 
     bool operator!=( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -3792,9 +3950,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAcquireNextImageInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SwapchainKHR const &,
@@ -3802,23 +3961,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Semaphore const &,
                VULKAN_HPP_NAMESPACE::Fence const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AcquireNextImageInfoKHR const & ) const = default;
 #else
     bool operator==( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) &&
+             ( timeout == rhs.timeout ) && ( semaphore == rhs.semaphore ) && ( fence == rhs.fence ) &&
+             ( deviceMask == rhs.deviceMask );
+#  endif
     }
 
     bool operator!=( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -3906,30 +4072,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAcquireProfilingLockInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AcquireProfilingLockFlagsKHR const &,
                uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, timeout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AcquireProfilingLockInfoKHR const & ) const = default;
 #else
     bool operator==( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout );
+#  endif
     }
 
     bool operator!=( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -4040,32 +4212,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAllocationCallbacks *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<void * const &,
                PFN_vkAllocationFunction const &,
                PFN_vkReallocationFunction const &,
                PFN_vkFreeFunction const &,
                PFN_vkInternalAllocationNotification const &,
                PFN_vkInternalFreeNotification const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( pUserData, pfnAllocation, pfnReallocation, pfnFree, pfnInternalAllocation, pfnInternalFree );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AllocationCallbacks const & ) const = default;
 #else
     bool operator==( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( pUserData == rhs.pUserData ) && ( pfnAllocation == rhs.pfnAllocation ) &&
+             ( pfnReallocation == rhs.pfnReallocation ) && ( pfnFree == rhs.pfnFree ) &&
+             ( pfnInternalAllocation == rhs.pfnInternalAllocation ) && ( pfnInternalFree == rhs.pfnInternalFree );
+#  endif
     }
 
     bool operator!=( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -4152,30 +4332,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkComponentMapping *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ComponentSwizzle const &,
                VULKAN_HPP_NAMESPACE::ComponentSwizzle const &,
                VULKAN_HPP_NAMESPACE::ComponentSwizzle const &,
                VULKAN_HPP_NAMESPACE::ComponentSwizzle const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( r, g, b, a );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ComponentMapping const & ) const = default;
 #else
     bool operator==( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( r == rhs.r ) && ( g == rhs.g ) && ( b == rhs.b ) && ( a == rhs.a );
+#  endif
     }
 
     bool operator!=( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -4253,9 +4439,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAndroidHardwareBufferFormatProperties2ANDROID *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Format const &,
@@ -4266,7 +4453,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
                VULKAN_HPP_NAMESPACE::ChromaLocation const &,
                VULKAN_HPP_NAMESPACE::ChromaLocation const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -4280,18 +4467,28 @@ namespace VULKAN_HPP_NAMESPACE
                        suggestedXChromaOffset,
                        suggestedYChromaOffset );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidHardwareBufferFormatProperties2ANDROID const & ) const = default;
 #  else
     bool operator==( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) &&
+             ( externalFormat == rhs.externalFormat ) && ( formatFeatures == rhs.formatFeatures ) &&
+             ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
+             ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
+             ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) &&
+             ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
+#    endif
     }
 
     bool operator!=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -4386,9 +4583,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAndroidHardwareBufferFormatPropertiesANDROID *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Format const &,
@@ -4399,7 +4597,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
                VULKAN_HPP_NAMESPACE::ChromaLocation const &,
                VULKAN_HPP_NAMESPACE::ChromaLocation const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -4413,18 +4611,28 @@ namespace VULKAN_HPP_NAMESPACE
                        suggestedXChromaOffset,
                        suggestedYChromaOffset );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const & ) const = default;
 #  else
     bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) &&
+             ( externalFormat == rhs.externalFormat ) && ( formatFeatures == rhs.formatFeatures ) &&
+             ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
+             ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
+             ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) &&
+             ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
+#    endif
     }
 
     bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -4503,30 +4711,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAndroidHardwareBufferPropertiesANDROID *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, allocationSize, memoryTypeBits );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidHardwareBufferPropertiesANDROID const & ) const = default;
 #  else
     bool operator==( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) &&
+             ( memoryTypeBits == rhs.memoryTypeBits );
+#    endif
     }
 
     bool operator!=( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -4595,27 +4810,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAndroidHardwareBufferUsageANDROID *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, androidHardwareBufferUsage );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidHardwareBufferUsageANDROID const & ) const = default;
 #  else
     bool operator==( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage );
+#    endif
     }
 
     bool operator!=( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -4703,30 +4925,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAndroidSurfaceCreateInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateFlagsKHR const &,
                struct ANativeWindow * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, window );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AndroidSurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window );
+#    endif
     }
 
     bool operator!=( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -4835,9 +5063,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkApplicationInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const char * const &,
@@ -4845,23 +5074,30 @@ namespace VULKAN_HPP_NAMESPACE
                const char * const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ApplicationInfo const & ) const = default;
 #else
     bool operator==( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pApplicationName == rhs.pApplicationName ) &&
+             ( applicationVersion == rhs.applicationVersion ) && ( pEngineName == rhs.pEngineName ) &&
+             ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion );
+#  endif
     }
 
     bool operator!=( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -5004,9 +5240,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentDescription *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags const &,
                VULKAN_HPP_NAMESPACE::Format const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
@@ -5016,24 +5253,32 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentDescription const & ) const = default;
 #else
     bool operator==( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) &&
+             ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && ( stencilLoadOp == rhs.stencilLoadOp ) &&
+             ( stencilStoreOp == rhs.stencilStoreOp ) && ( initialLayout == rhs.initialLayout ) &&
+             ( finalLayout == rhs.finalLayout );
+#  endif
     }
 
     bool operator!=( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -5181,9 +5426,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentDescription2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AttachmentDescriptionFlags const &,
@@ -5195,7 +5441,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -5210,18 +5456,26 @@ namespace VULKAN_HPP_NAMESPACE
                        initialLayout,
                        finalLayout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentDescription2 const & ) const = default;
 #else
     bool operator==( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( format == rhs.format ) &&
+             ( samples == rhs.samples ) && ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) &&
+             ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) &&
+             ( initialLayout == rhs.initialLayout ) && ( finalLayout == rhs.finalLayout );
+#  endif
     }
 
     bool operator!=( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -5320,30 +5574,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentDescriptionStencilLayout *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentDescriptionStencilLayout const & ) const = default;
 #else
     bool operator==( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) &&
+             ( stencilFinalLayout == rhs.stencilFinalLayout );
+#  endif
     }
 
     bool operator!=( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -5421,27 +5682,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentReference *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, VULKAN_HPP_NAMESPACE::ImageLayout const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( attachment, layout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentReference const & ) const = default;
 #else
     bool operator==( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( attachment == rhs.attachment ) && ( layout == rhs.layout );
+#  endif
     }
 
     bool operator!=( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -5526,31 +5793,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentReference2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &,
                VULKAN_HPP_NAMESPACE::ImageAspectFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, attachment, layout, aspectMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentReference2 const & ) const = default;
 #else
     bool operator==( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) &&
+             ( layout == rhs.layout ) && ( aspectMask == rhs.aspectMask );
+#  endif
     }
 
     bool operator!=( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -5631,27 +5905,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentReferenceStencilLayout *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ImageLayout const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stencilLayout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentReferenceStencilLayout const & ) const = default;
 #else
     bool operator==( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout );
+#  endif
     }
 
     bool operator!=( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -5771,31 +6051,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentSampleCountInfoAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SampleCountFlagBits * const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentSampleCountInfoAMD const & ) const = default;
 #else
     bool operator==( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
+             ( pColorAttachmentSamples == rhs.pColorAttachmentSamples ) &&
+             ( depthStencilAttachmentSamples == rhs.depthStencilAttachmentSamples );
+#  endif
     }
 
     bool operator!=( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -5870,27 +6158,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExtent2D *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( width, height );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Extent2D const & ) const = default;
 #else
     bool operator==( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( width == rhs.width ) && ( height == rhs.height );
+#  endif
     }
 
     bool operator!=( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -5954,27 +6248,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSampleLocationEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<float const &, float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( x, y );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SampleLocationEXT const & ) const = default;
 #else
     bool operator==( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( x == rhs.x ) && ( y == rhs.y );
+#  endif
     }
 
     bool operator!=( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -6094,33 +6394,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSampleLocationsInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SampleLocationEXT * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SampleLocationsInfoEXT const & ) const = default;
 #else
     bool operator==( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) &&
+             ( sampleLocationGridSize == rhs.sampleLocationGridSize ) &&
+             ( sampleLocationsCount == rhs.sampleLocationsCount ) && ( pSampleLocations == rhs.pSampleLocations );
+#  endif
     }
 
     bool operator!=( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -6200,27 +6509,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkAttachmentSampleLocationsEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( attachmentIndex, sampleLocationsInfo );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( AttachmentSampleLocationsEXT const & ) const = default;
 #else
     bool operator==( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( attachmentIndex == rhs.attachmentIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+#  endif
     }
 
     bool operator!=( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -6280,28 +6595,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBaseInStructure *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const struct VULKAN_HPP_NAMESPACE::BaseInStructure * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BaseInStructure const & ) const = default;
 #else
     bool operator==( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
+#  endif
     }
 
     bool operator!=( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -6359,27 +6680,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBaseOutStructure *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, struct VULKAN_HPP_NAMESPACE::BaseOutStructure * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BaseOutStructure const & ) const = default;
 #else
     bool operator==( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
+#  endif
     }
 
     bool operator!=( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -6512,9 +6839,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindAccelerationStructureMemoryInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureNV const &,
@@ -6522,23 +6850,31 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindAccelerationStructureMemoryInfoNV const & ) const = default;
 #else
     bool operator==( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) &&
+             ( memoryOffset == rhs.memoryOffset ) && ( deviceIndexCount == rhs.deviceIndexCount ) &&
+             ( pDeviceIndices == rhs.pDeviceIndices );
+#  endif
     }
 
     bool operator!=( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -6646,30 +6982,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindBufferMemoryDeviceGroupInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindBufferMemoryDeviceGroupInfo const & ) const = default;
 #else
     bool operator==( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) &&
+             ( pDeviceIndices == rhs.pDeviceIndices );
+#  endif
     }
 
     bool operator!=( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -6764,31 +7107,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindBufferMemoryInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, buffer, memory, memoryOffset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindBufferMemoryInfo const & ) const = default;
 #else
     bool operator==( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) &&
+             ( memoryOffset == rhs.memoryOffset );
+#  endif
     }
 
     bool operator!=( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -6860,27 +7210,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkOffset2D *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<int32_t const &, int32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( x, y );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Offset2D const & ) const = default;
 #else
     bool operator==( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( x == rhs.x ) && ( y == rhs.y );
+#  endif
     }
 
     bool operator!=( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -6943,27 +7299,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRect2D *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Offset2D const &, VULKAN_HPP_NAMESPACE::Extent2D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( offset, extent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Rect2D const & ) const = default;
 #else
     bool operator==( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( offset == rhs.offset ) && ( extent == rhs.extent );
+#  endif
     }
 
     bool operator!=( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -7093,33 +7455,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindImageMemoryDeviceGroupInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const uint32_t * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Rect2D * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindImageMemoryDeviceGroupInfo const & ) const = default;
 #else
     bool operator==( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) &&
+             ( pDeviceIndices == rhs.pDeviceIndices ) &&
+             ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) &&
+             ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions );
+#  endif
     }
 
     bool operator!=( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -7216,31 +7587,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindImageMemoryInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Image const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, image, memory, memoryOffset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindImageMemoryInfo const & ) const = default;
 #else
     bool operator==( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) &&
+             ( memoryOffset == rhs.memoryOffset );
+#  endif
     }
 
     bool operator!=( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -7327,30 +7705,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindImageMemorySwapchainInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SwapchainKHR const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, swapchain, imageIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindImageMemorySwapchainInfoKHR const & ) const = default;
 #else
     bool operator==( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) &&
+             ( imageIndex == rhs.imageIndex );
+#  endif
     }
 
     bool operator!=( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -7429,29 +7814,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindImagePlaneMemoryInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageAspectFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, planeAspect );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindImagePlaneMemoryInfo const & ) const = default;
 #else
     bool operator==( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect );
+#  endif
     }
 
     bool operator!=( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -7538,27 +7929,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindIndexBufferIndirectCommandNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DeviceAddress const &, uint32_t const &, VULKAN_HPP_NAMESPACE::IndexType const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( bufferAddress, size, indexType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindIndexBufferIndirectCommandNV const & ) const = default;
 #else
     bool operator==( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType );
+#  endif
     }
 
     bool operator!=( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -7620,27 +8017,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindShaderGroupIndirectCommandNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( groupIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindShaderGroupIndirectCommandNV const & ) const = default;
 #else
     bool operator==( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( groupIndex == rhs.groupIndex );
+#  endif
     }
 
     bool operator!=( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -7734,31 +8137,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseMemoryBind *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( resourceOffset, size, memory, memoryOffset, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseMemoryBind const & ) const = default;
 #else
     bool operator==( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( resourceOffset == rhs.resourceOffset ) && ( size == rhs.size ) && ( memory == rhs.memory ) &&
+             ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -7857,29 +8267,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseBufferMemoryBindInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Buffer const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SparseMemoryBind * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( buffer, bindCount, pBinds );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseBufferMemoryBindInfo const & ) const = default;
 #else
     bool operator==( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( buffer == rhs.buffer ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
+#  endif
     }
 
     bool operator!=( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -7978,29 +8394,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageOpaqueMemoryBindInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Image const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SparseMemoryBind * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( image, bindCount, pBinds );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageOpaqueMemoryBindInfo const & ) const = default;
 #else
     bool operator==( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
+#  endif
     }
 
     bool operator!=( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -8077,27 +8499,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSubresource *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( aspectMask, mipLevel, arrayLayer );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSubresource const & ) const = default;
 #else
     bool operator==( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( arrayLayer == rhs.arrayLayer );
+#  endif
     }
 
     bool operator!=( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -8169,27 +8597,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkOffset3D *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<int32_t const &, int32_t const &, int32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( x, y, z );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Offset3D const & ) const = default;
 #else
     bool operator==( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z );
+#  endif
     }
 
     bool operator!=( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -8264,27 +8698,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExtent3D *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( width, height, depth );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Extent3D const & ) const = default;
 #else
     bool operator==( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth );
+#  endif
     }
 
     bool operator!=( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -8389,32 +8829,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageMemoryBind *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresource const &,
                VULKAN_HPP_NAMESPACE::Offset3D const &,
                VULKAN_HPP_NAMESPACE::Extent3D const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::SparseMemoryBindFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( subresource, offset, extent, memory, memoryOffset, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageMemoryBind const & ) const = default;
 #else
     bool operator==( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( subresource == rhs.subresource ) && ( offset == rhs.offset ) && ( extent == rhs.extent ) &&
+             ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -8514,29 +8961,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageMemoryBindInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Image const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SparseImageMemoryBind * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( image, bindCount, pBinds );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageMemoryBindInfo const & ) const = default;
 #else
     bool operator==( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds );
+#  endif
     }
 
     bool operator!=( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -8763,9 +9216,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindSparseInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -8778,7 +9232,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Semaphore * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -8794,18 +9248,28 @@ namespace VULKAN_HPP_NAMESPACE
                        signalSemaphoreCount,
                        pSignalSemaphores );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindSparseInfo const & ) const = default;
 #else
     bool operator==( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
+             ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( bufferBindCount == rhs.bufferBindCount ) &&
+             ( pBufferBinds == rhs.pBufferBinds ) && ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) &&
+             ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) && ( imageBindCount == rhs.imageBindCount ) &&
+             ( pImageBinds == rhs.pImageBinds ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) &&
+             ( pSignalSemaphores == rhs.pSignalSemaphores );
+#  endif
     }
 
     bool operator!=( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -8897,27 +9361,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBindVertexBufferIndirectCommandNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DeviceAddress const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( bufferAddress, size, stride );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BindVertexBufferIndirectCommandNV const & ) const = default;
 #else
     bool operator==( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride );
+#  endif
     }
 
     bool operator!=( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -9002,27 +9472,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSubresourceLayers *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &, uint32_t const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( aspectMask, mipLevel, baseArrayLayer, layerCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSubresourceLayers const & ) const = default;
 #else
     bool operator==( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) &&
+             ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount );
+#  endif
     }
 
     bool operator!=( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -9120,32 +9597,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageBlit2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageBlit2KHR const & ) const = default;
 #else
     bool operator==( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) &&
+             ( srcOffsets == rhs.srcOffsets ) && ( dstSubresource == rhs.dstSubresource ) &&
+             ( dstOffsets == rhs.dstOffsets );
+#  endif
     }
 
     bool operator!=( ImageBlit2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -9302,9 +9787,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBlitImageInfo2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Image const &,
@@ -9314,24 +9800,32 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ImageBlit2KHR * const &,
                VULKAN_HPP_NAMESPACE::Filter const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BlitImageInfo2KHR const & ) const = default;
 #else
     bool operator==( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
+             ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) &&
+             ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) &&
+             ( pRegions == rhs.pRegions ) && ( filter == rhs.filter );
+#  endif
     }
 
     bool operator!=( BlitImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -9427,30 +9921,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCollectionBufferCreateInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &,
                uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, collection, index );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionBufferCreateInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) &&
+             ( index == rhs.index );
+#    endif
     }
 
     bool operator!=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -9572,9 +10073,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCollectionConstraintsInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -9582,7 +10084,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -9593,18 +10095,26 @@ namespace VULKAN_HPP_NAMESPACE
                        minBufferCountForDedicatedSlack,
                        minBufferCountForSharedSlack );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionConstraintsInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) &&
+             ( maxBufferCount == rhs.maxBufferCount ) && ( minBufferCountForCamping == rhs.minBufferCountForCamping ) &&
+             ( minBufferCountForDedicatedSlack == rhs.minBufferCountForDedicatedSlack ) &&
+             ( minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack );
+#    endif
     }
 
     bool operator!=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -9690,27 +10200,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCollectionCreateInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, zx_handle_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, collectionToken );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionCreateInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 );
+#    endif
     }
 
     bool operator!=( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -9802,30 +10319,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCollectionImageCreateInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &,
                uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, collection, index );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionImageCreateInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) &&
+             ( index == rhs.index );
+#    endif
     }
 
     bool operator!=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -9904,27 +10428,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSysmemColorSpaceFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, colorSpace );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SysmemColorSpaceFUCHSIA const & ) const = default;
 #  else
     bool operator==( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace );
+#    endif
     }
 
     bool operator!=( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -10097,9 +10627,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCollectionPropertiesFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -10113,7 +10644,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::SamplerYcbcrRange const &,
                VULKAN_HPP_NAMESPACE::ChromaLocation const &,
                VULKAN_HPP_NAMESPACE::ChromaLocation const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -10130,18 +10661,30 @@ namespace VULKAN_HPP_NAMESPACE
                        suggestedXChromaOffset,
                        suggestedYChromaOffset );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCollectionPropertiesFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ) &&
+             ( bufferCount == rhs.bufferCount ) && ( createInfoIndex == rhs.createInfoIndex ) &&
+             ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( formatFeatures == rhs.formatFeatures ) &&
+             ( sysmemColorSpaceIndex == rhs.sysmemColorSpaceIndex ) &&
+             ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) &&
+             ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) &&
+             ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) &&
+             ( suggestedYChromaOffset == rhs.suggestedYChromaOffset );
+#    endif
     }
 
     bool operator!=( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -10299,9 +10842,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::BufferCreateFlags const &,
@@ -10310,23 +10854,31 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::SharingMode const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCreateInfo const & ) const = default;
 #else
     bool operator==( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( size == rhs.size ) &&
+             ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) &&
+             ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
+             ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+#  endif
     }
 
     bool operator!=( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -10428,31 +10980,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferConstraintsInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::BufferCreateInfo const &,
                VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
                VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferConstraintsInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) &&
+             ( requiredFormatFeatures == rhs.requiredFormatFeatures ) &&
+             ( bufferCollectionConstraints == rhs.bufferCollectionConstraints );
+#    endif
     }
 
     bool operator!=( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -10537,29 +11097,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCopy *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( srcOffset, dstOffset, size );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCopy const & ) const = default;
 #else
     bool operator==( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size );
+#  endif
     }
 
     bool operator!=( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -10644,31 +11210,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferCopy2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcOffset, dstOffset, size );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferCopy2KHR const & ) const = default;
 #else
     bool operator==( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) &&
+             ( dstOffset == rhs.dstOffset ) && ( size == rhs.size );
+#  endif
     }
 
     bool operator!=( BufferCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -10747,29 +11320,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferDeviceAddressCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceAddress const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceAddress );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferDeviceAddressCreateInfoEXT const & ) const = default;
 #else
     bool operator==( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress );
+#  endif
     }
 
     bool operator!=( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -10845,27 +11424,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferDeviceAddressInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Buffer const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, buffer );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferDeviceAddressInfo const & ) const = default;
 #else
     bool operator==( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
+#  endif
     }
 
     bool operator!=( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -10976,32 +11561,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferImageCopy *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::Offset3D const &,
                VULKAN_HPP_NAMESPACE::Extent3D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferImageCopy const & ) const = default;
 #else
     bool operator==( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) &&
+             ( bufferImageHeight == rhs.bufferImageHeight ) && ( imageSubresource == rhs.imageSubresource ) &&
+             ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent );
+#  endif
     }
 
     bool operator!=( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -11116,9 +11709,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferImageCopy2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
@@ -11127,24 +11721,32 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::Offset3D const &,
                VULKAN_HPP_NAMESPACE::Extent3D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferImageCopy2KHR const & ) const = default;
 #else
     bool operator==( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferOffset == rhs.bufferOffset ) &&
+             ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) &&
+             ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) &&
+             ( imageExtent == rhs.imageExtent );
+#  endif
     }
 
     bool operator!=( BufferImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -11275,9 +11877,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferMemoryBarrier *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccessFlags const &,
@@ -11287,24 +11890,32 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferMemoryBarrier const & ) const = default;
 #else
     bool operator==( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) &&
+             ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
+             ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) &&
+             ( offset == rhs.offset ) && ( size == rhs.size );
+#  endif
     }
 
     bool operator!=( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -11456,9 +12067,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferMemoryBarrier2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
@@ -11470,7 +12082,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -11485,18 +12097,27 @@ namespace VULKAN_HPP_NAMESPACE
                        offset,
                        size );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferMemoryBarrier2KHR const & ) const = default;
 #else
     bool operator==( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) &&
+             ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) &&
+             ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
+             ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) &&
+             ( offset == rhs.offset ) && ( size == rhs.size );
+#  endif
     }
 
     bool operator!=( BufferMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -11581,27 +12202,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferMemoryRequirementsInfo2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Buffer const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, buffer );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferMemoryRequirementsInfo2 const & ) const = default;
 #else
     bool operator==( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
+#  endif
     }
 
     bool operator!=( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -11682,27 +12309,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferOpaqueCaptureAddressCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, opaqueCaptureAddress );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const & ) const = default;
 #else
     bool operator==( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress );
+#  endif
     }
 
     bool operator!=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -11814,9 +12447,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkBufferViewCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::BufferViewCreateFlags const &,
@@ -11824,23 +12458,29 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Format const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, buffer, format, offset, range );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( BufferViewCreateInfo const & ) const = default;
 #else
     bool operator==( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) &&
+             ( format == rhs.format ) && ( offset == rhs.offset ) && ( range == rhs.range );
+#  endif
     }
 
     bool operator!=( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -11921,29 +12561,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCalibratedTimestampInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::TimeDomainEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, timeDomain );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CalibratedTimestampInfoEXT const & ) const = default;
 #else
     bool operator==( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain );
+#  endif
     }
 
     bool operator!=( CalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -12005,30 +12651,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCheckpointData2NV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
                void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stage, pCheckpointMarker );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CheckpointData2NV const & ) const = default;
 #else
     bool operator==( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) &&
+             ( pCheckpointMarker == rhs.pCheckpointMarker );
+#  endif
     }
 
     bool operator!=( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -12091,30 +12744,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCheckpointDataNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlagBits const &,
                void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stage, pCheckpointMarker );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CheckpointDataNV const & ) const = default;
 #else
     bool operator==( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) &&
+             ( pCheckpointMarker == rhs.pCheckpointMarker );
+#  endif
     }
 
     bool operator!=( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -12233,27 +12893,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkClearDepthStencilValue *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<float const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( depth, stencil );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ClearDepthStencilValue const & ) const = default;
 #else
     bool operator==( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( depth == rhs.depth ) && ( stencil == rhs.stencil );
+#  endif
     }
 
     bool operator!=( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -12376,16 +13042,18 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkClearAttachment *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::
       tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &, uint32_t const &, VULKAN_HPP_NAMESPACE::ClearValue const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( aspectMask, colorAttachment, clearValue );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::ImageAspectFlags aspectMask      = {};
@@ -12456,27 +13124,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkClearRect *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Rect2D const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( rect, baseArrayLayer, layerCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ClearRect const & ) const = default;
 #else
-    bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool                     operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( rect == rhs.rect ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount );
+#  endif
     }
 
     bool operator!=( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -12549,27 +13223,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCoarseSampleLocationNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( pixelX, pixelY, sample );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CoarseSampleLocationNV const & ) const = default;
 #else
     bool operator==( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( pixelX == rhs.pixelX ) && ( pixelY == rhs.pixelY ) && ( sample == rhs.sample );
+#  endif
     }
 
     bool operator!=( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -12682,30 +13362,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCoarseSampleOrderCustomNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV const &,
                uint32_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( shadingRate, sampleCount, sampleLocationCount, pSampleLocations );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CoarseSampleOrderCustomNV const & ) const = default;
 #else
     bool operator==( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( shadingRate == rhs.shadingRate ) && ( sampleCount == rhs.sampleCount ) &&
+             ( sampleLocationCount == rhs.sampleLocationCount ) && ( pSampleLocations == rhs.pSampleLocations );
+#  endif
     }
 
     bool operator!=( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -12796,31 +13483,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferAllocateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::CommandPool const &,
                VULKAN_HPP_NAMESPACE::CommandBufferLevel const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, commandPool, level, commandBufferCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferAllocateInfo const & ) const = default;
 #else
     bool operator==( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) &&
+             ( level == rhs.level ) && ( commandBufferCount == rhs.commandBufferCount );
+#  endif
     }
 
     bool operator!=( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -12943,9 +13637,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferInheritanceInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::RenderPass const &,
@@ -12954,24 +13649,32 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::QueryControlFlags const &,
                VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceInfo const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) &&
+             ( subpass == rhs.subpass ) && ( framebuffer == rhs.framebuffer ) &&
+             ( occlusionQueryEnable == rhs.occlusionQueryEnable ) && ( queryFlags == rhs.queryFlags ) &&
+             ( pipelineStatistics == rhs.pipelineStatistics );
+#  endif
     }
 
     bool operator!=( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -13062,30 +13765,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferBeginInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::CommandBufferUsageFlags const &,
                const VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pInheritanceInfo );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferBeginInfo const & ) const = default;
 #else
     bool operator==( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pInheritanceInfo == rhs.pInheritanceInfo );
+#  endif
     }
 
     bool operator!=( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -13170,27 +13880,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferInheritanceConditionalRenderingInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, conditionalRenderingEnable );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( conditionalRenderingEnable == rhs.conditionalRenderingEnable );
+#  endif
     }
 
     bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -13286,30 +14003,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferInheritanceRenderPassTransformInfoQCOM *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
                VULKAN_HPP_NAMESPACE::Rect2D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, transform, renderArea );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) &&
+             ( renderArea == rhs.renderArea );
+#  endif
     }
 
     bool operator!=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -13480,9 +14204,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::RenderingFlagsKHR const &,
@@ -13492,7 +14217,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Format const &,
                VULKAN_HPP_NAMESPACE::Format const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -13505,18 +14230,28 @@ namespace VULKAN_HPP_NAMESPACE
                        stencilAttachmentFormat,
                        rasterizationSamples );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceRenderingInfoKHR const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
+             ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) &&
+             ( depthAttachmentFormat == rhs.depthAttachmentFormat ) &&
+             ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ) &&
+             ( rasterizationSamples == rhs.rasterizationSamples );
+#  endif
     }
 
     bool operator!=( CommandBufferInheritanceRenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -13627,27 +14362,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkViewport *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<float const &, float const &, float const &, float const &, float const &, float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( x, y, width, height, minDepth, maxDepth );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Viewport const & ) const = default;
 #else
     bool operator==( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( x == rhs.x ) && ( y == rhs.y ) && ( width == rhs.width ) && ( height == rhs.height ) &&
+             ( minDepth == rhs.minDepth ) && ( maxDepth == rhs.maxDepth );
+#  endif
     }
 
     bool operator!=( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -13744,31 +14486,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferInheritanceViewportScissorInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Viewport * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferInheritanceViewportScissorInfoNV const & ) const = default;
 #else
     bool operator==( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) &&
+             ( viewportDepthCount == rhs.viewportDepthCount ) && ( pViewportDepths == rhs.pViewportDepths );
+#  endif
     }
 
     bool operator!=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -13856,30 +14605,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandBufferSubmitInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::CommandBuffer const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, commandBuffer, deviceMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandBufferSubmitInfoKHR const & ) const = default;
 #else
     bool operator==( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) &&
+             ( deviceMask == rhs.deviceMask );
+#  endif
     }
 
     bool operator!=( CommandBufferSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -13964,30 +14720,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCommandPoolCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::CommandPoolCreateFlags const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, queueFamilyIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CommandPoolCreateInfo const & ) const = default;
 #else
     bool operator==( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( queueFamilyIndex == rhs.queueFamilyIndex );
+#  endif
     }
 
     bool operator!=( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -14067,27 +14830,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSpecializationMapEntry *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, size_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( constantID, offset, size );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SpecializationMapEntry const & ) const = default;
 #else
     bool operator==( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( constantID == rhs.constantID ) && ( offset == rhs.offset ) && ( size == rhs.size );
+#  endif
     }
 
     bool operator!=( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -14205,30 +14974,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSpecializationInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SpecializationMapEntry * const &,
                size_t const &,
                const void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( mapEntryCount, pMapEntries, dataSize, pData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SpecializationInfo const & ) const = default;
 #else
     bool operator==( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( mapEntryCount == rhs.mapEntryCount ) && ( pMapEntries == rhs.pMapEntries ) &&
+             ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
+#  endif
     }
 
     bool operator!=( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -14335,9 +15111,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineShaderStageCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateFlags const &,
@@ -14345,23 +15122,29 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ShaderModule const &,
                const char * const &,
                const VULKAN_HPP_NAMESPACE::SpecializationInfo * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineShaderStageCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) &&
+             ( module == rhs.module ) && ( pName == rhs.pName ) && ( pSpecializationInfo == rhs.pSpecializationInfo );
+#  endif
     }
 
     bool operator!=( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -14478,9 +15261,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkComputePipelineCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
@@ -14488,23 +15272,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::PipelineLayout const &,
                VULKAN_HPP_NAMESPACE::Pipeline const &,
                int32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ComputePipelineCreateInfo const & ) const = default;
 #else
     bool operator==( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) &&
+             ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) &&
+             ( basePipelineIndex == rhs.basePipelineIndex );
+#  endif
     }
 
     bool operator!=( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -14604,31 +15395,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkConditionalRenderingBeginInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::ConditionalRenderingFlagsEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, buffer, offset, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ConditionalRenderingBeginInfoEXT const & ) const = default;
 #else
     bool operator==( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) &&
+             ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -14720,27 +15518,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkConformanceVersion *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint8_t const &, uint8_t const &, uint8_t const &, uint8_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( major, minor, subminor, patch );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ConformanceVersion const & ) const = default;
 #else
     bool operator==( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( major == rhs.major ) && ( minor == rhs.minor ) && ( subminor == rhs.subminor ) && ( patch == rhs.patch );
+#  endif
     }
 
     bool operator!=( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -14873,9 +15677,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCooperativeMatrixPropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -14886,23 +15691,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
                VULKAN_HPP_NAMESPACE::ComponentTypeNV const &,
                VULKAN_HPP_NAMESPACE::ScopeNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CooperativeMatrixPropertiesNV const & ) const = default;
 #else
     bool operator==( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) &&
+             ( KSize == rhs.KSize ) && ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) &&
+             ( DType == rhs.DType ) && ( scope == rhs.scope );
+#  endif
     }
 
     bool operator!=( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -15007,31 +15819,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyAccelerationStructureInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
                VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, src, dst, mode );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyAccelerationStructureInfoKHR const & ) const = default;
 #else
     bool operator==( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) &&
+             ( mode == rhs.mode );
+#  endif
     }
 
     bool operator!=( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -15137,19 +15956,21 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyAccelerationStructureToMemoryInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
                VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR const &,
                VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, src, dst, mode );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType            sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR;
@@ -15277,32 +16098,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyBufferInfo2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::BufferCopy2KHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyBufferInfo2KHR const & ) const = default;
 #else
     bool operator==( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) &&
+             ( dstBuffer == rhs.dstBuffer ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
+#  endif
     }
 
     bool operator!=( CopyBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -15441,9 +16269,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyBufferToImageInfo2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
@@ -15451,23 +16280,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ImageLayout const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyBufferToImageInfo2KHR const & ) const = default;
 #else
     bool operator==( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) &&
+             ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) &&
+             ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
+#  endif
     }
 
     bool operator!=( CopyBufferToImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -15549,29 +16385,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyCommandTransformInfoQCOM *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, transform );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyCommandTransformInfoQCOM const & ) const = default;
 #else
     bool operator==( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform );
+#  endif
     }
 
     bool operator!=( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -15697,9 +16539,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyDescriptorSet *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DescriptorSet const &,
@@ -15709,24 +16552,32 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyDescriptorSet const & ) const = default;
 #else
     bool operator==( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSet == rhs.srcSet ) &&
+             ( srcBinding == rhs.srcBinding ) && ( srcArrayElement == rhs.srcArrayElement ) &&
+             ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) &&
+             ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount );
+#  endif
     }
 
     bool operator!=( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -15842,9 +16693,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageCopy2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
@@ -15852,23 +16704,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::Offset3D const &,
                VULKAN_HPP_NAMESPACE::Extent3D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageCopy2KHR const & ) const = default;
 #else
     bool operator==( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) &&
+             ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) &&
+             ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+#  endif
     }
 
     bool operator!=( ImageCopy2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -16016,9 +16875,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyImageInfo2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Image const &,
@@ -16027,23 +16887,31 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ImageLayout const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ImageCopy2KHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyImageInfo2KHR const & ) const = default;
 #else
     bool operator==( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
+             ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) &&
+             ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) &&
+             ( pRegions == rhs.pRegions );
+#  endif
     }
 
     bool operator!=( CopyImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -16184,9 +17052,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyImageToBufferInfo2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Image const &,
@@ -16194,23 +17063,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Buffer const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::BufferImageCopy2KHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CopyImageToBufferInfo2KHR const & ) const = default;
 #else
     bool operator==( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
+             ( srcImageLayout == rhs.srcImageLayout ) && ( dstBuffer == rhs.dstBuffer ) &&
+             ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions );
+#  endif
     }
 
     bool operator!=( CopyImageToBufferInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -16316,19 +17192,21 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCopyMemoryToAccelerationStructureInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR const &,
                VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &,
                VULKAN_HPP_NAMESPACE::CopyAccelerationStructureModeKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, src, dst, mode );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType               sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR;
@@ -16414,30 +17292,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCuFunctionCreateInfoNVX *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::CuModuleNVX const &,
                const char * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, module, pName );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CuFunctionCreateInfoNVX const & ) const = default;
 #else
     bool operator==( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( pName == rhs.pName );
+#  endif
     }
 
     bool operator!=( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -16647,9 +17531,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCuLaunchInfoNVX *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::CuFunctionNVX const &,
@@ -16664,7 +17549,7 @@ namespace VULKAN_HPP_NAMESPACE
                const void * const * const &,
                size_t const &,
                const void * const * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -16682,18 +17567,27 @@ namespace VULKAN_HPP_NAMESPACE
                        extraCount,
                        pExtras );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CuLaunchInfoNVX const & ) const = default;
 #else
     bool operator==( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) &&
+             ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) && ( gridDimZ == rhs.gridDimZ ) &&
+             ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) &&
+             ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) &&
+             ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) && ( pExtras == rhs.pExtras );
+#  endif
     }
 
     bool operator!=( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -16802,27 +17696,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkCuModuleCreateInfoNVX *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, size_t const &, const void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, dataSize, pData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( CuModuleCreateInfoNVX const & ) const = default;
 #else
     bool operator==( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
+#  endif
     }
 
     bool operator!=( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -16956,16 +17856,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkD3D12FenceSubmitInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const uint64_t * const &,
                uint32_t const &,
                const uint64_t * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -16975,18 +17876,27 @@ namespace VULKAN_HPP_NAMESPACE
                        signalSemaphoreValuesCount,
                        pSignalSemaphoreValues );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( D3D12FenceSubmitInfoKHR const & ) const = default;
 #  else
     bool operator==( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) &&
+             ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) &&
+             ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) &&
+             ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
+#    endif
     }
 
     bool operator!=( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -17073,30 +17983,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugMarkerMarkerInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const char * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pMarkerName, color );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugMarkerMarkerInfoEXT const & ) const = default;
 #else
     bool operator==( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pMarkerName == rhs.pMarkerName ) &&
+             ( color == rhs.color );
+#  endif
     }
 
     bool operator!=( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -17191,31 +18108,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT const &,
                uint64_t const &,
                const char * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, objectType, object, pObjectName );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugMarkerObjectNameInfoEXT const & ) const = default;
 #else
     bool operator==( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
+             ( object == rhs.object ) && ( pObjectName == rhs.pObjectName );
+#  endif
     }
 
     bool operator!=( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -17353,9 +18277,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugMarkerObjectTagInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT const &,
@@ -17363,23 +18288,30 @@ namespace VULKAN_HPP_NAMESPACE
                uint64_t const &,
                size_t const &,
                const void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugMarkerObjectTagInfoEXT const & ) const = default;
 #else
     bool operator==( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
+             ( object == rhs.object ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) &&
+             ( pTag == rhs.pTag );
+#  endif
     }
 
     bool operator!=( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -17479,31 +18411,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugReportCallbackCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DebugReportFlagsEXT const &,
                PFN_vkDebugReportCallbackEXT const &,
                void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pfnCallback, pUserData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugReportCallbackCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData );
+#  endif
     }
 
     bool operator!=( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -17588,30 +18527,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsLabelEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const char * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pLabelName, color );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsLabelEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pLabelName == rhs.pLabelName ) &&
+             ( color == rhs.color );
+#  endif
     }
 
     bool operator!=( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -17705,31 +18651,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsObjectNameInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ObjectType const &,
                uint64_t const &,
                const char * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, objectType, objectHandle, pObjectName );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsObjectNameInfoEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
+             ( objectHandle == rhs.objectHandle ) && ( pObjectName == rhs.pObjectName );
+#  endif
     }
 
     bool operator!=( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -17951,9 +18904,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsMessengerCallbackDataEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataFlagsEXT const &,
@@ -17966,7 +18920,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -17982,18 +18936,28 @@ namespace VULKAN_HPP_NAMESPACE
                        objectCount,
                        pObjects );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsMessengerCallbackDataEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pMessageIdName == rhs.pMessageIdName ) && ( messageIdNumber == rhs.messageIdNumber ) &&
+             ( pMessage == rhs.pMessage ) && ( queueLabelCount == rhs.queueLabelCount ) &&
+             ( pQueueLabels == rhs.pQueueLabels ) && ( cmdBufLabelCount == rhs.cmdBufLabelCount ) &&
+             ( pCmdBufLabels == rhs.pCmdBufLabels ) && ( objectCount == rhs.objectCount ) &&
+             ( pObjects == rhs.pObjects );
+#  endif
     }
 
     bool operator!=( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -18116,9 +19080,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateFlagsEXT const &,
@@ -18126,23 +19091,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::DebugUtilsMessageTypeFlagsEXT const &,
                PFN_vkDebugUtilsMessengerCallbackEXT const &,
                void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsMessengerCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( messageSeverity == rhs.messageSeverity ) && ( messageType == rhs.messageType ) &&
+             ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData );
+#  endif
     }
 
     bool operator!=( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -18281,9 +19253,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDebugUtilsObjectTagInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ObjectType const &,
@@ -18291,23 +19264,30 @@ namespace VULKAN_HPP_NAMESPACE
                uint64_t const &,
                size_t const &,
                const void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DebugUtilsObjectTagInfoEXT const & ) const = default;
 #else
     bool operator==( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) &&
+             ( objectHandle == rhs.objectHandle ) && ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) &&
+             ( pTag == rhs.pTag );
+#  endif
     }
 
     bool operator!=( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -18391,27 +19371,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDedicatedAllocationBufferCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, dedicatedAllocation );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DedicatedAllocationBufferCreateInfoNV const & ) const = default;
 #else
     bool operator==( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
+#  endif
     }
 
     bool operator!=( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -18492,27 +19478,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDedicatedAllocationImageCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, dedicatedAllocation );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DedicatedAllocationImageCreateInfoNV const & ) const = default;
 #else
     bool operator==( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation );
+#  endif
     }
 
     bool operator!=( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -18604,30 +19596,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDedicatedAllocationMemoryAllocateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Image const &,
                VULKAN_HPP_NAMESPACE::Buffer const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, image, buffer );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const & ) const = default;
 #else
     bool operator==( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer );
+#  endif
     }
 
     bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -18733,32 +19731,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryBarrier2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
                VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
                VULKAN_HPP_NAMESPACE::AccessFlags2KHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryBarrier2KHR const & ) const = default;
 #else
     bool operator==( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) &&
+             ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) &&
+             ( dstAccessMask == rhs.dstAccessMask );
+#  endif
     }
 
     bool operator!=( MemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -18858,31 +19864,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSubresourceRange *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &,
                uint32_t const &,
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( aspectMask, baseMipLevel, levelCount, baseArrayLayer, layerCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSubresourceRange const & ) const = default;
 #else
     bool operator==( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( aspectMask == rhs.aspectMask ) && ( baseMipLevel == rhs.baseMipLevel ) &&
+             ( levelCount == rhs.levelCount ) && ( baseArrayLayer == rhs.baseArrayLayer ) &&
+             ( layerCount == rhs.layerCount );
+#  endif
     }
 
     bool operator!=( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -19033,9 +20047,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageMemoryBarrier2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
@@ -19048,7 +20063,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::Image const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -19064,18 +20079,28 @@ namespace VULKAN_HPP_NAMESPACE
                        image,
                        subresourceRange );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageMemoryBarrier2KHR const & ) const = default;
 #else
     bool operator==( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) &&
+             ( srcAccessMask == rhs.srcAccessMask ) && ( dstStageMask == rhs.dstStageMask ) &&
+             ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) &&
+             ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
+             ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) &&
+             ( subresourceRange == rhs.subresourceRange );
+#  endif
     }
 
     bool operator!=( ImageMemoryBarrier2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -19266,9 +20291,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDependencyInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DependencyFlags const &,
@@ -19278,7 +20304,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2KHR * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2KHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -19291,18 +20317,28 @@ namespace VULKAN_HPP_NAMESPACE
                        imageMemoryBarrierCount,
                        pImageMemoryBarriers );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DependencyInfoKHR const & ) const = default;
 #else
     bool operator==( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dependencyFlags == rhs.dependencyFlags ) &&
+             ( memoryBarrierCount == rhs.memoryBarrierCount ) && ( pMemoryBarriers == rhs.pMemoryBarriers ) &&
+             ( bufferMemoryBarrierCount == rhs.bufferMemoryBarrierCount ) &&
+             ( pBufferMemoryBarriers == rhs.pBufferMemoryBarriers ) &&
+             ( imageMemoryBarrierCount == rhs.imageMemoryBarrierCount ) &&
+             ( pImageMemoryBarriers == rhs.pImageMemoryBarriers );
+#  endif
     }
 
     bool operator!=( DependencyInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -19390,29 +20426,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorBufferInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( buffer, offset, range );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorBufferInfo const & ) const = default;
 #else
     bool operator==( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( range == rhs.range );
+#  endif
     }
 
     bool operator!=( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -19490,29 +20532,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorImageInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Sampler const &,
                VULKAN_HPP_NAMESPACE::ImageView const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sampler, imageView, imageLayout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorImageInfo const & ) const = default;
 #else
     bool operator==( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sampler == rhs.sampler ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout );
+#  endif
     }
 
     bool operator!=( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -19580,27 +20628,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorPoolSize *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DescriptorType const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( type, descriptorCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorPoolSize const & ) const = default;
 #else
     bool operator==( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( type == rhs.type ) && ( descriptorCount == rhs.descriptorCount );
+#  endif
     }
 
     bool operator!=( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -19716,32 +20770,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorPoolCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DescriptorPoolCreateFlags const &,
                uint32_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::DescriptorPoolSize * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorPoolCreateInfo const & ) const = default;
 #else
     bool operator==( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) &&
+             ( poolSizeCount == rhs.poolSizeCount ) && ( pPoolSizes == rhs.pPoolSizes );
+#  endif
     }
 
     bool operator!=( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -19827,27 +20888,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxInlineUniformBlockBindings );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings );
+#  endif
     }
 
     bool operator!=( DescriptorPoolInlineUniformBlockCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -19966,31 +21034,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetAllocateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DescriptorPool const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetAllocateInfo const & ) const = default;
 #else
     bool operator==( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) &&
+             ( descriptorSetCount == rhs.descriptorSetCount ) && ( pSetLayouts == rhs.pSetLayouts );
+#  endif
     }
 
     bool operator!=( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -20120,31 +21195,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetLayoutBinding *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &,
                VULKAN_HPP_NAMESPACE::DescriptorType const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
                const VULKAN_HPP_NAMESPACE::Sampler * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetLayoutBinding const & ) const = default;
 #else
     bool operator==( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( binding == rhs.binding ) && ( descriptorType == rhs.descriptorType ) &&
+             ( descriptorCount == rhs.descriptorCount ) && ( stageFlags == rhs.stageFlags ) &&
+             ( pImmutableSamplers == rhs.pImmutableSamplers );
+#  endif
     }
 
     bool operator!=( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -20251,30 +21334,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetLayoutBindingFlagsCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::DescriptorBindingFlags * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, bindingCount, pBindingFlags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const & ) const = default;
 #else
     bool operator==( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) &&
+             ( pBindingFlags == rhs.pBindingFlags );
+#  endif
     }
 
     bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -20394,31 +21484,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetLayoutCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateFlags const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, bindingCount, pBindings );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetLayoutCreateInfo const & ) const = default;
 #else
     bool operator==( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( bindingCount == rhs.bindingCount ) && ( pBindings == rhs.pBindings );
+#  endif
     }
 
     bool operator!=( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -20482,27 +21579,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetLayoutSupport *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, supported );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetLayoutSupport const & ) const = default;
 #else
     bool operator==( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported );
+#  endif
     }
 
     bool operator!=( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -20613,30 +21716,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountAllocateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const & ) const = default;
 #else
     bool operator==( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) &&
+             ( pDescriptorCounts == rhs.pDescriptorCounts );
+#  endif
     }
 
     bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -20708,27 +21818,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorSetVariableDescriptorCountLayoutSupport *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxVariableDescriptorCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const & ) const = default;
 #else
     bool operator==( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount );
+#  endif
     }
 
     bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -20842,32 +21959,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorUpdateTemplateEntry *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::DescriptorType const &,
                size_t const &,
                size_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( dstBinding, dstArrayElement, descriptorCount, descriptorType, offset, stride );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorUpdateTemplateEntry const & ) const = default;
 #else
     bool operator==( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) &&
+             ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) &&
+             ( offset == rhs.offset ) && ( stride == rhs.stride );
+#  endif
     }
 
     bool operator!=( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -21042,9 +22167,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDescriptorUpdateTemplateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags const &,
@@ -21055,7 +22181,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
                VULKAN_HPP_NAMESPACE::PipelineLayout const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -21069,18 +22195,27 @@ namespace VULKAN_HPP_NAMESPACE
                        pipelineLayout,
                        set );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DescriptorUpdateTemplateCreateInfo const & ) const = default;
 #else
     bool operator==( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) &&
+             ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) && ( templateType == rhs.templateType ) &&
+             ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
+             ( pipelineLayout == rhs.pipelineLayout ) && ( set == rhs.set );
+#  endif
     }
 
     bool operator!=( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -21169,29 +22304,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceBufferMemoryRequirementsKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const VULKAN_HPP_NAMESPACE::BufferCreateInfo * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pCreateInfo );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceBufferMemoryRequirementsKHR const & ) const = default;
 #else
     bool operator==( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo );
+#  endif
     }
 
     bool operator!=( DeviceBufferMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -21314,32 +22455,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceQueueCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags const &,
                uint32_t const &,
                uint32_t const &,
                const float * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceQueueCreateInfo const & ) const = default;
 #else
     bool operator==( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueCount == rhs.queueCount ) &&
+             ( pQueuePriorities == rhs.pQueuePriorities );
+#  endif
     }
 
     bool operator!=( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -21894,9 +23043,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -21952,7 +23102,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( robustBufferAccess,
@@ -22011,18 +23161,62 @@ namespace VULKAN_HPP_NAMESPACE
                        variableMultisampleRate,
                        inheritedQueries );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( robustBufferAccess == rhs.robustBufferAccess ) && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 ) &&
+             ( imageCubeArray == rhs.imageCubeArray ) && ( independentBlend == rhs.independentBlend ) &&
+             ( geometryShader == rhs.geometryShader ) && ( tessellationShader == rhs.tessellationShader ) &&
+             ( sampleRateShading == rhs.sampleRateShading ) && ( dualSrcBlend == rhs.dualSrcBlend ) &&
+             ( logicOp == rhs.logicOp ) && ( multiDrawIndirect == rhs.multiDrawIndirect ) &&
+             ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance ) && ( depthClamp == rhs.depthClamp ) &&
+             ( depthBiasClamp == rhs.depthBiasClamp ) && ( fillModeNonSolid == rhs.fillModeNonSolid ) &&
+             ( depthBounds == rhs.depthBounds ) && ( wideLines == rhs.wideLines ) &&
+             ( largePoints == rhs.largePoints ) && ( alphaToOne == rhs.alphaToOne ) &&
+             ( multiViewport == rhs.multiViewport ) && ( samplerAnisotropy == rhs.samplerAnisotropy ) &&
+             ( textureCompressionETC2 == rhs.textureCompressionETC2 ) &&
+             ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR ) &&
+             ( textureCompressionBC == rhs.textureCompressionBC ) &&
+             ( occlusionQueryPrecise == rhs.occlusionQueryPrecise ) &&
+             ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery ) &&
+             ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics ) &&
+             ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics ) &&
+             ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize ) &&
+             ( shaderImageGatherExtended == rhs.shaderImageGatherExtended ) &&
+             ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats ) &&
+             ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample ) &&
+             ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat ) &&
+             ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat ) &&
+             ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing ) &&
+             ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing ) &&
+             ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing ) &&
+             ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing ) &&
+             ( shaderClipDistance == rhs.shaderClipDistance ) && ( shaderCullDistance == rhs.shaderCullDistance ) &&
+             ( shaderFloat64 == rhs.shaderFloat64 ) && ( shaderInt64 == rhs.shaderInt64 ) &&
+             ( shaderInt16 == rhs.shaderInt16 ) && ( shaderResourceResidency == rhs.shaderResourceResidency ) &&
+             ( shaderResourceMinLod == rhs.shaderResourceMinLod ) && ( sparseBinding == rhs.sparseBinding ) &&
+             ( sparseResidencyBuffer == rhs.sparseResidencyBuffer ) &&
+             ( sparseResidencyImage2D == rhs.sparseResidencyImage2D ) &&
+             ( sparseResidencyImage3D == rhs.sparseResidencyImage3D ) &&
+             ( sparseResidency2Samples == rhs.sparseResidency2Samples ) &&
+             ( sparseResidency4Samples == rhs.sparseResidency4Samples ) &&
+             ( sparseResidency8Samples == rhs.sparseResidency8Samples ) &&
+             ( sparseResidency16Samples == rhs.sparseResidency16Samples ) &&
+             ( sparseResidencyAliased == rhs.sparseResidencyAliased ) &&
+             ( variableMultisampleRate == rhs.variableMultisampleRate ) && ( inheritedQueries == rhs.inheritedQueries );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -22257,9 +23451,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceCreateFlags const &,
@@ -22270,7 +23465,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                const char * const * const &,
                const VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -22284,18 +23479,27 @@ namespace VULKAN_HPP_NAMESPACE
                        ppEnabledExtensionNames,
                        pEnabledFeatures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceCreateInfo const & ) const = default;
 #else
     bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( queueCreateInfoCount == rhs.queueCreateInfoCount ) && ( pQueueCreateInfos == rhs.pQueueCreateInfos ) &&
+             ( enabledLayerCount == rhs.enabledLayerCount ) && ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) &&
+             ( enabledExtensionCount == rhs.enabledExtensionCount ) &&
+             ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames ) && ( pEnabledFeatures == rhs.pEnabledFeatures );
+#  endif
     }
 
     bool operator!=( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -22400,31 +23604,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceDeviceMemoryReportCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT const &,
                PFN_vkDeviceMemoryReportCallbackEXT const &,
                void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pfnUserCallback, pUserData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceDeviceMemoryReportCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData );
+#  endif
     }
 
     bool operator!=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -22506,29 +23717,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceDiagnosticsConfigCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const & ) const = default;
 #else
     bool operator==( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -22606,29 +23823,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceEventInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceEventTypeEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceEvent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceEventInfoEXT const & ) const = default;
 #else
     bool operator==( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceEvent == rhs.deviceEvent );
+#  endif
     }
 
     bool operator!=( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -22712,27 +23935,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupBindSparseInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, resourceDeviceIndex, memoryDeviceIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupBindSparseInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) &&
+             ( memoryDeviceIndex == rhs.memoryDeviceIndex );
+#  endif
     }
 
     bool operator!=( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -22812,27 +24042,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupCommandBufferBeginInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupCommandBufferBeginInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask );
+#  endif
     }
 
     bool operator!=( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -22940,30 +24176,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupDeviceCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::PhysicalDevice * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, physicalDeviceCount, pPhysicalDevices );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupDeviceCreateInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) &&
+             ( pPhysicalDevices == rhs.pPhysicalDevices );
+#  endif
     }
 
     bool operator!=( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -23032,30 +24275,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupPresentCapabilitiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, VK_MAX_DEVICE_GROUP_SIZE> const &,
                VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, presentMask, modes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupPresentCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMask == rhs.presentMask ) &&
+             ( modes == rhs.modes );
+#  endif
     }
 
     bool operator!=( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -23173,31 +24423,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupPresentInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const uint32_t * const &,
                VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagBitsKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, swapchainCount, pDeviceMasks, mode );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupPresentInfoKHR const & ) const = default;
 #else
     bool operator==( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
+             ( pDeviceMasks == rhs.pDeviceMasks ) && ( mode == rhs.mode );
+#  endif
     }
 
     bool operator!=( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -23316,31 +24573,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupRenderPassBeginInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Rect2D * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceMask, deviceRenderAreaCount, pDeviceRenderAreas );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupRenderPassBeginInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ) &&
+             ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) && ( pDeviceRenderAreas == rhs.pDeviceRenderAreas );
+#  endif
     }
 
     bool operator!=( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -23512,9 +24776,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupSubmitInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -23523,7 +24788,7 @@ namespace VULKAN_HPP_NAMESPACE
                const uint32_t * const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -23535,18 +24800,28 @@ namespace VULKAN_HPP_NAMESPACE
                        signalSemaphoreCount,
                        pSignalSemaphoreDeviceIndices );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupSubmitInfo const & ) const = default;
 #else
     bool operator==( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
+             ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) &&
+             ( commandBufferCount == rhs.commandBufferCount ) &&
+             ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) &&
+             ( signalSemaphoreCount == rhs.signalSemaphoreCount ) &&
+             ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices );
+#  endif
     }
 
     bool operator!=( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -23629,29 +24904,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceGroupSwapchainCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceGroupPresentModeFlagsKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, modes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const & ) const = default;
 #else
     bool operator==( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( modes == rhs.modes );
+#  endif
     }
 
     bool operator!=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -23872,9 +25153,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageCreateFlags const &,
@@ -23890,7 +25172,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                const uint32_t * const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -23909,18 +25191,28 @@ namespace VULKAN_HPP_NAMESPACE
                        pQueueFamilyIndices,
                        initialLayout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageCreateInfo const & ) const = default;
 #else
     bool operator==( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( imageType == rhs.imageType ) && ( format == rhs.format ) && ( extent == rhs.extent ) &&
+             ( mipLevels == rhs.mipLevels ) && ( arrayLayers == rhs.arrayLayers ) && ( samples == rhs.samples ) &&
+             ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) &&
+             ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
+             ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( initialLayout == rhs.initialLayout );
+#  endif
     }
 
     bool operator!=( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -24019,30 +25311,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceImageMemoryRequirementsKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const VULKAN_HPP_NAMESPACE::ImageCreateInfo * const &,
                VULKAN_HPP_NAMESPACE::ImageAspectFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pCreateInfo, planeAspect );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceImageMemoryRequirementsKHR const & ) const = default;
 #else
     bool operator==( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) &&
+             ( planeAspect == rhs.planeAspect );
+#  endif
     }
 
     bool operator!=( DeviceImageMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -24124,29 +25423,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceMemoryOpaqueCaptureAddressInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memory );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const & ) const = default;
 #else
     bool operator==( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory );
+#  endif
     }
 
     bool operator!=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -24231,29 +25536,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceMemoryOverallocationCreateInfoAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, overallocationBehavior );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const & ) const = default;
 #else
     bool operator==( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( overallocationBehavior == rhs.overallocationBehavior );
+#  endif
     }
 
     bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -24333,9 +25645,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceMemoryReportCallbackDataEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DeviceMemoryReportFlagsEXT const &,
@@ -24345,23 +25658,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ObjectType const &,
                uint64_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default;
 #else
     bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) &&
+             ( memoryObjectId == rhs.memoryObjectId ) && ( size == rhs.size ) && ( objectType == rhs.objectType ) &&
+             ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex );
+#  endif
     }
 
     bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -24447,27 +25767,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDevicePrivateDataCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, privateDataSlotRequestCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DevicePrivateDataCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( privateDataSlotRequestCount == rhs.privateDataSlotRequestCount );
+#  endif
     }
 
     bool operator!=( DevicePrivateDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -24550,29 +25877,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, globalPriority );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceQueueGlobalPriorityCreateInfoEXT const & ) const = default;
 #else
     bool operator==( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriority == rhs.globalPriority );
+#  endif
     }
 
     bool operator!=( DeviceQueueGlobalPriorityCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -24665,31 +25998,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDeviceQueueInfo2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, queueFamilyIndex, queueIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DeviceQueueInfo2 const & ) const = default;
 #else
     bool operator==( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( queueIndex == rhs.queueIndex );
+#  endif
     }
 
     bool operator!=( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -24783,31 +26123,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDirectFBSurfaceCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateFlagsEXT const &,
                IDirectFB * const &,
                IDirectFBSurface * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, dfb, surface );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DirectFBSurfaceCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) &&
+             ( surface == rhs.surface );
+#    endif
     }
 
     bool operator!=( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -24891,27 +26238,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDispatchIndirectCommand *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( x, y, z );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DispatchIndirectCommand const & ) const = default;
 #else
     bool operator==( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z );
+#  endif
     }
 
     bool operator!=( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -24982,29 +26335,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayEventInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DisplayEventTypeEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, displayEvent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayEventInfoEXT const & ) const = default;
 #else
     bool operator==( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayEvent == rhs.displayEvent );
+#  endif
     }
 
     bool operator!=( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25077,27 +26436,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayModeParametersKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Extent2D const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( visibleRegion, refreshRate );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayModeParametersKHR const & ) const = default;
 #else
     bool operator==( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( visibleRegion == rhs.visibleRegion ) && ( refreshRate == rhs.refreshRate );
+#  endif
     }
 
     bool operator!=( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25175,30 +26540,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayModeCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DisplayModeCreateFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, parameters );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayModeCreateInfoKHR const & ) const = default;
 #else
     bool operator==( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( parameters == rhs.parameters );
+#  endif
     }
 
     bool operator!=( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25259,27 +26631,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayModePropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DisplayModeKHR const &, VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( displayMode, parameters );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayModePropertiesKHR const & ) const = default;
 #else
     bool operator==( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( displayMode == rhs.displayMode ) && ( parameters == rhs.parameters );
+#  endif
     }
 
     bool operator!=( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25334,29 +26712,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayModeProperties2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, displayModeProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayModeProperties2KHR const & ) const = default;
 #else
     bool operator==( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayModeProperties == rhs.displayModeProperties );
+#  endif
     }
 
     bool operator!=( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25422,27 +26806,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayNativeHdrSurfaceCapabilitiesAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, localDimmingSupport );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const & ) const = default;
 #else
     bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingSupport == rhs.localDimmingSupport );
+#  endif
     }
 
     bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25519,9 +26909,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlaneCapabilitiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::Offset2D const &,
                VULKAN_HPP_NAMESPACE::Offset2D const &,
@@ -25531,7 +26922,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Offset2D const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( supportedAlpha,
@@ -25544,18 +26935,27 @@ namespace VULKAN_HPP_NAMESPACE
                        minDstExtent,
                        maxDstExtent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlaneCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( supportedAlpha == rhs.supportedAlpha ) && ( minSrcPosition == rhs.minSrcPosition ) &&
+             ( maxSrcPosition == rhs.maxSrcPosition ) && ( minSrcExtent == rhs.minSrcExtent ) &&
+             ( maxSrcExtent == rhs.maxSrcExtent ) && ( minDstPosition == rhs.minDstPosition ) &&
+             ( maxDstPosition == rhs.maxDstPosition ) && ( minDstExtent == rhs.minDstExtent ) &&
+             ( maxDstExtent == rhs.maxDstExtent );
+#  endif
     }
 
     bool operator!=( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25618,29 +27018,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlaneCapabilities2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, capabilities );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlaneCapabilities2KHR const & ) const = default;
 #else
     bool operator==( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilities == rhs.capabilities );
+#  endif
     }
 
     bool operator!=( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25724,30 +27130,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlaneInfo2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DisplayModeKHR const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, mode, planeIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlaneInfo2KHR const & ) const = default;
 #else
     bool operator==( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) &&
+             ( planeIndex == rhs.planeIndex );
+#  endif
     }
 
     bool operator!=( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25807,27 +27220,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlanePropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DisplayKHR const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( currentDisplay, currentStackIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlanePropertiesKHR const & ) const = default;
 #else
     bool operator==( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( currentDisplay == rhs.currentDisplay ) && ( currentStackIndex == rhs.currentStackIndex );
+#  endif
     }
 
     bool operator!=( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25882,29 +27301,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPlaneProperties2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, displayPlaneProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPlaneProperties2KHR const & ) const = default;
 #else
     bool operator==( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( displayPlaneProperties == rhs.displayPlaneProperties );
+#  endif
     }
 
     bool operator!=( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -25980,29 +27406,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPowerInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DisplayPowerStateEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, powerState );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPowerInfoEXT const & ) const = default;
 #else
     bool operator==( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( powerState == rhs.powerState );
+#  endif
     }
 
     bool operator!=( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -26094,31 +27526,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPresentInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Rect2D const &,
                VULKAN_HPP_NAMESPACE::Rect2D const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcRect, dstRect, persistent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPresentInfoKHR const & ) const = default;
 #else
     bool operator==( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRect == rhs.srcRect ) &&
+             ( dstRect == rhs.dstRect ) && ( persistent == rhs.persistent );
+#  endif
     }
 
     bool operator!=( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -26189,9 +27628,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayPropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DisplayKHR const &,
                const char * const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
@@ -26199,7 +27639,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::SurfaceTransformFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( display,
@@ -26210,18 +27650,26 @@ namespace VULKAN_HPP_NAMESPACE
                        planeReorderPossible,
                        persistentContent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayPropertiesKHR const & ) const = default;
 #else
     bool operator==( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( display == rhs.display ) && ( displayName == rhs.displayName ) &&
+             ( physicalDimensions == rhs.physicalDimensions ) && ( physicalResolution == rhs.physicalResolution ) &&
+             ( supportedTransforms == rhs.supportedTransforms ) &&
+             ( planeReorderPossible == rhs.planeReorderPossible ) && ( persistentContent == rhs.persistentContent );
+#  endif
     }
 
     bool operator!=( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -26279,29 +27727,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplayProperties2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, displayProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplayProperties2KHR const & ) const = default;
 #else
     bool operator==( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayProperties == rhs.displayProperties );
+#  endif
     }
 
     bool operator!=( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -26440,9 +27894,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDisplaySurfaceCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateFlagsKHR const &,
@@ -26453,24 +27908,32 @@ namespace VULKAN_HPP_NAMESPACE
                float const &,
                VULKAN_HPP_NAMESPACE::DisplayPlaneAlphaFlagBitsKHR const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, flags, displayMode, planeIndex, planeStackIndex, transform, globalAlpha, alphaMode, imageExtent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DisplaySurfaceCreateInfoKHR const & ) const = default;
 #else
     bool operator==( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( displayMode == rhs.displayMode ) && ( planeIndex == rhs.planeIndex ) &&
+             ( planeStackIndex == rhs.planeStackIndex ) && ( transform == rhs.transform ) &&
+             ( globalAlpha == rhs.globalAlpha ) && ( alphaMode == rhs.alphaMode ) && ( imageExtent == rhs.imageExtent );
+#  endif
     }
 
     bool operator!=( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -26578,27 +28041,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrawIndexedIndirectCommand *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, int32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( indexCount, instanceCount, firstIndex, vertexOffset, firstInstance );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrawIndexedIndirectCommand const & ) const = default;
 #else
     bool operator==( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( indexCount == rhs.indexCount ) && ( instanceCount == rhs.instanceCount ) &&
+             ( firstIndex == rhs.firstIndex ) && ( vertexOffset == rhs.vertexOffset ) &&
+             ( firstInstance == rhs.firstInstance );
+#  endif
     }
 
     bool operator!=( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -26683,27 +28154,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrawIndirectCommand *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( vertexCount, instanceCount, firstVertex, firstInstance );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrawIndirectCommand const & ) const = default;
 #else
     bool operator==( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( vertexCount == rhs.vertexCount ) && ( instanceCount == rhs.instanceCount ) &&
+             ( firstVertex == rhs.firstVertex ) && ( firstInstance == rhs.firstInstance );
+#  endif
     }
 
     bool operator!=( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -26772,27 +28250,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrawMeshTasksIndirectCommandNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( taskCount, firstTask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrawMeshTasksIndirectCommandNV const & ) const = default;
 #else
     bool operator==( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( taskCount == rhs.taskCount ) && ( firstTask == rhs.firstTask );
+#  endif
     }
 
     bool operator!=( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -26850,27 +28334,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrmFormatModifierProperties2EXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint64_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrmFormatModifierProperties2EXT const & ) const = default;
 #else
     bool operator==( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( drmFormatModifier == rhs.drmFormatModifier ) &&
+             ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) &&
+             ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures );
+#  endif
     }
 
     bool operator!=( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -26929,27 +28421,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrmFormatModifierPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint64_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrmFormatModifierPropertiesEXT const & ) const = default;
 #else
     bool operator==( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( drmFormatModifier == rhs.drmFormatModifier ) &&
+             ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) &&
+             ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures );
+#  endif
     }
 
     bool operator!=( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -27020,30 +28520,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrmFormatModifierPropertiesList2EXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrmFormatModifierPropertiesList2EXT const & ) const = default;
 #else
     bool operator==( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
+             ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties );
+#  endif
     }
 
     bool operator!=( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -27121,30 +28629,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkDrmFormatModifierPropertiesListEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( DrmFormatModifierPropertiesListEXT const & ) const = default;
 #else
     bool operator==( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
+             ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties );
+#  endif
     }
 
     bool operator!=( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -27221,29 +28737,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkEventCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::EventCreateFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( EventCreateInfo const & ) const = default;
 #else
     bool operator==( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -27318,29 +28840,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportFenceCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportFenceCreateInfo const & ) const = default;
 #else
     bool operator==( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+#  endif
     }
 
     bool operator!=( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -27434,31 +28962,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportFenceWin32HandleInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const SECURITY_ATTRIBUTES * const &,
                DWORD const &,
                LPCWSTR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pAttributes, dwAccess, name );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportFenceWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
+             ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
+#    endif
     }
 
     bool operator!=( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -27538,29 +29073,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportMemoryAllocateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportMemoryAllocateInfo const & ) const = default;
 #else
     bool operator==( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+#  endif
     }
 
     bool operator!=( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -27638,29 +29179,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportMemoryAllocateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportMemoryAllocateInfoNV const & ) const = default;
 #else
     bool operator==( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+#  endif
     }
 
     bool operator!=( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -27754,31 +29301,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportMemoryWin32HandleInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const SECURITY_ATTRIBUTES * const &,
                DWORD const &,
                LPCWSTR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pAttributes, dwAccess, name );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportMemoryWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
+             ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
+#    endif
     }
 
     bool operator!=( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -27868,30 +29422,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportMemoryWin32HandleInfoNV *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const SECURITY_ATTRIBUTES * const &,
                DWORD const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pAttributes, dwAccess );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportMemoryWin32HandleInfoNV const & ) const = default;
 #  else
     bool operator==( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
+             ( dwAccess == rhs.dwAccess );
+#    endif
     }
 
     bool operator!=( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -27971,29 +29532,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportSemaphoreCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportSemaphoreCreateInfo const & ) const = default;
 #else
     bool operator==( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+#  endif
     }
 
     bool operator!=( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -28089,31 +29656,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExportSemaphoreWin32HandleInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const SECURITY_ATTRIBUTES * const &,
                DWORD const &,
                LPCWSTR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pAttributes, dwAccess, name );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) &&
+             ( dwAccess == rhs.dwAccess ) && ( name == rhs.name );
+#    endif
     }
 
     bool operator!=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -28177,27 +29751,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExtensionProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( extensionName, specVersion );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExtensionProperties const & ) const = default;
 #else
     bool operator==( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( extensionName == rhs.extensionName ) && ( specVersion == rhs.specVersion );
+#  endif
     }
 
     bool operator!=( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -28251,29 +29831,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalMemoryProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalMemoryProperties const & ) const = default;
 #else
     bool operator==( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) &&
+             ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
+             ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+#  endif
     }
 
     bool operator!=( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -28329,29 +29917,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalBufferProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, externalMemoryProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalBufferProperties const & ) const = default;
 #else
     bool operator==( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( externalMemoryProperties == rhs.externalMemoryProperties );
+#  endif
     }
 
     bool operator!=( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -28417,31 +30012,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalFenceProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalFenceFeatures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalFenceProperties const & ) const = default;
 #else
     bool operator==( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
+             ( compatibleHandleTypes == rhs.compatibleHandleTypes ) &&
+             ( externalFenceFeatures == rhs.externalFenceFeatures );
+#  endif
     }
 
     bool operator!=( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -28519,27 +30123,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalFormatANDROID *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, externalFormat );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalFormatANDROID const & ) const = default;
 #  else
     bool operator==( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat );
+#    endif
     }
 
     bool operator!=( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -28602,29 +30212,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalImageFormatProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, externalMemoryProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalImageFormatProperties const & ) const = default;
 #else
     bool operator==( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( externalMemoryProperties == rhs.externalMemoryProperties );
+#  endif
     }
 
     bool operator!=( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -28692,31 +30309,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageFormatProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Extent3D const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( maxExtent, maxMipLevels, maxArrayLayers, sampleCounts, maxResourceSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageFormatProperties const & ) const = default;
 #else
     bool operator==( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( maxExtent == rhs.maxExtent ) && ( maxMipLevels == rhs.maxMipLevels ) &&
+             ( maxArrayLayers == rhs.maxArrayLayers ) && ( sampleCounts == rhs.sampleCounts ) &&
+             ( maxResourceSize == rhs.maxResourceSize );
+#  endif
     }
 
     bool operator!=( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -28777,31 +30402,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalImageFormatPropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ImageFormatProperties const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsNV const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         imageFormatProperties, externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalImageFormatPropertiesNV const & ) const = default;
 #else
     bool operator==( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( imageFormatProperties == rhs.imageFormatProperties ) &&
+             ( externalMemoryFeatures == rhs.externalMemoryFeatures ) &&
+             ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
+             ( compatibleHandleTypes == rhs.compatibleHandleTypes );
+#  endif
     }
 
     bool operator!=( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -28875,29 +30509,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalMemoryBufferCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalMemoryBufferCreateInfo const & ) const = default;
 #else
     bool operator==( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+#  endif
     }
 
     bool operator!=( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -28977,29 +30617,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalMemoryImageCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalMemoryImageCreateInfo const & ) const = default;
 #else
     bool operator==( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+#  endif
     }
 
     bool operator!=( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -29079,29 +30725,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalMemoryImageCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalMemoryImageCreateInfoNV const & ) const = default;
 #else
     bool operator==( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes );
+#  endif
     }
 
     bool operator!=( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -29168,31 +30820,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkExternalSemaphoreProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalSemaphoreFeatures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ExternalSemaphoreProperties const & ) const = default;
 #else
     bool operator==( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) &&
+             ( compatibleHandleTypes == rhs.compatibleHandleTypes ) &&
+             ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures );
+#  endif
     }
 
     bool operator!=( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -29271,29 +30932,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFenceCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::FenceCreateFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FenceCreateInfo const & ) const = default;
 #else
     bool operator==( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -29377,30 +31044,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFenceGetFdInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Fence const &,
                VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fence, handleType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FenceGetFdInfoKHR const & ) const = default;
 #else
     bool operator==( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) &&
+             ( handleType == rhs.handleType );
+#  endif
     }
 
     bool operator!=( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -29489,30 +31163,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFenceGetWin32HandleInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Fence const &,
                VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fence, handleType );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FenceGetWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) &&
+             ( handleType == rhs.handleType );
+#    endif
     }
 
     bool operator!=( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -29584,30 +31265,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFilterCubicImageViewImageFormatPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, filterCubic, filterCubicMinmax );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const & ) const = default;
 #else
     bool operator==( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCubic == rhs.filterCubic ) &&
+             ( filterCubicMinmax == rhs.filterCubicMinmax );
+#  endif
     }
 
     bool operator!=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -29672,29 +31360,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFormatProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
                VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &,
                VULKAN_HPP_NAMESPACE::FormatFeatureFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( linearTilingFeatures, optimalTilingFeatures, bufferFeatures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FormatProperties const & ) const = default;
 #else
     bool operator==( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( linearTilingFeatures == rhs.linearTilingFeatures ) &&
+             ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures );
+#  endif
     }
 
     bool operator!=( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -29748,28 +31443,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFormatProperties2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::
       tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::FormatProperties const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, formatProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FormatProperties2 const & ) const = default;
 #else
     bool operator==( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatProperties == rhs.formatProperties );
+#  endif
     }
 
     bool operator!=( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -29834,31 +31535,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFormatProperties3KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &,
                VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &,
                VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, linearTilingFeatures, optimalTilingFeatures, bufferFeatures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FormatProperties3KHR const & ) const = default;
 #else
     bool operator==( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearTilingFeatures == rhs.linearTilingFeatures ) &&
+             ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures );
+#  endif
     }
 
     bool operator!=( FormatProperties3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -29948,30 +31656,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFragmentShadingRateAttachmentInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pFragmentShadingRateAttachment, shadingRateAttachmentTexelSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FragmentShadingRateAttachmentInfoKHR const & ) const = default;
 #else
     bool operator==( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( pFragmentShadingRateAttachment == rhs.pFragmentShadingRateAttachment ) &&
+             ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize );
+#  endif
     }
 
     bool operator!=( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -30131,9 +31847,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFramebufferAttachmentImageInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageCreateFlags const &,
@@ -30143,23 +31860,30 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Format * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, usage, width, height, layerCount, viewFormatCount, pViewFormats );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FramebufferAttachmentImageInfo const & ) const = default;
 #else
     bool operator==( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) &&
+             ( width == rhs.width ) && ( height == rhs.height ) && ( layerCount == rhs.layerCount ) &&
+             ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats );
+#  endif
     }
 
     bool operator!=( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -30274,30 +31998,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFramebufferAttachmentsCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, attachmentImageInfoCount, pAttachmentImageInfos );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FramebufferAttachmentsCreateInfo const & ) const = default;
 #else
     bool operator==( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( attachmentImageInfoCount == rhs.attachmentImageInfoCount ) &&
+             ( pAttachmentImageInfos == rhs.pAttachmentImageInfos );
+#  endif
     }
 
     bool operator!=( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -30454,9 +32186,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFramebufferCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::FramebufferCreateFlags const &,
@@ -30466,23 +32199,31 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, renderPass, attachmentCount, pAttachments, width, height, layers );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FramebufferCreateInfo const & ) const = default;
 #else
     bool operator==( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( renderPass == rhs.renderPass ) && ( attachmentCount == rhs.attachmentCount ) &&
+             ( pAttachments == rhs.pAttachments ) && ( width == rhs.width ) && ( height == rhs.height ) &&
+             ( layers == rhs.layers );
+#  endif
     }
 
     bool operator!=( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -30559,32 +32300,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkFramebufferMixedSamplesCombinationNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::CoverageReductionModeNV const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, coverageReductionMode, rasterizationSamples, depthStencilSamples, colorSamples );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( FramebufferMixedSamplesCombinationNV const & ) const = default;
 #else
     bool operator==( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( coverageReductionMode == rhs.coverageReductionMode ) &&
+             ( rasterizationSamples == rhs.rasterizationSamples ) &&
+             ( depthStencilSamples == rhs.depthStencilSamples ) && ( colorSamples == rhs.colorSamples );
+#  endif
     }
 
     bool operator!=( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -30664,27 +32414,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkIndirectCommandsStreamNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Buffer const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( buffer, offset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( IndirectCommandsStreamNV const & ) const = default;
 #else
     bool operator==( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( buffer == rhs.buffer ) && ( offset == rhs.offset );
+#  endif
     }
 
     bool operator!=( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -30901,9 +32657,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeneratedCommandsInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
@@ -30919,7 +32676,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::Buffer const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -30938,18 +32695,31 @@ namespace VULKAN_HPP_NAMESPACE
                        sequencesIndexBuffer,
                        sequencesIndexOffset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeneratedCommandsInfoNV const & ) const = default;
 #else
     bool operator==( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
+             ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) &&
+             ( streamCount == rhs.streamCount ) && ( pStreams == rhs.pStreams ) &&
+             ( sequencesCount == rhs.sequencesCount ) && ( preprocessBuffer == rhs.preprocessBuffer ) &&
+             ( preprocessOffset == rhs.preprocessOffset ) && ( preprocessSize == rhs.preprocessSize ) &&
+             ( sequencesCountBuffer == rhs.sequencesCountBuffer ) &&
+             ( sequencesCountOffset == rhs.sequencesCountOffset ) &&
+             ( sequencesIndexBuffer == rhs.sequencesIndexBuffer ) &&
+             ( sequencesIndexOffset == rhs.sequencesIndexOffset );
+#  endif
     }
 
     bool operator!=( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -31071,32 +32841,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGeneratedCommandsMemoryRequirementsInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
                VULKAN_HPP_NAMESPACE::Pipeline const &,
                VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pipelineBindPoint, pipeline, indirectCommandsLayout, maxSequencesCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const & ) const = default;
 #else
     bool operator==( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
+             ( pipeline == rhs.pipeline ) && ( indirectCommandsLayout == rhs.indirectCommandsLayout ) &&
+             ( maxSequencesCount == rhs.maxSequencesCount );
+#  endif
     }
 
     bool operator!=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -31187,27 +32965,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVertexInputBindingDescription *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::VertexInputRate const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( binding, stride, inputRate );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputBindingDescription const & ) const = default;
 #else
     bool operator==( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate );
+#  endif
     }
 
     bool operator!=( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -31295,27 +33079,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVertexInputAttributeDescription *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::Format const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( location, binding, format, offset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputAttributeDescription const & ) const = default;
 #else
     bool operator==( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) &&
+             ( offset == rhs.offset );
+#  endif
     }
 
     bool operator!=( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -31465,9 +33256,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineVertexInputStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateFlags const &,
@@ -31475,7 +33267,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::VertexInputBindingDescription * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -31486,18 +33278,27 @@ namespace VULKAN_HPP_NAMESPACE
                        vertexAttributeDescriptionCount,
                        pVertexAttributeDescriptions );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineVertexInputStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) &&
+             ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) &&
+             ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) &&
+             ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions );
+#  endif
     }
 
     bool operator!=( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -31600,31 +33401,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineInputAssemblyStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags const &,
                VULKAN_HPP_NAMESPACE::PrimitiveTopology const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, topology, primitiveRestartEnable );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineInputAssemblyStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( topology == rhs.topology ) && ( primitiveRestartEnable == rhs.primitiveRestartEnable );
+#  endif
     }
 
     bool operator!=( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -31716,30 +33524,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineTessellationStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateFlags const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, patchControlPoints );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineTessellationStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( patchControlPoints == rhs.patchControlPoints );
+#  endif
     }
 
     bool operator!=( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -31890,9 +33705,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateFlags const &,
@@ -31900,23 +33716,30 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::Viewport * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Rect2D * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, viewportCount, pViewports, scissorCount, pScissors );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( viewportCount == rhs.viewportCount ) && ( pViewports == rhs.pViewports ) &&
+             ( scissorCount == rhs.scissorCount ) && ( pScissors == rhs.pScissors );
+#  endif
     }
 
     bool operator!=( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -32090,9 +33913,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateFlags const &,
@@ -32106,7 +33930,7 @@ namespace VULKAN_HPP_NAMESPACE
                float const &,
                float const &,
                float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -32123,18 +33947,29 @@ namespace VULKAN_HPP_NAMESPACE
                        depthBiasSlopeFactor,
                        lineWidth );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( depthClampEnable == rhs.depthClampEnable ) &&
+             ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable ) && ( polygonMode == rhs.polygonMode ) &&
+             ( cullMode == rhs.cullMode ) && ( frontFace == rhs.frontFace ) &&
+             ( depthBiasEnable == rhs.depthBiasEnable ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) &&
+             ( depthBiasClamp == rhs.depthBiasClamp ) && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ) &&
+             ( lineWidth == rhs.lineWidth );
+#  endif
     }
 
     bool operator!=( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -32279,9 +34114,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineMultisampleStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateFlags const &,
@@ -32291,7 +34127,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::SampleMask * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -32304,18 +34140,27 @@ namespace VULKAN_HPP_NAMESPACE
                        alphaToCoverageEnable,
                        alphaToOneEnable );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineMultisampleStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( rasterizationSamples == rhs.rasterizationSamples ) &&
+             ( sampleShadingEnable == rhs.sampleShadingEnable ) && ( minSampleShading == rhs.minSampleShading ) &&
+             ( pSampleMask == rhs.pSampleMask ) && ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) &&
+             ( alphaToOneEnable == rhs.alphaToOneEnable );
+#  endif
     }
 
     bool operator!=( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -32438,9 +34283,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkStencilOpState *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StencilOp const &,
                VULKAN_HPP_NAMESPACE::StencilOp const &,
                VULKAN_HPP_NAMESPACE::StencilOp const &,
@@ -32448,23 +34294,30 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( failOp, passOp, depthFailOp, compareOp, compareMask, writeMask, reference );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( StencilOpState const & ) const = default;
 #else
     bool operator==( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( failOp == rhs.failOp ) && ( passOp == rhs.passOp ) && ( depthFailOp == rhs.depthFailOp ) &&
+             ( compareOp == rhs.compareOp ) && ( compareMask == rhs.compareMask ) && ( writeMask == rhs.writeMask ) &&
+             ( reference == rhs.reference );
+#  endif
     }
 
     bool operator!=( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -32622,9 +34475,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineDepthStencilStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags const &,
@@ -32637,7 +34491,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::StencilOpState const &,
                float const &,
                float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -32653,18 +34507,27 @@ namespace VULKAN_HPP_NAMESPACE
                        minDepthBounds,
                        maxDepthBounds );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineDepthStencilStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( depthTestEnable == rhs.depthTestEnable ) && ( depthWriteEnable == rhs.depthWriteEnable ) &&
+             ( depthCompareOp == rhs.depthCompareOp ) && ( depthBoundsTestEnable == rhs.depthBoundsTestEnable ) &&
+             ( stencilTestEnable == rhs.stencilTestEnable ) && ( front == rhs.front ) && ( back == rhs.back ) &&
+             ( minDepthBounds == rhs.minDepthBounds ) && ( maxDepthBounds == rhs.maxDepthBounds );
+#  endif
     }
 
     bool operator!=( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -32806,9 +34669,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineColorBlendAttachmentState *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::BlendFactor const &,
                VULKAN_HPP_NAMESPACE::BlendFactor const &,
@@ -32817,7 +34681,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::BlendFactor const &,
                VULKAN_HPP_NAMESPACE::BlendOp const &,
                VULKAN_HPP_NAMESPACE::ColorComponentFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( blendEnable,
@@ -32829,18 +34693,26 @@ namespace VULKAN_HPP_NAMESPACE
                        alphaBlendOp,
                        colorWriteMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineColorBlendAttachmentState const & ) const = default;
 #else
     bool operator==( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( blendEnable == rhs.blendEnable ) && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) &&
+             ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && ( colorBlendOp == rhs.colorBlendOp ) &&
+             ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) &&
+             ( alphaBlendOp == rhs.alphaBlendOp ) && ( colorWriteMask == rhs.colorWriteMask );
+#  endif
     }
 
     bool operator!=( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -32992,9 +34864,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineColorBlendStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags const &,
@@ -33003,23 +34876,31 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 4> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, logicOpEnable, logicOp, attachmentCount, pAttachments, blendConstants );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineColorBlendStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( logicOpEnable == rhs.logicOpEnable ) && ( logicOp == rhs.logicOp ) &&
+             ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) &&
+             ( blendConstants == rhs.blendConstants );
+#  endif
     }
 
     bool operator!=( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -33142,31 +35023,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineDynamicStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::DynamicState * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, dynamicStateCount, pDynamicStates );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineDynamicStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( dynamicStateCount == rhs.dynamicStateCount ) && ( pDynamicStates == rhs.pDynamicStates );
+#  endif
     }
 
     bool operator!=( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -33438,9 +35326,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGraphicsPipelineCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
@@ -33460,7 +35349,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::Pipeline const &,
                int32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -33483,18 +35372,31 @@ namespace VULKAN_HPP_NAMESPACE
                        basePipelineHandle,
                        basePipelineIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GraphicsPipelineCreateInfo const & ) const = default;
 #else
     bool operator==( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) &&
+             ( pVertexInputState == rhs.pVertexInputState ) && ( pInputAssemblyState == rhs.pInputAssemblyState ) &&
+             ( pTessellationState == rhs.pTessellationState ) && ( pViewportState == rhs.pViewportState ) &&
+             ( pRasterizationState == rhs.pRasterizationState ) && ( pMultisampleState == rhs.pMultisampleState ) &&
+             ( pDepthStencilState == rhs.pDepthStencilState ) && ( pColorBlendState == rhs.pColorBlendState ) &&
+             ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) && ( renderPass == rhs.renderPass ) &&
+             ( subpass == rhs.subpass ) && ( basePipelineHandle == rhs.basePipelineHandle ) &&
+             ( basePipelineIndex == rhs.basePipelineIndex );
+#  endif
     }
 
     bool operator!=( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -33638,32 +35540,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGraphicsShaderGroupCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo * const &,
                const VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo * const &,
                const VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stageCount, pStages, pVertexInputState, pTessellationState );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GraphicsShaderGroupCreateInfoNV const & ) const = default;
 #else
     bool operator==( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageCount == rhs.stageCount ) &&
+             ( pStages == rhs.pStages ) && ( pVertexInputState == rhs.pVertexInputState ) &&
+             ( pTessellationState == rhs.pTessellationState );
+#  endif
     }
 
     bool operator!=( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -33811,32 +35721,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkGraphicsPipelineShaderGroupsCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Pipeline * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, groupCount, pGroups, pipelineCount, pPipelines );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const & ) const = default;
 #else
     bool operator==( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( groupCount == rhs.groupCount ) &&
+             ( pGroups == rhs.pGroups ) && ( pipelineCount == rhs.pipelineCount ) && ( pPipelines == rhs.pPipelines );
+#  endif
     }
 
     bool operator!=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -33913,27 +35830,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkXYColorEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<float const &, float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( x, y );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( XYColorEXT const & ) const = default;
 #else
     bool operator==( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( x == rhs.x ) && ( y == rhs.y );
+#  endif
     }
 
     bool operator!=( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -34060,9 +35983,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkHdrMetadataEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::XYColorEXT const &,
@@ -34073,7 +35997,7 @@ namespace VULKAN_HPP_NAMESPACE
                float const &,
                float const &,
                float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -34087,18 +36011,27 @@ namespace VULKAN_HPP_NAMESPACE
                        maxContentLightLevel,
                        maxFrameAverageLightLevel );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( HdrMetadataEXT const & ) const = default;
 #else
     bool operator==( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPrimaryRed == rhs.displayPrimaryRed ) &&
+             ( displayPrimaryGreen == rhs.displayPrimaryGreen ) && ( displayPrimaryBlue == rhs.displayPrimaryBlue ) &&
+             ( whitePoint == rhs.whitePoint ) && ( maxLuminance == rhs.maxLuminance ) &&
+             ( minLuminance == rhs.minLuminance ) && ( maxContentLightLevel == rhs.maxContentLightLevel ) &&
+             ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel );
+#  endif
     }
 
     bool operator!=( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -34180,29 +36113,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateFlagsEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( HeadlessSurfaceCreateInfoEXT const & ) const = default;
 #else
     bool operator==( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -34287,30 +36226,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkIOSSurfaceCreateInfoMVK *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::IOSSurfaceCreateFlagsMVK const &,
                const void * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pView );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( IOSSurfaceCreateInfoMVK const & ) const = default;
 #  else
     bool operator==( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView );
+#    endif
     }
 
     bool operator!=( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -34405,30 +36350,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageBlit *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::Offset3D, 2> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( srcSubresource, srcOffsets, dstSubresource, dstOffsets );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageBlit const & ) const = default;
 #else
     bool operator==( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) &&
+             ( dstSubresource == rhs.dstSubresource ) && ( dstOffsets == rhs.dstOffsets );
+#  endif
     }
 
     bool operator!=( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -34547,9 +36499,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageFormatConstraintsInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageCreateInfo const &,
@@ -34558,7 +36511,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint64_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -34570,18 +36523,26 @@ namespace VULKAN_HPP_NAMESPACE
                        colorSpaceCount,
                        pColorSpaces );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageFormatConstraintsInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCreateInfo == rhs.imageCreateInfo ) &&
+             ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && ( flags == rhs.flags ) &&
+             ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( colorSpaceCount == rhs.colorSpaceCount ) &&
+             ( pColorSpaces == rhs.pColorSpaces );
+#    endif
     }
 
     bool operator!=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -34718,32 +36679,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageConstraintsInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA * const &,
                VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &,
                VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFlagsFUCHSIA const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, formatConstraintsCount, pFormatConstraints, bufferCollectionConstraints, flags );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageConstraintsInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( formatConstraintsCount == rhs.formatConstraintsCount ) &&
+             ( pFormatConstraints == rhs.pFormatConstraints ) &&
+             ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ) && ( flags == rhs.flags );
+#    endif
     }
 
     bool operator!=( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -34848,31 +36818,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageCopy *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::Offset3D const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::Offset3D const &,
                VULKAN_HPP_NAMESPACE::Extent3D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageCopy const & ) const = default;
 #else
     bool operator==( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) &&
+             ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+#  endif
     }
 
     bool operator!=( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -34932,31 +36909,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubresourceLayout *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( offset, size, rowPitch, arrayPitch, depthPitch );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubresourceLayout const & ) const = default;
 #else
     bool operator==( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( offset == rhs.offset ) && ( size == rhs.size ) && ( rowPitch == rhs.rowPitch ) &&
+             ( arrayPitch == rhs.arrayPitch ) && ( depthPitch == rhs.depthPitch );
+#  endif
     }
 
     bool operator!=( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -35074,31 +37058,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageDrmFormatModifierExplicitCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint64_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SubresourceLayout * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, drmFormatModifier, drmFormatModifierPlaneCount, pPlaneLayouts );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) &&
+             ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) &&
+             ( pPlaneLayouts == rhs.pPlaneLayouts );
+#  endif
     }
 
     bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -35211,30 +37203,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageDrmFormatModifierListCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const uint64_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifiers );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( drmFormatModifierCount == rhs.drmFormatModifierCount ) &&
+             ( pDrmFormatModifiers == rhs.pDrmFormatModifiers );
+#  endif
     }
 
     bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -35301,27 +37301,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageDrmFormatModifierPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, drmFormatModifier );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageDrmFormatModifierPropertiesEXT const & ) const = default;
 #else
     bool operator==( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier );
+#  endif
     }
 
     bool operator!=( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -35426,30 +37432,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageFormatListCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Format * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, viewFormatCount, pViewFormats );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageFormatListCreateInfo const & ) const = default;
 #else
     bool operator==( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewFormatCount == rhs.viewFormatCount ) &&
+             ( pViewFormats == rhs.pViewFormats );
+#  endif
     }
 
     bool operator!=( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -35512,29 +37525,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageFormatProperties2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ImageFormatProperties const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, imageFormatProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageFormatProperties2 const & ) const = default;
 #else
     bool operator==( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFormatProperties == rhs.imageFormatProperties );
+#  endif
     }
 
     bool operator!=( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -35673,9 +37692,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageMemoryBarrier *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccessFlags const &,
@@ -35686,7 +37706,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::Image const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -35700,18 +37720,27 @@ namespace VULKAN_HPP_NAMESPACE
                        image,
                        subresourceRange );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageMemoryBarrier const & ) const = default;
 #else
     bool operator==( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) &&
+             ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) &&
+             ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) &&
+             ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) &&
+             ( subresourceRange == rhs.subresourceRange );
+#  endif
     }
 
     bool operator!=( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -35793,27 +37822,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageMemoryRequirementsInfo2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Image const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, image );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageMemoryRequirementsInfo2 const & ) const = default;
 #else
     bool operator==( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image );
+#  endif
     }
 
     bool operator!=( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -35904,30 +37939,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImagePipeSurfaceCreateInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateFlagsFUCHSIA const &,
                zx_handle_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, imagePipeHandle );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ) == 0 );
+#    endif
     }
 
     bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -36009,29 +38051,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImagePlaneMemoryRequirementsInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageAspectFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, planeAspect );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImagePlaneMemoryRequirementsInfo const & ) const = default;
 #else
     bool operator==( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect );
+#  endif
     }
 
     bool operator!=( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -36135,31 +38183,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageResolve *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::Offset3D const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::Offset3D const &,
                VULKAN_HPP_NAMESPACE::Extent3D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageResolve const & ) const = default;
 #else
     bool operator==( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) &&
+             ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+#  endif
     }
 
     bool operator!=( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -36265,9 +38320,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageResolve2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
@@ -36275,23 +38331,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &,
                VULKAN_HPP_NAMESPACE::Offset3D const &,
                VULKAN_HPP_NAMESPACE::Extent3D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageResolve2KHR const & ) const = default;
 #else
     bool operator==( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) &&
+             ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) &&
+             ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent );
+#  endif
     }
 
     bool operator!=( ImageResolve2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -36374,27 +38437,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSparseMemoryRequirementsInfo2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Image const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, image );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSparseMemoryRequirementsInfo2 const & ) const = default;
 #else
     bool operator==( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image );
+#  endif
     }
 
     bool operator!=( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -36473,29 +38542,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageStencilUsageCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stencilUsage );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageStencilUsageCreateInfo const & ) const = default;
 #else
     bool operator==( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilUsage == rhs.stencilUsage );
+#  endif
     }
 
     bool operator!=( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -36574,29 +38649,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageSwapchainCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SwapchainKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, swapchain );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageSwapchainCreateInfoKHR const & ) const = default;
 #else
     bool operator==( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain );
+#  endif
     }
 
     bool operator!=( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -36674,27 +38755,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewASTCDecodeModeEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Format const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, decodeMode );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewASTCDecodeModeEXT const & ) const = default;
 #else
     bool operator==( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeMode == rhs.decodeMode );
+#  endif
     }
 
     bool operator!=( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -36759,30 +38846,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewAddressPropertiesNVX *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DeviceAddress const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceAddress, size );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewAddressPropertiesNVX const & ) const = default;
 #else
     bool operator==( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) &&
+             ( size == rhs.size );
+#  endif
     }
 
     bool operator!=( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -36903,9 +38997,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageViewCreateFlags const &,
@@ -36914,23 +39009,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Format const &,
                VULKAN_HPP_NAMESPACE::ComponentMapping const &,
                VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, image, viewType, format, components, subresourceRange );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewCreateInfo const & ) const = default;
 #else
     bool operator==( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( image == rhs.image ) &&
+             ( viewType == rhs.viewType ) && ( format == rhs.format ) && ( components == rhs.components ) &&
+             ( subresourceRange == rhs.subresourceRange );
+#  endif
     }
 
     bool operator!=( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -37028,31 +39130,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewHandleInfoNVX *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageView const &,
                VULKAN_HPP_NAMESPACE::DescriptorType const &,
                VULKAN_HPP_NAMESPACE::Sampler const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, imageView, descriptorType, sampler );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewHandleInfoNVX const & ) const = default;
 #else
     bool operator==( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) &&
+             ( descriptorType == rhs.descriptorType ) && ( sampler == rhs.sampler );
+#  endif
     }
 
     bool operator!=( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -37127,27 +39236,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewMinLodCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, minLod );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewMinLodCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod );
+#  endif
     }
 
     bool operator!=( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -37224,29 +39339,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImageViewUsageCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, usage );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImageViewUsageCreateInfo const & ) const = default;
 #else
     bool operator==( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage );
+#  endif
     }
 
     bool operator!=( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -37329,27 +39450,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportAndroidHardwareBufferInfoANDROID *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, struct AHardwareBuffer * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, buffer );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const & ) const = default;
 #  else
     bool operator==( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer );
+#    endif
     }
 
     bool operator!=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -37453,32 +39580,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportFenceFdInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Fence const &,
                VULKAN_HPP_NAMESPACE::FenceImportFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &,
                int const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fence, flags, handleType, fd );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportFenceFdInfoKHR const & ) const = default;
 #else
     bool operator==( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) &&
+             ( handleType == rhs.handleType ) && ( fd == rhs.fd );
+#  endif
     }
 
     bool operator!=( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -37595,9 +39729,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportFenceWin32HandleInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Fence const &,
@@ -37605,23 +39740,29 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &,
                HANDLE const &,
                LPCWSTR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fence, flags, handleType, handle, name );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportFenceWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) &&
+             ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && ( name == rhs.name );
+#    endif
     }
 
     bool operator!=( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -37717,30 +39858,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryBufferCollectionFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &,
                uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, collection, index );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryBufferCollectionFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) &&
+             ( index == rhs.index );
+#    endif
     }
 
     bool operator!=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -37827,30 +39975,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryFdInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
                int const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleType, fd );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryFdInfoKHR const & ) const = default;
 #else
     bool operator==( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd );
+#  endif
     }
 
     bool operator!=( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -37938,30 +40092,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryHostPointerInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
                void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleType, pHostPointer );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryHostPointerInfoEXT const & ) const = default;
 #else
     bool operator==( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
+             ( pHostPointer == rhs.pHostPointer );
+#  endif
     }
 
     bool operator!=( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -38060,31 +40221,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryWin32HandleInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
                HANDLE const &,
                LPCWSTR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleType, handle, name );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
+             ( handle == rhs.handle ) && ( name == rhs.name );
+#    endif
     }
 
     bool operator!=( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -38176,30 +40344,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryWin32HandleInfoNV *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsNV const &,
                HANDLE const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleType, handle );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryWin32HandleInfoNV const & ) const = default;
 #  else
     bool operator==( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
+             ( handle == rhs.handle );
+#    endif
     }
 
     bool operator!=( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -38292,30 +40467,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportMemoryZirconHandleInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &,
                zx_handle_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleType, handle );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportMemoryZirconHandleInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) &&
+             ( memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ) == 0 );
+#    endif
     }
 
     bool operator!=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -38422,32 +40604,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportSemaphoreFdInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Semaphore const &,
                VULKAN_HPP_NAMESPACE::SemaphoreImportFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &,
                int const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, semaphore, flags, handleType, fd );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportSemaphoreFdInfoKHR const & ) const = default;
 #else
     bool operator==( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
+             ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd );
+#  endif
     }
 
     bool operator!=( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -38566,9 +40755,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportSemaphoreWin32HandleInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Semaphore const &,
@@ -38576,23 +40766,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &,
                HANDLE const &,
                LPCWSTR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, semaphore, flags, handleType, handle, name );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
+             ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ) &&
+             ( name == rhs.name );
+#    endif
     }
 
     bool operator!=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -38709,32 +40906,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkImportSemaphoreZirconHandleInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Semaphore const &,
                VULKAN_HPP_NAMESPACE::SemaphoreImportFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &,
                zx_handle_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, semaphore, flags, handleType, zirconHandle );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ImportSemaphoreZirconHandleInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
+             ( flags == rhs.flags ) && ( handleType == rhs.handleType ) &&
+             ( memcmp( &zirconHandle, &rhs.zirconHandle, sizeof( zx_handle_t ) ) == 0 );
+#    endif
     }
 
     bool operator!=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -38988,9 +41193,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkIndirectCommandsLayoutTokenNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeNV const &,
@@ -39006,7 +41212,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::IndexType * const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -39025,18 +41231,30 @@ namespace VULKAN_HPP_NAMESPACE
                        pIndexTypes,
                        pIndexTypeValues );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( IndirectCommandsLayoutTokenNV const & ) const = default;
 #else
     bool operator==( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tokenType == rhs.tokenType ) &&
+             ( stream == rhs.stream ) && ( offset == rhs.offset ) && ( vertexBindingUnit == rhs.vertexBindingUnit ) &&
+             ( vertexDynamicStride == rhs.vertexDynamicStride ) &&
+             ( pushconstantPipelineLayout == rhs.pushconstantPipelineLayout ) &&
+             ( pushconstantShaderStageFlags == rhs.pushconstantShaderStageFlags ) &&
+             ( pushconstantOffset == rhs.pushconstantOffset ) && ( pushconstantSize == rhs.pushconstantSize ) &&
+             ( indirectStateFlags == rhs.indirectStateFlags ) && ( indexTypeCount == rhs.indexTypeCount ) &&
+             ( pIndexTypes == rhs.pIndexTypes ) && ( pIndexTypeValues == rhs.pIndexTypeValues );
+#  endif
     }
 
     bool operator!=( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -39212,9 +41430,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkIndirectCommandsLayoutCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsNV const &,
@@ -39223,23 +41442,31 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV * const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pipelineBindPoint, tokenCount, pTokens, streamCount, pStreamStrides );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( IndirectCommandsLayoutCreateInfoNV const & ) const = default;
 #else
     bool operator==( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( tokenCount == rhs.tokenCount ) &&
+             ( pTokens == rhs.pTokens ) && ( streamCount == rhs.streamCount ) &&
+             ( pStreamStrides == rhs.pStreamStrides );
+#  endif
     }
 
     bool operator!=( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -39322,27 +41549,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkInitializePerformanceApiInfoINTEL *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pUserData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( InitializePerformanceApiInfoINTEL const & ) const = default;
 #else
     bool operator==( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pUserData == rhs.pUserData );
+#  endif
     }
 
     bool operator!=( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -39429,27 +41662,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkInputAttachmentAspectReference *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, VULKAN_HPP_NAMESPACE::ImageAspectFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( subpass, inputAttachmentIndex, aspectMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( InputAttachmentAspectReference const & ) const = default;
 #else
     bool operator==( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( subpass == rhs.subpass ) && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) &&
+             ( aspectMask == rhs.aspectMask );
+#  endif
     }
 
     bool operator!=( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -39601,9 +41841,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkInstanceCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::InstanceCreateFlags const &,
@@ -39612,7 +41853,7 @@ namespace VULKAN_HPP_NAMESPACE
                const char * const * const &,
                uint32_t const &,
                const char * const * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -39624,18 +41865,27 @@ namespace VULKAN_HPP_NAMESPACE
                        enabledExtensionCount,
                        ppEnabledExtensionNames );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( InstanceCreateInfo const & ) const = default;
 #else
     bool operator==( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pApplicationInfo == rhs.pApplicationInfo ) && ( enabledLayerCount == rhs.enabledLayerCount ) &&
+             ( ppEnabledLayerNames == rhs.ppEnabledLayerNames ) &&
+             ( enabledExtensionCount == rhs.enabledExtensionCount ) &&
+             ( ppEnabledExtensionNames == rhs.ppEnabledExtensionNames );
+#  endif
     }
 
     bool operator!=( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -39703,30 +41953,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkLayerProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( layerName, specVersion, implementationVersion, description );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( LayerProperties const & ) const = default;
 #else
     bool operator==( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( layerName == rhs.layerName ) && ( specVersion == rhs.specVersion ) &&
+             ( implementationVersion == rhs.implementationVersion ) && ( description == rhs.description );
+#  endif
     }
 
     bool operator!=( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -39805,30 +42062,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMacOSSurfaceCreateInfoMVK *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateFlagsMVK const &,
                const void * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pView );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MacOSSurfaceCreateInfoMVK const & ) const = default;
 #  else
     bool operator==( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView );
+#    endif
     }
 
     bool operator!=( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -39922,31 +42185,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMappedMemoryRange *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memory, offset, size );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MappedMemoryRange const & ) const = default;
 #else
     bool operator==( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) &&
+             ( size == rhs.size );
+#  endif
     }
 
     bool operator!=( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -40030,30 +42300,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryAllocateFlagsInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::MemoryAllocateFlags const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, deviceMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryAllocateFlagsInfo const & ) const = default;
 #else
     bool operator==( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( deviceMask == rhs.deviceMask );
+#  endif
     }
 
     bool operator!=( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -40138,30 +42415,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryAllocateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, allocationSize, memoryTypeIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryAllocateInfo const & ) const = default;
 #else
     bool operator==( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) &&
+             ( memoryTypeIndex == rhs.memoryTypeIndex );
+#  endif
     }
 
     bool operator!=( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -40245,30 +42529,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryBarrier *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AccessFlags const &,
                VULKAN_HPP_NAMESPACE::AccessFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcAccessMask, dstAccessMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryBarrier const & ) const = default;
 #else
     bool operator==( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) &&
+             ( dstAccessMask == rhs.dstAccessMask );
+#  endif
     }
 
     bool operator!=( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -40353,30 +42644,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryDedicatedAllocateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Image const &,
                VULKAN_HPP_NAMESPACE::Buffer const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, image, buffer );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryDedicatedAllocateInfo const & ) const = default;
 #else
     bool operator==( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer );
+#  endif
     }
 
     bool operator!=( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -40443,30 +42740,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryDedicatedRequirements *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, prefersDedicatedAllocation, requiresDedicatedAllocation );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryDedicatedRequirements const & ) const = default;
 #else
     bool operator==( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) &&
+             ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation );
+#  endif
     }
 
     bool operator!=( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -40529,27 +42834,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryFdPropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryTypeBits );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryFdPropertiesKHR const & ) const = default;
 #else
     bool operator==( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+#  endif
     }
 
     bool operator!=( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -40632,29 +42943,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryGetAndroidHardwareBufferInfoANDROID *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memory );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const & ) const = default;
 #  else
     bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory );
+#    endif
     }
 
     bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -40743,30 +43060,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryGetFdInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memory, handleType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetFdInfoKHR const & ) const = default;
 #else
     bool operator==( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
+             ( handleType == rhs.handleType );
+#  endif
     }
 
     bool operator!=( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -40854,30 +43178,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryGetRemoteAddressInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memory, handleType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetRemoteAddressInfoNV const & ) const = default;
 #else
     bool operator==( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
+             ( handleType == rhs.handleType );
+#  endif
     }
 
     bool operator!=( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -40968,30 +43299,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryGetWin32HandleInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memory, handleType );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
+             ( handleType == rhs.handleType );
+#    endif
     }
 
     bool operator!=( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -41084,30 +43422,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryGetZirconHandleInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memory, handleType );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryGetZirconHandleInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) &&
+             ( handleType == rhs.handleType );
+#    endif
     }
 
     bool operator!=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -41170,27 +43515,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryHeap *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &, VULKAN_HPP_NAMESPACE::MemoryHeapFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( size, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryHeap const & ) const = default;
 #else
     bool operator==( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( size == rhs.size ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -41244,27 +43595,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryHostPointerPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryTypeBits );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryHostPointerPropertiesEXT const & ) const = default;
 #else
     bool operator==( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+#  endif
     }
 
     bool operator!=( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -41346,27 +43703,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryOpaqueCaptureAddressAllocateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, opaqueCaptureAddress );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const & ) const = default;
 #else
     bool operator==( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress );
+#  endif
     }
 
     bool operator!=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -41445,27 +43808,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryPriorityAllocateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, priority );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryPriorityAllocateInfoEXT const & ) const = default;
 #else
     bool operator==( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priority == rhs.priority );
+#  endif
     }
 
     bool operator!=( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -41527,27 +43896,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryRequirements *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DeviceSize const &, VULKAN_HPP_NAMESPACE::DeviceSize const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( size, alignment, memoryTypeBits );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryRequirements const & ) const = default;
 #else
     bool operator==( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( size == rhs.size ) && ( alignment == rhs.alignment ) && ( memoryTypeBits == rhs.memoryTypeBits );
+#  endif
     }
 
     bool operator!=( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -41601,29 +43976,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryRequirements2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::MemoryRequirements const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryRequirements );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryRequirements2 const & ) const = default;
 #else
     bool operator==( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements );
+#  endif
     }
 
     bool operator!=( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -41682,27 +44063,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryType *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::MemoryPropertyFlags const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( propertyFlags, heapIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryType const & ) const = default;
 #else
     bool operator==( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( propertyFlags == rhs.propertyFlags ) && ( heapIndex == rhs.heapIndex );
+#  endif
     }
 
     bool operator!=( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -41757,27 +44144,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryWin32HandlePropertiesKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryTypeBits );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryWin32HandlePropertiesKHR const & ) const = default;
 #  else
     bool operator==( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+#    endif
     }
 
     bool operator!=( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -41844,27 +44237,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMemoryZirconHandlePropertiesFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryTypeBits );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MemoryZirconHandlePropertiesFUCHSIA const & ) const = default;
 #  else
     bool operator==( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits );
+#    endif
     }
 
     bool operator!=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -41951,30 +44350,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMetalSurfaceCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::MetalSurfaceCreateFlagsEXT const &,
                const CAMetalLayer * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pLayer );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MetalSurfaceCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pLayer == rhs.pLayer );
+#    endif
     }
 
     bool operator!=( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -42057,27 +44462,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMultiDrawIndexedInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, int32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( firstIndex, indexCount, vertexOffset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MultiDrawIndexedInfoEXT const & ) const = default;
 #else
     bool operator==( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( firstIndex == rhs.firstIndex ) && ( indexCount == rhs.indexCount ) &&
+             ( vertexOffset == rhs.vertexOffset );
+#  endif
     }
 
     bool operator!=( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -42143,27 +44555,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMultiDrawInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( firstVertex, vertexCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MultiDrawInfoEXT const & ) const = default;
 #else
     bool operator==( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( firstVertex == rhs.firstVertex ) && ( vertexCount == rhs.vertexCount );
+#  endif
     }
 
     bool operator!=( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -42216,27 +44634,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMultisamplePropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Extent2D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxSampleLocationGridSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MultisamplePropertiesEXT const & ) const = default;
 #else
     bool operator==( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize );
+#  endif
     }
 
     bool operator!=( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -42324,30 +44749,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMultiviewPerViewAttributesInfoNVX *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, perViewAttributes, perViewAttributesPositionXOnly );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MultiviewPerViewAttributesInfoNVX const & ) const = default;
 #else
     bool operator==( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewAttributes == rhs.perViewAttributes ) &&
+             ( perViewAttributesPositionXOnly == rhs.perViewAttributesPositionXOnly );
+#  endif
     }
 
     bool operator!=( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -42447,27 +44879,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMutableDescriptorTypeListVALVE *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, const VULKAN_HPP_NAMESPACE::DescriptorType * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( descriptorTypeCount, pDescriptorTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MutableDescriptorTypeListVALVE const & ) const = default;
 #else
     bool operator==( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes );
+#  endif
     }
 
     bool operator!=( MutableDescriptorTypeListVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -42571,30 +45009,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, mutableDescriptorTypeListCount, pMutableDescriptorTypeLists );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( MutableDescriptorTypeCreateInfoVALVE const & ) const = default;
 #else
     bool operator==( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) &&
+             ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists );
+#  endif
     }
 
     bool operator!=( MutableDescriptorTypeCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -42662,27 +45108,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPastPresentationTimingGOOGLE *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint64_t const &, uint64_t const &, uint64_t const &, uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( presentID, desiredPresentTime, actualPresentTime, earliestPresentTime, presentMargin );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PastPresentationTimingGOOGLE const & ) const = default;
 #else
     bool operator==( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ) &&
+             ( actualPresentTime == rhs.actualPresentTime ) && ( earliestPresentTime == rhs.earliestPresentTime ) &&
+             ( presentMargin == rhs.presentMargin );
+#  endif
     }
 
     bool operator!=( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -42763,29 +45217,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceConfigurationAcquireInfoINTEL *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PerformanceConfigurationTypeINTEL const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, type );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const & ) const = default;
 #else
     bool operator==( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type );
+#  endif
     }
 
     bool operator!=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -42857,32 +45317,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceCounterDescriptionKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, name, category, description );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceCounterDescriptionKHR const & ) const = default;
 #else
     bool operator==( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( name == rhs.name ) &&
+             ( category == rhs.category ) && ( description == rhs.description );
+#  endif
     }
 
     bool operator!=( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -42955,32 +45422,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceCounterKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PerformanceCounterUnitKHR const &,
                VULKAN_HPP_NAMESPACE::PerformanceCounterScopeKHR const &,
                VULKAN_HPP_NAMESPACE::PerformanceCounterStorageKHR const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, unit, scope, storage, uuid );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceCounterKHR const & ) const = default;
 #else
     bool operator==( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unit == rhs.unit ) && ( scope == rhs.scope ) &&
+             ( storage == rhs.storage ) && ( uuid == rhs.uuid );
+#  endif
     }
 
     bool operator!=( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -43131,27 +45605,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceMarkerInfoINTEL *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, marker );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceMarkerInfoINTEL const & ) const = default;
 #else
     bool operator==( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker );
+#  endif
     }
 
     bool operator!=( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -43246,31 +45726,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceOverrideInfoINTEL *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PerformanceOverrideTypeINTEL const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, type, enable, parameter );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceOverrideInfoINTEL const & ) const = default;
 #else
     bool operator==( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( enable == rhs.enable ) &&
+             ( parameter == rhs.parameter );
+#  endif
     }
 
     bool operator!=( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -43351,27 +45838,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceQuerySubmitInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, counterPassIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceQuerySubmitInfoKHR const & ) const = default;
 #else
     bool operator==( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterPassIndex == rhs.counterPassIndex );
+#  endif
     }
 
     bool operator!=( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -43448,27 +45941,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceStreamMarkerInfoINTEL *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, marker );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PerformanceStreamMarkerInfoINTEL const & ) const = default;
 #else
     bool operator==( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker );
+#  endif
     }
 
     bool operator!=( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -43617,16 +46116,18 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPerformanceValueINTEL *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL const &,
                VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( type, data );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL type = VULKAN_HPP_NAMESPACE::PerformanceValueTypeINTEL::eUint32;
@@ -43723,16 +46224,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevice16BitStorageFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -43742,18 +46244,27 @@ namespace VULKAN_HPP_NAMESPACE
                        storagePushConstant16,
                        storageInputOutput16 );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevice16BitStorageFeatures const & ) const = default;
 #else
-    bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool         operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) &&
+             ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) &&
+             ( storagePushConstant16 == rhs.storagePushConstant16 ) &&
+             ( storageInputOutput16 == rhs.storageInputOutput16 );
+#  endif
     }
 
     bool operator!=( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -43847,30 +46358,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevice4444FormatsFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, formatA4R4G4B4, formatA4B4G4R4 );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevice4444FormatsFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatA4R4G4B4 == rhs.formatA4R4G4B4 ) &&
+             ( formatA4B4G4R4 == rhs.formatA4B4G4R4 );
+#  endif
     }
 
     bool operator!=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -43969,31 +46487,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevice8BitStorageFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, storageBuffer8BitAccess, uniformAndStorageBuffer8BitAccess, storagePushConstant8 );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevice8BitStorageFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) &&
+             ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) &&
+             ( storagePushConstant8 == rhs.storagePushConstant8 );
+#  endif
     }
 
     bool operator!=( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -44077,27 +46604,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceASTCDecodeFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, decodeModeSharedExponent );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( decodeModeSharedExponent == rhs.decodeModeSharedExponent );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -44218,9 +46752,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceAccelerationStructureFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -44228,7 +46763,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -44239,18 +46774,29 @@ namespace VULKAN_HPP_NAMESPACE
                        accelerationStructureHostCommands,
                        descriptorBindingAccelerationStructureUpdateAfterBind );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceAccelerationStructureFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( accelerationStructure == rhs.accelerationStructure ) &&
+             ( accelerationStructureCaptureReplay == rhs.accelerationStructureCaptureReplay ) &&
+             ( accelerationStructureIndirectBuild == rhs.accelerationStructureIndirectBuild ) &&
+             ( accelerationStructureHostCommands == rhs.accelerationStructureHostCommands ) &&
+             ( descriptorBindingAccelerationStructureUpdateAfterBind ==
+               rhs.descriptorBindingAccelerationStructureUpdateAfterBind );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -44338,9 +46884,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceAccelerationStructurePropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint64_t const &,
@@ -44351,7 +46898,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -44365,18 +46912,31 @@ namespace VULKAN_HPP_NAMESPACE
                        maxDescriptorSetUpdateAfterBindAccelerationStructures,
                        minAccelerationStructureScratchOffsetAlignment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceAccelerationStructurePropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGeometryCount == rhs.maxGeometryCount ) &&
+             ( maxInstanceCount == rhs.maxInstanceCount ) && ( maxPrimitiveCount == rhs.maxPrimitiveCount ) &&
+             ( maxPerStageDescriptorAccelerationStructures == rhs.maxPerStageDescriptorAccelerationStructures ) &&
+             ( maxPerStageDescriptorUpdateAfterBindAccelerationStructures ==
+               rhs.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ) &&
+             ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ) &&
+             ( maxDescriptorSetUpdateAfterBindAccelerationStructures ==
+               rhs.maxDescriptorSetUpdateAfterBindAccelerationStructures ) &&
+             ( minAccelerationStructureScratchOffsetAlignment == rhs.minAccelerationStructureScratchOffsetAlignment );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -44468,27 +47028,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, advancedBlendCoherentOperations );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -44568,9 +47135,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -44579,7 +47147,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -44591,18 +47159,29 @@ namespace VULKAN_HPP_NAMESPACE
                        advancedBlendCorrelatedOverlap,
                        advancedBlendAllOperations );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) &&
+             ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) &&
+             ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) &&
+             ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) &&
+             ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) &&
+             ( advancedBlendAllOperations == rhs.advancedBlendAllOperations );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -44700,30 +47279,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, borderColorSwizzle, borderColorSwizzleFromImage );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( borderColorSwizzle == rhs.borderColorSwizzle ) &&
+             ( borderColorSwizzleFromImage == rhs.borderColorSwizzleFromImage );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -44826,32 +47412,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
+             ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) &&
+             ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -44956,32 +47550,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
+             ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) &&
+             ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -45067,27 +47669,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceCoherentMemory );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceCoherentMemory == rhs.deviceCoherentMemory );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -45170,27 +47778,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceColorWriteEnableFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, colorWriteEnable );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceColorWriteEnableFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorWriteEnable == rhs.colorWriteEnable );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -45284,30 +47898,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, computeDerivativeGroupQuads, computeDerivativeGroupLinear );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) &&
+             ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -45402,30 +48024,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceConditionalRenderingFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, conditionalRendering, inheritedConditionalRendering );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRendering == rhs.conditionalRendering ) &&
+             ( inheritedConditionalRendering == rhs.inheritedConditionalRendering );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -45512,9 +48141,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                float const &,
@@ -45526,7 +48156,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -45541,18 +48171,32 @@ namespace VULKAN_HPP_NAMESPACE
                        fullyCoveredFragmentShaderInputVariable,
                        conservativeRasterizationPostDepthCoverage );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) &&
+             ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) &&
+             ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) &&
+             ( primitiveUnderestimation == rhs.primitiveUnderestimation ) &&
+             ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) &&
+             ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) &&
+             ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) &&
+             ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) &&
+             ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -45653,30 +48297,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) &&
+             ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -45746,28 +48397,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCooperativeMatrixPropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::
       tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ShaderStageFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, cooperativeMatrixSupportedStages );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -45851,27 +48509,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCornerSampledImageFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, cornerSampledImage );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cornerSampledImage == rhs.cornerSampledImage );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -45956,27 +48620,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCoverageReductionModeFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, coverageReductionMode );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -46069,30 +48739,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCustomBorderColorFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, customBorderColors, customBorderColorWithoutFormat );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCustomBorderColorFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customBorderColors == rhs.customBorderColors ) &&
+             ( customBorderColorWithoutFormat == rhs.customBorderColorWithoutFormat );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -46162,27 +48839,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceCustomBorderColorPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxCustomBorderColorSamplers );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceCustomBorderColorPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxCustomBorderColorSamplers == rhs.maxCustomBorderColorSamplers );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -46269,27 +48953,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, dedicatedAllocationImageAliasing );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -46374,27 +49065,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, depthClipControl );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDepthClipControlFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipControl == rhs.depthClipControl );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -46478,27 +49175,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, depthClipEnable );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipEnable == rhs.depthClipEnable );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -46573,16 +49276,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDepthStencilResolveProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
                VULKAN_HPP_NAMESPACE::ResolveModeFlags const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -46592,18 +49296,27 @@ namespace VULKAN_HPP_NAMESPACE
                        independentResolveNone,
                        independentResolve );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) &&
+             ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) &&
+             ( independentResolveNone == rhs.independentResolveNone ) &&
+             ( independentResolve == rhs.independentResolve );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -46866,9 +49579,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -46891,7 +49605,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -46917,18 +49631,47 @@ namespace VULKAN_HPP_NAMESPACE
                        descriptorBindingVariableDescriptorCount,
                        runtimeDescriptorArray );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) &&
+             ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) &&
+             ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) &&
+             ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) &&
+             ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) &&
+             ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) &&
+             ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) &&
+             ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) &&
+             ( shaderUniformTexelBufferArrayNonUniformIndexing ==
+               rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) &&
+             ( shaderStorageTexelBufferArrayNonUniformIndexing ==
+               rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) &&
+             ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) &&
+             ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) &&
+             ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) &&
+             ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) &&
+             ( descriptorBindingUniformTexelBufferUpdateAfterBind ==
+               rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) &&
+             ( descriptorBindingStorageTexelBufferUpdateAfterBind ==
+               rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) &&
+             ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) &&
+             ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) &&
+             ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) &&
+             ( runtimeDescriptorArray == rhs.runtimeDescriptorArray );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -47061,9 +49804,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDescriptorIndexingProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -47089,7 +49833,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -47118,18 +49862,58 @@ namespace VULKAN_HPP_NAMESPACE
                        maxDescriptorSetUpdateAfterBindStorageImages,
                        maxDescriptorSetUpdateAfterBindInputAttachments );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) &&
+             ( shaderUniformBufferArrayNonUniformIndexingNative ==
+               rhs.shaderUniformBufferArrayNonUniformIndexingNative ) &&
+             ( shaderSampledImageArrayNonUniformIndexingNative ==
+               rhs.shaderSampledImageArrayNonUniformIndexingNative ) &&
+             ( shaderStorageBufferArrayNonUniformIndexingNative ==
+               rhs.shaderStorageBufferArrayNonUniformIndexingNative ) &&
+             ( shaderStorageImageArrayNonUniformIndexingNative ==
+               rhs.shaderStorageImageArrayNonUniformIndexingNative ) &&
+             ( shaderInputAttachmentArrayNonUniformIndexingNative ==
+               rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) &&
+             ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) &&
+             ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) &&
+             ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) &&
+             ( maxPerStageDescriptorUpdateAfterBindUniformBuffers ==
+               rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) &&
+             ( maxPerStageDescriptorUpdateAfterBindStorageBuffers ==
+               rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) &&
+             ( maxPerStageDescriptorUpdateAfterBindSampledImages ==
+               rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) &&
+             ( maxPerStageDescriptorUpdateAfterBindStorageImages ==
+               rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) &&
+             ( maxPerStageDescriptorUpdateAfterBindInputAttachments ==
+               rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) &&
+             ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) &&
+             ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) &&
+             ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) &&
+             ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ==
+               rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) &&
+             ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) &&
+             ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ==
+               rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) &&
+             ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) &&
+             ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) &&
+             ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -47237,27 +50021,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceGeneratedCommands );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( deviceGeneratedCommands == rhs.deviceGeneratedCommands );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -47343,9 +50134,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -47357,7 +50149,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -47372,18 +50164,32 @@ namespace VULKAN_HPP_NAMESPACE
                        minSequencesIndexBufferOffsetAlignment,
                        minIndirectCommandsBufferOffsetAlignment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxGraphicsShaderGroupCount == rhs.maxGraphicsShaderGroupCount ) &&
+             ( maxIndirectSequenceCount == rhs.maxIndirectSequenceCount ) &&
+             ( maxIndirectCommandsTokenCount == rhs.maxIndirectCommandsTokenCount ) &&
+             ( maxIndirectCommandsStreamCount == rhs.maxIndirectCommandsStreamCount ) &&
+             ( maxIndirectCommandsTokenOffset == rhs.maxIndirectCommandsTokenOffset ) &&
+             ( maxIndirectCommandsStreamStride == rhs.maxIndirectCommandsStreamStride ) &&
+             ( minSequencesCountBufferOffsetAlignment == rhs.minSequencesCountBufferOffsetAlignment ) &&
+             ( minSequencesIndexBufferOffsetAlignment == rhs.minSequencesIndexBufferOffsetAlignment ) &&
+             ( minIndirectCommandsBufferOffsetAlignment == rhs.minIndirectCommandsBufferOffsetAlignment );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -47475,27 +50281,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceMemoryReport );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMemoryReport == rhs.deviceMemoryReport );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -47579,27 +50391,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDiagnosticsConfigFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, diagnosticsConfig );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( diagnosticsConfig == rhs.diagnosticsConfig );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -47668,27 +50486,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDiscardRectanglePropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxDiscardRectangles );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDiscardRectangles == rhs.maxDiscardRectangles );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -47759,32 +50583,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDriverProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DriverId const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_NAME_SIZE> const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DRIVER_INFO_SIZE> const &,
                VULKAN_HPP_NAMESPACE::ConformanceVersion const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, driverID, driverName, driverInfo, conformanceVersion );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDriverProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) &&
+             ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) &&
+             ( conformanceVersion == rhs.conformanceVersion );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -47861,9 +50693,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDrmPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -47872,23 +50705,31 @@ namespace VULKAN_HPP_NAMESPACE
                int64_t const &,
                int64_t const &,
                int64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, hasPrimary, hasRender, primaryMajor, primaryMinor, renderMajor, renderMinor );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDrmPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasPrimary == rhs.hasPrimary ) &&
+             ( hasRender == rhs.hasRender ) && ( primaryMajor == rhs.primaryMajor ) &&
+             ( primaryMinor == rhs.primaryMinor ) && ( renderMajor == rhs.renderMajor ) &&
+             ( renderMinor == rhs.renderMinor );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -47975,27 +50816,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, dynamicRendering );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceDynamicRenderingFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRendering == rhs.dynamicRendering );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceDynamicRenderingFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -48078,27 +50925,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExclusiveScissorFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, exclusiveScissor );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissor == rhs.exclusiveScissor );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -48201,32 +51054,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, extendedDynamicState2, extendedDynamicState2LogicOp, extendedDynamicState2PatchControlPoints );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( extendedDynamicState2 == rhs.extendedDynamicState2 ) &&
+             ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) &&
+             ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -48313,27 +51175,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, extendedDynamicState );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -48432,31 +51300,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalBufferInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::BufferCreateFlags const &,
                VULKAN_HPP_NAMESPACE::BufferUsageFlags const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, usage, handleType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalBufferInfo const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) &&
+             ( handleType == rhs.handleType );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -48540,29 +51415,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalFenceInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalFenceInfo const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -48647,29 +51528,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalImageFormatInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalImageFormatInfo const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -48739,27 +51626,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, minImportedHostPointerAlignment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -48843,27 +51737,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, externalMemoryRDMA );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryRDMA == rhs.externalMemoryRDMA );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -48946,29 +51846,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceExternalSemaphoreInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, handleType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const & ) const = default;
 #else
     bool operator==( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -49047,29 +51953,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFeatures2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, features );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFeatures2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( features == rhs.features );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -49170,9 +52082,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFloatControlsProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ShaderFloatControlsIndependence const &,
@@ -49192,7 +52105,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -49215,18 +52128,40 @@ namespace VULKAN_HPP_NAMESPACE
                        shaderRoundingModeRTZFloat32,
                        shaderRoundingModeRTZFloat64 );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFloatControlsProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) &&
+             ( roundingModeIndependence == rhs.roundingModeIndependence ) &&
+             ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) &&
+             ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) &&
+             ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) &&
+             ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) &&
+             ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) &&
+             ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) &&
+             ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) &&
+             ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) &&
+             ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) &&
+             ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) &&
+             ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) &&
+             ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) &&
+             ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) &&
+             ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) &&
+             ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -49328,27 +52263,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fragmentDensityMapDeferred );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -49423,16 +52365,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -49442,18 +52385,26 @@ namespace VULKAN_HPP_NAMESPACE
                        maxSubsampledArrayLayers,
                        maxDescriptorSetSubsampledSamplers );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) &&
+             ( subsampledCoarseReconstructionEarlyAccess == rhs.subsampledCoarseReconstructionEarlyAccess ) &&
+             ( maxSubsampledArrayLayers == rhs.maxSubsampledArrayLayers ) &&
+             ( maxDescriptorSetSubsampledSamplers == rhs.maxDescriptorSetSubsampledSamplers );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -49558,32 +52509,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, fragmentDensityMap, fragmentDensityMapDynamic, fragmentDensityMapNonSubsampledImages );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMap == rhs.fragmentDensityMap ) &&
+             ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) &&
+             ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -49671,27 +52630,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fragmentDensityMapOffset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fragmentDensityMapOffset == rhs.fragmentDensityMapOffset );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -49761,27 +52727,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Extent2D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fragmentDensityOffsetGranularity );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fragmentDensityOffsetGranularity == rhs.fragmentDensityOffsetGranularity );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -49854,32 +52827,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, minFragmentDensityTexelSize, maxFragmentDensityTexelSize, fragmentDensityInvocations );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) &&
+             ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) &&
+             ( fragmentDensityInvocations == rhs.fragmentDensityInvocations );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -49967,27 +52949,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fragmentShaderBarycentric );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -50090,32 +53079,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, fragmentShaderShadingRateInterlock );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fragmentShaderSampleInterlock == rhs.fragmentShaderSampleInterlock ) &&
+             ( fragmentShaderPixelInterlock == rhs.fragmentShaderPixelInterlock ) &&
+             ( fragmentShaderShadingRateInterlock == rhs.fragmentShaderShadingRateInterlock );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -50220,32 +53218,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, fragmentShadingRateEnums, supersampleFragmentShadingRates, noInvocationFragmentShadingRates );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fragmentShadingRateEnums == rhs.fragmentShadingRateEnums ) &&
+             ( supersampleFragmentShadingRates == rhs.supersampleFragmentShadingRates ) &&
+             ( noInvocationFragmentShadingRates == rhs.noInvocationFragmentShadingRates );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -50335,29 +53342,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxFragmentShadingRateInvocationCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxFragmentShadingRateInvocationCount == rhs.maxFragmentShadingRateInvocationCount );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -50460,32 +53474,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, pipelineFragmentShadingRate, primitiveFragmentShadingRate, attachmentFragmentShadingRate );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRateFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( pipelineFragmentShadingRate == rhs.pipelineFragmentShadingRate ) &&
+             ( primitiveFragmentShadingRate == rhs.primitiveFragmentShadingRate ) &&
+             ( attachmentFragmentShadingRate == rhs.attachmentFragmentShadingRate );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -50556,30 +53579,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRateKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, sampleCounts, fragmentSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRateKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleCounts == rhs.sampleCounts ) &&
+             ( fragmentSize == rhs.fragmentSize );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -50681,9 +53711,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceFragmentShadingRatePropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
@@ -50703,7 +53734,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -50726,18 +53757,44 @@ namespace VULKAN_HPP_NAMESPACE
                        fragmentShadingRateWithCustomSampleLocations,
                        fragmentShadingRateStrictMultiplyCombiner );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceFragmentShadingRatePropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( minFragmentShadingRateAttachmentTexelSize == rhs.minFragmentShadingRateAttachmentTexelSize ) &&
+             ( maxFragmentShadingRateAttachmentTexelSize == rhs.maxFragmentShadingRateAttachmentTexelSize ) &&
+             ( maxFragmentShadingRateAttachmentTexelSizeAspectRatio ==
+               rhs.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ) &&
+             ( primitiveFragmentShadingRateWithMultipleViewports ==
+               rhs.primitiveFragmentShadingRateWithMultipleViewports ) &&
+             ( layeredShadingRateAttachments == rhs.layeredShadingRateAttachments ) &&
+             ( fragmentShadingRateNonTrivialCombinerOps == rhs.fragmentShadingRateNonTrivialCombinerOps ) &&
+             ( maxFragmentSize == rhs.maxFragmentSize ) &&
+             ( maxFragmentSizeAspectRatio == rhs.maxFragmentSizeAspectRatio ) &&
+             ( maxFragmentShadingRateCoverageSamples == rhs.maxFragmentShadingRateCoverageSamples ) &&
+             ( maxFragmentShadingRateRasterizationSamples == rhs.maxFragmentShadingRateRasterizationSamples ) &&
+             ( fragmentShadingRateWithShaderDepthStencilWrites ==
+               rhs.fragmentShadingRateWithShaderDepthStencilWrites ) &&
+             ( fragmentShadingRateWithSampleMask == rhs.fragmentShadingRateWithSampleMask ) &&
+             ( fragmentShadingRateWithShaderSampleMask == rhs.fragmentShadingRateWithShaderSampleMask ) &&
+             ( fragmentShadingRateWithConservativeRasterization ==
+               rhs.fragmentShadingRateWithConservativeRasterization ) &&
+             ( fragmentShadingRateWithFragmentShaderInterlock == rhs.fragmentShadingRateWithFragmentShaderInterlock ) &&
+             ( fragmentShadingRateWithCustomSampleLocations == rhs.fragmentShadingRateWithCustomSampleLocations ) &&
+             ( fragmentShadingRateStrictMultiplyCombiner == rhs.fragmentShadingRateStrictMultiplyCombiner );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -50838,27 +53895,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, globalPriorityQuery );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceGlobalPriorityQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -50927,32 +53990,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceGroupProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<
       VULKAN_HPP_NAMESPACE::StructureType const &,
       void * const &,
       uint32_t const &,
       VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::PhysicalDevice, VK_MAX_DEVICE_GROUP_SIZE> const &,
       VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, physicalDeviceCount, physicalDevices, subsetAllocation );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceGroupProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) &&
+             ( physicalDevices == rhs.physicalDevices ) && ( subsetAllocation == rhs.subsetAllocation );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -51037,27 +54107,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, hostQueryReset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceHostQueryResetFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostQueryReset == rhs.hostQueryReset );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -51129,9 +54205,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceIDProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
@@ -51139,23 +54216,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_LUID_SIZE> const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, deviceUUID, driverUUID, deviceLUID, deviceNodeMask, deviceLUIDValid );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceIDProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) &&
+             ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) &&
+             ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -51292,32 +54376,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint64_t const &,
                VULKAN_HPP_NAMESPACE::SharingMode const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, drmFormatModifier, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) &&
+             ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
+             ( pQueueFamilyIndices == rhs.pQueueFamilyIndices );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -51436,9 +54528,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImageFormatInfo2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Format const &,
@@ -51446,23 +54539,29 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ImageTiling const &,
                VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
                VULKAN_HPP_NAMESPACE::ImageCreateFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, format, type, tiling, usage, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageFormatInfo2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) &&
+             ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -51550,27 +54649,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, robustImageAccess );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageRobustnessFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceImageRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -51655,27 +54760,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImageViewImageFormatInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ImageViewType const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, imageViewType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageViewType == rhs.imageViewType );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -51759,27 +54870,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, minLod );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImageViewMinLodFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -51863,27 +54980,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, imagelessFramebuffer );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -51967,27 +55090,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, indexTypeUint8 );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceIndexTypeUint8FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexTypeUint8 == rhs.indexTypeUint8 );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceIndexTypeUint8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -52072,27 +55201,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceInheritedViewportScissorFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, inheritedViewportScissor2D );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceInheritedViewportScissorFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( inheritedViewportScissor2D == rhs.inheritedViewportScissor2D );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -52186,30 +55322,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, inlineUniformBlock, descriptorBindingInlineUniformBlockUpdateAfterBind );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceInlineUniformBlockFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inlineUniformBlock == rhs.inlineUniformBlock ) &&
+             ( descriptorBindingInlineUniformBlockUpdateAfterBind ==
+               rhs.descriptorBindingInlineUniformBlockUpdateAfterBind );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceInlineUniformBlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -52288,9 +55432,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -52298,7 +55443,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -52309,18 +55454,30 @@ namespace VULKAN_HPP_NAMESPACE
                        maxDescriptorSetInlineUniformBlocks,
                        maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceInlineUniformBlockPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) &&
+             ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) &&
+             ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ==
+               rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) &&
+             ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) &&
+             ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks ==
+               rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceInlineUniformBlockPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -52407,27 +55564,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, invocationMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & ) const = default;
 #else
     bool operator==( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( invocationMask == rhs.invocationMask );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -52697,9 +55860,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceLimits *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &,
                uint32_t const &,
                uint32_t const &,
@@ -52806,7 +55970,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( maxImageDimension1D,
@@ -52916,18 +56080,121 @@ namespace VULKAN_HPP_NAMESPACE
                        optimalBufferCopyRowPitchAlignment,
                        nonCoherentAtomSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceLimits const & ) const = default;
 #else
     bool operator==( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( maxImageDimension1D == rhs.maxImageDimension1D ) && ( maxImageDimension2D == rhs.maxImageDimension2D ) &&
+             ( maxImageDimension3D == rhs.maxImageDimension3D ) &&
+             ( maxImageDimensionCube == rhs.maxImageDimensionCube ) &&
+             ( maxImageArrayLayers == rhs.maxImageArrayLayers ) &&
+             ( maxTexelBufferElements == rhs.maxTexelBufferElements ) &&
+             ( maxUniformBufferRange == rhs.maxUniformBufferRange ) &&
+             ( maxStorageBufferRange == rhs.maxStorageBufferRange ) &&
+             ( maxPushConstantsSize == rhs.maxPushConstantsSize ) &&
+             ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) &&
+             ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) &&
+             ( bufferImageGranularity == rhs.bufferImageGranularity ) &&
+             ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) &&
+             ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) &&
+             ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) &&
+             ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) &&
+             ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) &&
+             ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) &&
+             ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) &&
+             ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) &&
+             ( maxPerStageResources == rhs.maxPerStageResources ) &&
+             ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) &&
+             ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) &&
+             ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) &&
+             ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) &&
+             ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) &&
+             ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) &&
+             ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) &&
+             ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) &&
+             ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) &&
+             ( maxVertexInputBindings == rhs.maxVertexInputBindings ) &&
+             ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) &&
+             ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) &&
+             ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) &&
+             ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) &&
+             ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) &&
+             ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) &&
+             ( maxTessellationControlPerVertexOutputComponents ==
+               rhs.maxTessellationControlPerVertexOutputComponents ) &&
+             ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) &&
+             ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) &&
+             ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) &&
+             ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) &&
+             ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) &&
+             ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) &&
+             ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) &&
+             ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) &&
+             ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) &&
+             ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) &&
+             ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) &&
+             ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) &&
+             ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) &&
+             ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) &&
+             ( maxComputeWorkGroupCount == rhs.maxComputeWorkGroupCount ) &&
+             ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) &&
+             ( maxComputeWorkGroupSize == rhs.maxComputeWorkGroupSize ) &&
+             ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) &&
+             ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) &&
+             ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) &&
+             ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) &&
+             ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) &&
+             ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) && ( maxViewports == rhs.maxViewports ) &&
+             ( maxViewportDimensions == rhs.maxViewportDimensions ) &&
+             ( viewportBoundsRange == rhs.viewportBoundsRange ) &&
+             ( viewportSubPixelBits == rhs.viewportSubPixelBits ) &&
+             ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) &&
+             ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) &&
+             ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) &&
+             ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) &&
+             ( minTexelOffset == rhs.minTexelOffset ) && ( maxTexelOffset == rhs.maxTexelOffset ) &&
+             ( minTexelGatherOffset == rhs.minTexelGatherOffset ) &&
+             ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) &&
+             ( minInterpolationOffset == rhs.minInterpolationOffset ) &&
+             ( maxInterpolationOffset == rhs.maxInterpolationOffset ) &&
+             ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) &&
+             ( maxFramebufferWidth == rhs.maxFramebufferWidth ) &&
+             ( maxFramebufferHeight == rhs.maxFramebufferHeight ) &&
+             ( maxFramebufferLayers == rhs.maxFramebufferLayers ) &&
+             ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) &&
+             ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) &&
+             ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) &&
+             ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) &&
+             ( maxColorAttachments == rhs.maxColorAttachments ) &&
+             ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) &&
+             ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) &&
+             ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) &&
+             ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) &&
+             ( storageImageSampleCounts == rhs.storageImageSampleCounts ) &&
+             ( maxSampleMaskWords == rhs.maxSampleMaskWords ) &&
+             ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) &&
+             ( timestampPeriod == rhs.timestampPeriod ) && ( maxClipDistances == rhs.maxClipDistances ) &&
+             ( maxCullDistances == rhs.maxCullDistances ) &&
+             ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) &&
+             ( discreteQueuePriorities == rhs.discreteQueuePriorities ) && ( pointSizeRange == rhs.pointSizeRange ) &&
+             ( lineWidthRange == rhs.lineWidthRange ) && ( pointSizeGranularity == rhs.pointSizeGranularity ) &&
+             ( lineWidthGranularity == rhs.lineWidthGranularity ) && ( strictLines == rhs.strictLines ) &&
+             ( standardSampleLocations == rhs.standardSampleLocations ) &&
+             ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) &&
+             ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) &&
+             ( nonCoherentAtomSize == rhs.nonCoherentAtomSize );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -53150,9 +56417,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -53161,7 +56429,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -53173,18 +56441,27 @@ namespace VULKAN_HPP_NAMESPACE
                        stippledBresenhamLines,
                        stippledSmoothLines );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceLineRasterizationFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rectangularLines == rhs.rectangularLines ) &&
+             ( bresenhamLines == rhs.bresenhamLines ) && ( smoothLines == rhs.smoothLines ) &&
+             ( stippledRectangularLines == rhs.stippledRectangularLines ) &&
+             ( stippledBresenhamLines == rhs.stippledBresenhamLines ) &&
+             ( stippledSmoothLines == rhs.stippledSmoothLines );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceLineRasterizationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -53258,27 +56535,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, lineSubPixelPrecisionBits );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceLineRasterizationPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceLineRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -53363,27 +56647,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, linearColorAttachment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceLinearColorAttachmentFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearColorAttachment == rhs.linearColorAttachment );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -53452,30 +56742,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMaintenance3Properties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxPerSetDescriptors, maxMemoryAllocationSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMaintenance3Properties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) &&
+             ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -53559,27 +56856,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maintenance4 );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMaintenance4FeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance4 == rhs.maintenance4 );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMaintenance4FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -53645,27 +56948,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxBufferSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMaintenance4PropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBufferSize == rhs.maxBufferSize );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMaintenance4PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -53735,30 +57044,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::DeviceSize, VK_MAX_MEMORY_HEAPS> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, heapBudget, heapUsage );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapBudget == rhs.heapBudget ) &&
+             ( heapUsage == rhs.heapUsage );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -53842,27 +57158,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMemoryPriorityFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryPriority );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryPriority == rhs.memoryPriority );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -53930,30 +57252,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMemoryProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryType, VK_MAX_MEMORY_TYPES> const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::MemoryHeap, VK_MAX_MEMORY_HEAPS> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( memoryTypeCount, memoryTypes, memoryHeapCount, memoryHeaps );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMemoryProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( memoryTypeCount == rhs.memoryTypeCount ) && ( memoryTypes == rhs.memoryTypes ) &&
+             ( memoryHeapCount == rhs.memoryHeapCount ) && ( memoryHeaps == rhs.memoryHeaps );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54012,29 +57341,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMemoryProperties2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMemoryProperties2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryProperties == rhs.memoryProperties );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54125,30 +57460,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, taskShader, meshShader );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) &&
+             ( meshShader == rhs.meshShader );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54239,9 +57581,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -54257,7 +57600,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -54276,18 +57619,36 @@ namespace VULKAN_HPP_NAMESPACE
                        meshOutputPerVertexGranularity,
                        meshOutputPerPrimitiveGranularity );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount ) &&
+             ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) &&
+             ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) &&
+             ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize ) &&
+             ( maxTaskOutputCount == rhs.maxTaskOutputCount ) &&
+             ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) &&
+             ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) &&
+             ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize ) &&
+             ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) &&
+             ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) &&
+             ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) &&
+             ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) &&
+             ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54380,27 +57741,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMultiDrawFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, multiDraw );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiDrawFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiDraw == rhs.multiDraw );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54465,27 +57832,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMultiDrawPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxMultiDrawCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiDrawPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiDrawCount == rhs.maxMultiDrawCount );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54582,31 +57955,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMultiviewFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, multiview, multiviewGeometryShader, multiviewTessellationShader );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiviewFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiview == rhs.multiview ) &&
+             ( multiviewGeometryShader == rhs.multiviewGeometryShader ) &&
+             ( multiviewTessellationShader == rhs.multiviewTessellationShader );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54678,27 +58059,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, perViewPositionAllComponents );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( perViewPositionAllComponents == rhs.perViewPositionAllComponents );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54767,27 +58155,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMultiviewProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxMultiviewViewCount, maxMultiviewInstanceIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMultiviewProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) &&
+             ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54873,27 +58269,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, mutableDescriptorType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & ) const = default;
 #else
     bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -54966,32 +58368,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePCIBusInfoPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pciDomain, pciBus, pciDevice, pciFunction );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pciDomain == rhs.pciDomain ) &&
+             ( pciBus == rhs.pciBus ) && ( pciDevice == rhs.pciDevice ) && ( pciFunction == rhs.pciFunction );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -55079,27 +58488,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pageableDeviceLocalMemory );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( pageableDeviceLocalMemory == rhs.pageableDeviceLocalMemory );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -55192,30 +58608,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePerformanceQueryFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, performanceCounterQueryPools, performanceCounterMultipleQueryPools );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) &&
+             ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -55285,27 +58709,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePerformanceQueryPropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, allowCommandBufferQueryCopies );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -55391,27 +58822,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pipelineCreationCacheControl );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePipelineCreationCacheControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -55498,27 +58936,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pipelineExecutableInfo );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( pipelineExecutableInfo == rhs.pipelineExecutableInfo );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -55588,29 +59033,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePointClippingProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PointClippingBehavior const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pointClippingBehavior );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePointClippingProperties const & ) const = default;
 #else
     bool operator==( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pointClippingBehavior == rhs.pointClippingBehavior );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -55822,9 +59273,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -55842,7 +59294,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -55863,18 +59315,35 @@ namespace VULKAN_HPP_NAMESPACE
                        triangleFans,
                        vertexAttributeAccessBeyondStride );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePortabilitySubsetFeaturesKHR const & ) const = default;
 #  else
     bool operator==( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( constantAlphaColorBlendFactors == rhs.constantAlphaColorBlendFactors ) && ( events == rhs.events ) &&
+             ( imageViewFormatReinterpretation == rhs.imageViewFormatReinterpretation ) &&
+             ( imageViewFormatSwizzle == rhs.imageViewFormatSwizzle ) &&
+             ( imageView2DOn3DImage == rhs.imageView2DOn3DImage ) &&
+             ( multisampleArrayImage == rhs.multisampleArrayImage ) &&
+             ( mutableComparisonSamplers == rhs.mutableComparisonSamplers ) && ( pointPolygons == rhs.pointPolygons ) &&
+             ( samplerMipLodBias == rhs.samplerMipLodBias ) &&
+             ( separateStencilMaskRef == rhs.separateStencilMaskRef ) &&
+             ( shaderSampleRateInterpolationFunctions == rhs.shaderSampleRateInterpolationFunctions ) &&
+             ( tessellationIsolines == rhs.tessellationIsolines ) &&
+             ( tessellationPointMode == rhs.tessellationPointMode ) && ( triangleFans == rhs.triangleFans ) &&
+             ( vertexAttributeAccessBeyondStride == rhs.vertexAttributeAccessBeyondStride );
+#    endif
     }
 
     bool operator!=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -55974,27 +59443,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, minVertexInputBindingStrideAlignment );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePortabilitySubsetPropertiesKHR const & ) const = default;
 #  else
     bool operator==( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( minVertexInputBindingStrideAlignment == rhs.minVertexInputBindingStrideAlignment );
+#    endif
     }
 
     bool operator!=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -56077,27 +59553,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePresentIdFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, presentId );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePresentIdFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -56178,27 +59660,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePresentWaitFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, presentWait );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePresentWaitFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait == rhs.presentWait );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -56293,30 +59781,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, primitiveTopologyListRestart, primitiveTopologyPatchListRestart );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( primitiveTopologyListRestart == rhs.primitiveTopologyListRestart ) &&
+             ( primitiveTopologyPatchListRestart == rhs.primitiveTopologyPatchListRestart );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -56400,27 +59896,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, privateData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePrivateDataFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateData == rhs.privateData );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePrivateDataFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -56489,15 +59991,16 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSparseProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( residencyStandard2DBlockShape,
@@ -56506,18 +60009,27 @@ namespace VULKAN_HPP_NAMESPACE
                        residencyAlignedMipSize,
                        residencyNonResidentStrict );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSparseProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) &&
+             ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) &&
+             ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) &&
+             ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) &&
+             ( residencyNonResidentStrict == rhs.residencyNonResidentStrict );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -56589,9 +60101,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &,
                uint32_t const &,
                uint32_t const &,
@@ -56601,7 +60114,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
                VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const &,
                VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( apiVersion,
@@ -56614,18 +60127,26 @@ namespace VULKAN_HPP_NAMESPACE
                        limits,
                        sparseProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( apiVersion == rhs.apiVersion ) && ( driverVersion == rhs.driverVersion ) &&
+             ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && ( deviceType == rhs.deviceType ) &&
+             ( deviceName == rhs.deviceName ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) &&
+             ( limits == rhs.limits ) && ( sparseProperties == rhs.sparseProperties );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -56687,29 +60208,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProperties2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, properties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProperties2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -56791,27 +60318,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, protectedMemory );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedMemory == rhs.protectedMemory );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -56878,27 +60411,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProtectedMemoryProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, protectedNoFault );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProtectedMemoryProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedNoFault == rhs.protectedNoFault );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -56991,30 +60530,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, provokingVertexLast, transformFeedbackPreservesProvokingVertex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProvokingVertexFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexLast == rhs.provokingVertexLast ) &&
+             ( transformFeedbackPreservesProvokingVertex == rhs.transformFeedbackPreservesProvokingVertex );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -57086,31 +60632,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceProvokingVertexPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, provokingVertexModePerPipeline, transformFeedbackPreservesTriangleFanProvokingVertex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceProvokingVertexPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( provokingVertexModePerPipeline == rhs.provokingVertexModePerPipeline ) &&
+             ( transformFeedbackPreservesTriangleFanProvokingVertex ==
+               rhs.transformFeedbackPreservesTriangleFanProvokingVertex );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -57180,27 +60735,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxPushDescriptors );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDevicePushDescriptorPropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPushDescriptors == rhs.maxPushDescriptors );
+#  endif
     }
 
     bool operator!=( PhysicalDevicePushDescriptorPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -57284,27 +60845,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, formatRgba10x6WithoutYCbCrSampler );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( formatRgba10x6WithoutYCbCrSampler == rhs.formatRgba10x6WithoutYCbCrSampler );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -57412,15 +60980,16 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -57429,18 +60998,26 @@ namespace VULKAN_HPP_NAMESPACE
                        rasterizationOrderDepthAttachmentAccess,
                        rasterizationOrderStencilAttachmentAccess );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( rasterizationOrderColorAttachmentAccess == rhs.rasterizationOrderColorAttachmentAccess ) &&
+             ( rasterizationOrderDepthAttachmentAccess == rhs.rasterizationOrderDepthAttachmentAccess ) &&
+             ( rasterizationOrderStencilAttachmentAccess == rhs.rasterizationOrderStencilAttachmentAccess );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -57526,27 +61103,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRayQueryFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, rayQuery );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayQueryFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayQuery == rhs.rayQuery );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -57639,30 +61222,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, rayTracingMotionBlur, rayTracingMotionBlurPipelineTraceRaysIndirect );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMotionBlur == rhs.rayTracingMotionBlur ) &&
+             ( rayTracingMotionBlurPipelineTraceRaysIndirect == rhs.rayTracingMotionBlurPipelineTraceRaysIndirect );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -57785,9 +61375,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRayTracingPipelineFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -57795,7 +61386,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -57806,18 +61397,29 @@ namespace VULKAN_HPP_NAMESPACE
                        rayTracingPipelineTraceRaysIndirect,
                        rayTraversalPrimitiveCulling );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayTracingPipelineFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPipeline == rhs.rayTracingPipeline ) &&
+             ( rayTracingPipelineShaderGroupHandleCaptureReplay ==
+               rhs.rayTracingPipelineShaderGroupHandleCaptureReplay ) &&
+             ( rayTracingPipelineShaderGroupHandleCaptureReplayMixed ==
+               rhs.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ) &&
+             ( rayTracingPipelineTraceRaysIndirect == rhs.rayTracingPipelineTraceRaysIndirect ) &&
+             ( rayTraversalPrimitiveCulling == rhs.rayTraversalPrimitiveCulling );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -57904,9 +61506,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRayTracingPipelinePropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -57917,7 +61520,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -57931,18 +61534,31 @@ namespace VULKAN_HPP_NAMESPACE
                        shaderGroupHandleAlignment,
                        maxRayHitAttributeSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayTracingPipelinePropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) &&
+             ( maxRayRecursionDepth == rhs.maxRayRecursionDepth ) &&
+             ( maxShaderGroupStride == rhs.maxShaderGroupStride ) &&
+             ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) &&
+             ( shaderGroupHandleCaptureReplaySize == rhs.shaderGroupHandleCaptureReplaySize ) &&
+             ( maxRayDispatchInvocationCount == rhs.maxRayDispatchInvocationCount ) &&
+             ( shaderGroupHandleAlignment == rhs.shaderGroupHandleAlignment ) &&
+             ( maxRayHitAttributeSize == rhs.maxRayHitAttributeSize );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -58030,9 +61646,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRayTracingPropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -58043,7 +61660,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint64_t const &,
                uint64_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -58057,18 +61674,29 @@ namespace VULKAN_HPP_NAMESPACE
                        maxTriangleCount,
                        maxDescriptorSetAccelerationStructures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) &&
+             ( maxShaderGroupStride == rhs.maxShaderGroupStride ) &&
+             ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) &&
+             ( maxGeometryCount == rhs.maxGeometryCount ) && ( maxInstanceCount == rhs.maxInstanceCount ) &&
+             ( maxTriangleCount == rhs.maxTriangleCount ) &&
+             ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -58160,27 +61788,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, representativeFragmentTest );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( representativeFragmentTest == rhs.representativeFragmentTest );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -58280,31 +61915,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRobustness2FeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, robustBufferAccess2, robustImageAccess2, nullDescriptor );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRobustness2FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) &&
+             ( robustImageAccess2 == rhs.robustImageAccess2 ) && ( nullDescriptor == rhs.nullDescriptor );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRobustness2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -58375,30 +62017,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceRobustness2PropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, robustStorageBufferAccessSizeAlignment, robustUniformBufferAccessSizeAlignment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceRobustness2PropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) &&
+             ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceRobustness2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -58476,9 +62126,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSampleLocationsPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlags const &,
@@ -58486,7 +62137,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<float, 2> const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -58497,18 +62148,28 @@ namespace VULKAN_HPP_NAMESPACE
                        sampleLocationSubPixelBits,
                        variableSampleLocations );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) &&
+             ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) &&
+             ( sampleLocationCoordinateRange == rhs.sampleLocationCoordinateRange ) &&
+             ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) &&
+             ( variableSampleLocations == rhs.variableSampleLocations );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -58583,30 +62244,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSamplerFilterMinmaxProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, filterMinmaxSingleComponentFormats, filterMinmaxImageComponentMapping );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) &&
+             ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -58692,27 +62361,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, samplerYcbcrConversion );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( samplerYcbcrConversion == rhs.samplerYcbcrConversion );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -58795,27 +62471,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, scalarBlockLayout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalarBlockLayout == rhs.scalarBlockLayout );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -58902,27 +62584,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, separateDepthStencilLayouts );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -59106,9 +62795,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -59123,7 +62813,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -59141,18 +62831,35 @@ namespace VULKAN_HPP_NAMESPACE
                        shaderImageFloat32AtomicMinMax,
                        sparseImageFloat32AtomicMinMax );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderBufferFloat16Atomics == rhs.shaderBufferFloat16Atomics ) &&
+             ( shaderBufferFloat16AtomicAdd == rhs.shaderBufferFloat16AtomicAdd ) &&
+             ( shaderBufferFloat16AtomicMinMax == rhs.shaderBufferFloat16AtomicMinMax ) &&
+             ( shaderBufferFloat32AtomicMinMax == rhs.shaderBufferFloat32AtomicMinMax ) &&
+             ( shaderBufferFloat64AtomicMinMax == rhs.shaderBufferFloat64AtomicMinMax ) &&
+             ( shaderSharedFloat16Atomics == rhs.shaderSharedFloat16Atomics ) &&
+             ( shaderSharedFloat16AtomicAdd == rhs.shaderSharedFloat16AtomicAdd ) &&
+             ( shaderSharedFloat16AtomicMinMax == rhs.shaderSharedFloat16AtomicMinMax ) &&
+             ( shaderSharedFloat32AtomicMinMax == rhs.shaderSharedFloat32AtomicMinMax ) &&
+             ( shaderSharedFloat64AtomicMinMax == rhs.shaderSharedFloat64AtomicMinMax ) &&
+             ( shaderImageFloat32AtomicMinMax == rhs.shaderImageFloat32AtomicMinMax ) &&
+             ( sparseImageFloat32AtomicMinMax == rhs.sparseImageFloat32AtomicMinMax );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -59346,9 +63053,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -59363,7 +63071,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -59381,18 +63089,35 @@ namespace VULKAN_HPP_NAMESPACE
                        sparseImageFloat32Atomics,
                        sparseImageFloat32AtomicAdd );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderBufferFloat32Atomics == rhs.shaderBufferFloat32Atomics ) &&
+             ( shaderBufferFloat32AtomicAdd == rhs.shaderBufferFloat32AtomicAdd ) &&
+             ( shaderBufferFloat64Atomics == rhs.shaderBufferFloat64Atomics ) &&
+             ( shaderBufferFloat64AtomicAdd == rhs.shaderBufferFloat64AtomicAdd ) &&
+             ( shaderSharedFloat32Atomics == rhs.shaderSharedFloat32Atomics ) &&
+             ( shaderSharedFloat32AtomicAdd == rhs.shaderSharedFloat32AtomicAdd ) &&
+             ( shaderSharedFloat64Atomics == rhs.shaderSharedFloat64Atomics ) &&
+             ( shaderSharedFloat64AtomicAdd == rhs.shaderSharedFloat64AtomicAdd ) &&
+             ( shaderImageFloat32Atomics == rhs.shaderImageFloat32Atomics ) &&
+             ( shaderImageFloat32AtomicAdd == rhs.shaderImageFloat32AtomicAdd ) &&
+             ( sparseImageFloat32Atomics == rhs.sparseImageFloat32Atomics ) &&
+             ( sparseImageFloat32AtomicAdd == rhs.sparseImageFloat32AtomicAdd );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -59495,30 +63220,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderBufferInt64Atomics, shaderSharedInt64Atomics );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) &&
+             ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -59611,30 +63344,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderClockFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderSubgroupClock, shaderDeviceClock );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupClock == rhs.shaderSubgroupClock ) &&
+             ( shaderDeviceClock == rhs.shaderDeviceClock );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -59704,30 +63444,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ShaderCorePropertiesFlagsAMD const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderCoreFeatures, activeComputeUnitCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) &&
+             ( activeComputeUnitCount == rhs.activeComputeUnitCount );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -59822,9 +63569,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -59841,7 +63589,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -59861,18 +63609,31 @@ namespace VULKAN_HPP_NAMESPACE
                        maxVgprAllocation,
                        vgprAllocationGranularity );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEngineCount == rhs.shaderEngineCount ) &&
+             ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount ) &&
+             ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray ) &&
+             ( simdPerComputeUnit == rhs.simdPerComputeUnit ) && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd ) &&
+             ( wavefrontSize == rhs.wavefrontSize ) && ( sgprsPerSimd == rhs.sgprsPerSimd ) &&
+             ( minSgprAllocation == rhs.minSgprAllocation ) && ( maxSgprAllocation == rhs.maxSgprAllocation ) &&
+             ( sgprAllocationGranularity == rhs.sgprAllocationGranularity ) && ( vgprsPerSimd == rhs.vgprsPerSimd ) &&
+             ( minVgprAllocation == rhs.minVgprAllocation ) && ( maxVgprAllocation == rhs.maxVgprAllocation ) &&
+             ( vgprAllocationGranularity == rhs.vgprAllocationGranularity );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -59970,27 +63731,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderDemoteToHelperInvocation );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -60075,27 +63843,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderDrawParametersFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderDrawParameters );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -60188,30 +63962,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderFloat16, shaderInt8 );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16 == rhs.shaderFloat16 ) &&
+             ( shaderInt8 == rhs.shaderInt8 );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -60308,30 +64089,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderImageInt64Atomics, sparseImageInt64Atomics );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderImageInt64Atomics == rhs.shaderImageInt64Atomics ) &&
+             ( sparseImageInt64Atomics == rhs.sparseImageInt64Atomics );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -60415,27 +64204,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderImageFootprintFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, imageFootprint );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFootprint == rhs.imageFootprint );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -60520,27 +64315,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderIntegerDotProduct );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderIntegerDotProductFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -60964,9 +64766,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -60999,7 +64802,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -61035,18 +64838,74 @@ namespace VULKAN_HPP_NAMESPACE
                        integerDotProductAccumulatingSaturating64BitSignedAccelerated,
                        integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) &&
+             ( integerDotProduct8BitSignedAccelerated == rhs.integerDotProduct8BitSignedAccelerated ) &&
+             ( integerDotProduct8BitMixedSignednessAccelerated ==
+               rhs.integerDotProduct8BitMixedSignednessAccelerated ) &&
+             ( integerDotProduct4x8BitPackedUnsignedAccelerated ==
+               rhs.integerDotProduct4x8BitPackedUnsignedAccelerated ) &&
+             ( integerDotProduct4x8BitPackedSignedAccelerated == rhs.integerDotProduct4x8BitPackedSignedAccelerated ) &&
+             ( integerDotProduct4x8BitPackedMixedSignednessAccelerated ==
+               rhs.integerDotProduct4x8BitPackedMixedSignednessAccelerated ) &&
+             ( integerDotProduct16BitUnsignedAccelerated == rhs.integerDotProduct16BitUnsignedAccelerated ) &&
+             ( integerDotProduct16BitSignedAccelerated == rhs.integerDotProduct16BitSignedAccelerated ) &&
+             ( integerDotProduct16BitMixedSignednessAccelerated ==
+               rhs.integerDotProduct16BitMixedSignednessAccelerated ) &&
+             ( integerDotProduct32BitUnsignedAccelerated == rhs.integerDotProduct32BitUnsignedAccelerated ) &&
+             ( integerDotProduct32BitSignedAccelerated == rhs.integerDotProduct32BitSignedAccelerated ) &&
+             ( integerDotProduct32BitMixedSignednessAccelerated ==
+               rhs.integerDotProduct32BitMixedSignednessAccelerated ) &&
+             ( integerDotProduct64BitUnsignedAccelerated == rhs.integerDotProduct64BitUnsignedAccelerated ) &&
+             ( integerDotProduct64BitSignedAccelerated == rhs.integerDotProduct64BitSignedAccelerated ) &&
+             ( integerDotProduct64BitMixedSignednessAccelerated ==
+               rhs.integerDotProduct64BitMixedSignednessAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating8BitSignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating8BitSignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating16BitSignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating16BitSignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating32BitSignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating32BitSignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating64BitSignedAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating64BitSignedAccelerated ) &&
+             ( integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ==
+               rhs.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderIntegerDotProductPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -61161,27 +65020,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderIntegerFunctions2 );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -61264,27 +65130,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderSMBuiltins );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMBuiltins == rhs.shaderSMBuiltins );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -61355,27 +65227,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderSMCount, shaderWarpsPerSM );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMCount == rhs.shaderSMCount ) &&
+             ( shaderWarpsPerSM == rhs.shaderWarpsPerSM );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -61462,27 +65341,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderSubgroupExtendedTypes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -61571,27 +65457,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderSubgroupUniformControlFlow );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderSubgroupUniformControlFlow == rhs.shaderSubgroupUniformControlFlow );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -61679,27 +65572,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderTerminateInvocation );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderTerminateInvocation == rhs.shaderTerminateInvocation );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShaderTerminateInvocationFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -61792,30 +65692,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShadingRateImageFeaturesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shadingRateImage, shadingRateCoarseSampleOrder );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImage == rhs.shadingRateImage ) &&
+             ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -61889,31 +65796,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceShadingRateImagePropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shadingRateTexelSize, shadingRatePaletteSize, shadingRateMaxCoarseSamples );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const & ) const = default;
 #else
     bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) &&
+             ( shadingRatePaletteSize == rhs.shadingRatePaletteSize ) &&
+             ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62033,9 +65948,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSparseImageFormatInfo2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Format const &,
@@ -62043,23 +65959,29 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::SampleCountFlagBits const &,
                VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
                VULKAN_HPP_NAMESPACE::ImageTiling const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, format, type, samples, usage, tiling );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) &&
+             ( samples == rhs.samples ) && ( usage == rhs.usage ) && ( tiling == rhs.tiling );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62134,32 +66056,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSubgroupProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
                VULKAN_HPP_NAMESPACE::SubgroupFeatureFlags const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, subgroupSize, supportedStages, supportedOperations, quadOperationsInAllStages );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubgroupProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSize == rhs.subgroupSize ) &&
+             ( supportedStages == rhs.supportedStages ) && ( supportedOperations == rhs.supportedOperations ) &&
+             ( quadOperationsInAllStages == rhs.quadOperationsInAllStages );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62254,30 +66184,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, subgroupSizeControl, computeFullSubgroups );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSizeControl == rhs.subgroupSizeControl ) &&
+             ( computeFullSubgroups == rhs.computeFullSubgroups );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSubgroupSizeControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62353,33 +66290,42 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ShaderStageFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, minSubgroupSize, maxSubgroupSize, maxComputeWorkgroupSubgroups, requiredSubgroupSizeStages );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) &&
+             ( maxSubgroupSize == rhs.maxSubgroupSize ) &&
+             ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) &&
+             ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSubgroupSizeControlPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62465,27 +66411,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, subpassShading );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassShading == rhs.subpassShading );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62554,27 +66506,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxSubpassShadingWorkgroupSizeAspectRatio );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxSubpassShadingWorkgroupSizeAspectRatio == rhs.maxSubpassShadingWorkgroupSizeAspectRatio );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62654,28 +66613,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSurfaceInfo2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::
       tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::SurfaceKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, surface );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surface == rhs.surface );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62757,27 +66722,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, synchronization2 );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceSynchronization2FeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( synchronization2 == rhs.synchronization2 );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceSynchronization2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62862,27 +66833,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, texelBufferAlignment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( texelBufferAlignment == rhs.texelBufferAlignment );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -62957,16 +66934,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -62976,18 +66954,27 @@ namespace VULKAN_HPP_NAMESPACE
                        uniformTexelBufferOffsetAlignmentBytes,
                        uniformTexelBufferOffsetSingleTexelAlignment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) &&
+             ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) &&
+             ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) &&
+             ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceTexelBufferAlignmentPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -63076,27 +67063,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, textureCompressionASTC_HDR );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -63178,27 +67172,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, timelineSemaphore );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timelineSemaphore == rhs.timelineSemaphore );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -63267,27 +67267,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxTimelineSemaphoreValueDifference );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -63361,9 +67368,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceToolPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &,
@@ -63371,23 +67379,29 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_EXTENSION_NAME_SIZE> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, name, version, purposes, description, layer );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceToolPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) && ( version == rhs.version ) &&
+             ( purposes == rhs.purposes ) && ( description == rhs.description ) && ( layer == rhs.layer );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceToolPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -63483,30 +67497,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, transformFeedback, geometryStreams );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transformFeedback == rhs.transformFeedback ) &&
+             ( geometryStreams == rhs.geometryStreams );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -63594,9 +67615,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceTransformFeedbackPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -63609,7 +67631,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -63625,18 +67647,33 @@ namespace VULKAN_HPP_NAMESPACE
                        transformFeedbackRasterizationStreamSelect,
                        transformFeedbackDraw );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams ) &&
+             ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers ) &&
+             ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize ) &&
+             ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize ) &&
+             ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize ) &&
+             ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride ) &&
+             ( transformFeedbackQueries == rhs.transformFeedbackQueries ) &&
+             ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles ) &&
+             ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect ) &&
+             ( transformFeedbackDraw == rhs.transformFeedbackDraw );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -63731,27 +67768,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, uniformBufferStandardLayout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -63844,30 +67888,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, variablePointersStorageBuffer, variablePointers );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVariablePointersFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) &&
+             ( variablePointers == rhs.variablePointers );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -63965,30 +68017,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, vertexAttributeInstanceRateDivisor, vertexAttributeInstanceRateZeroDivisor );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) &&
+             ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceVertexAttributeDivisorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -64059,27 +68119,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxVertexAttribDivisor );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -64164,27 +68231,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, vertexInputDynamicState );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( vertexInputDynamicState == rhs.vertexInputDynamicState );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -64291,32 +68365,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoProfileKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagBitsKHR const &,
                VULKAN_HPP_NAMESPACE::VideoChromaSubsamplingFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::VideoComponentBitDepthFlagsKHR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoProfileKHR const & ) const = default;
 #  else
     bool operator==( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) &&
+             ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) &&
+             ( chromaBitDepth == rhs.chromaBitDepth );
+#    endif
     }
 
     bool operator!=( VideoProfileKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -64405,30 +68487,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoProfilesKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoProfileKHR * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, profileCount, pProfiles );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoProfilesKHR const & ) const = default;
 #  else
     bool operator==( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( profileCount == rhs.profileCount ) &&
+             ( pProfiles == rhs.pProfiles );
+#    endif
     }
 
     bool operator!=( VideoProfilesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -64495,30 +68584,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVideoFormatInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
                const VULKAN_HPP_NAMESPACE::VideoProfilesKHR * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, imageUsage, pVideoProfiles );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVideoFormatInfoKHR const & ) const = default;
 #  else
     bool operator==( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageUsage == rhs.imageUsage ) &&
+             ( pVideoProfiles == rhs.pVideoProfiles );
+#    endif
     }
 
     bool operator!=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -64698,9 +68794,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkan11Features *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -64715,7 +68812,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -64733,18 +68830,33 @@ namespace VULKAN_HPP_NAMESPACE
                        samplerYcbcrConversion,
                        shaderDrawParameters );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkan11Features const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) &&
+             ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) &&
+             ( storagePushConstant16 == rhs.storagePushConstant16 ) &&
+             ( storageInputOutput16 == rhs.storageInputOutput16 ) && ( multiview == rhs.multiview ) &&
+             ( multiviewGeometryShader == rhs.multiviewGeometryShader ) &&
+             ( multiviewTessellationShader == rhs.multiviewTessellationShader ) &&
+             ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) &&
+             ( variablePointers == rhs.variablePointers ) && ( protectedMemory == rhs.protectedMemory ) &&
+             ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ) &&
+             ( shaderDrawParameters == rhs.shaderDrawParameters );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -64848,9 +68960,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkan11Properties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &,
@@ -64868,7 +68981,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -64889,18 +69002,33 @@ namespace VULKAN_HPP_NAMESPACE
                        maxPerSetDescriptors,
                        maxMemoryAllocationSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkan11Properties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) &&
+             ( driverUUID == rhs.driverUUID ) && ( deviceLUID == rhs.deviceLUID ) &&
+             ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ) &&
+             ( subgroupSize == rhs.subgroupSize ) && ( subgroupSupportedStages == rhs.subgroupSupportedStages ) &&
+             ( subgroupSupportedOperations == rhs.subgroupSupportedOperations ) &&
+             ( subgroupQuadOperationsInAllStages == rhs.subgroupQuadOperationsInAllStages ) &&
+             ( pointClippingBehavior == rhs.pointClippingBehavior ) &&
+             ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) &&
+             ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ) &&
+             ( protectedNoFault == rhs.protectedNoFault ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) &&
+             ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -65408,9 +69536,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkan12Features *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
@@ -65460,7 +69589,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -65513,18 +69642,70 @@ namespace VULKAN_HPP_NAMESPACE
                        shaderOutputLayer,
                        subgroupBroadcastDynamicId );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkan12Features const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( samplerMirrorClampToEdge == rhs.samplerMirrorClampToEdge ) &&
+             ( drawIndirectCount == rhs.drawIndirectCount ) &&
+             ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) &&
+             ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) &&
+             ( storagePushConstant8 == rhs.storagePushConstant8 ) &&
+             ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) &&
+             ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ) && ( shaderFloat16 == rhs.shaderFloat16 ) &&
+             ( shaderInt8 == rhs.shaderInt8 ) && ( descriptorIndexing == rhs.descriptorIndexing ) &&
+             ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) &&
+             ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) &&
+             ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) &&
+             ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) &&
+             ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) &&
+             ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) &&
+             ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) &&
+             ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) &&
+             ( shaderUniformTexelBufferArrayNonUniformIndexing ==
+               rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) &&
+             ( shaderStorageTexelBufferArrayNonUniformIndexing ==
+               rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) &&
+             ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) &&
+             ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) &&
+             ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) &&
+             ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) &&
+             ( descriptorBindingUniformTexelBufferUpdateAfterBind ==
+               rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) &&
+             ( descriptorBindingStorageTexelBufferUpdateAfterBind ==
+               rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) &&
+             ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) &&
+             ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) &&
+             ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) &&
+             ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ) &&
+             ( samplerFilterMinmax == rhs.samplerFilterMinmax ) && ( scalarBlockLayout == rhs.scalarBlockLayout ) &&
+             ( imagelessFramebuffer == rhs.imagelessFramebuffer ) &&
+             ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ) &&
+             ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ) &&
+             ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ) &&
+             ( hostQueryReset == rhs.hostQueryReset ) && ( timelineSemaphore == rhs.timelineSemaphore ) &&
+             ( bufferDeviceAddress == rhs.bufferDeviceAddress ) &&
+             ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) &&
+             ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ) &&
+             ( vulkanMemoryModel == rhs.vulkanMemoryModel ) &&
+             ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) &&
+             ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ) &&
+             ( shaderOutputViewportIndex == rhs.shaderOutputViewportIndex ) &&
+             ( shaderOutputLayer == rhs.shaderOutputLayer ) &&
+             ( subgroupBroadcastDynamicId == rhs.subgroupBroadcastDynamicId );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -65738,9 +69919,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkan12Properties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::DriverId const &,
@@ -65795,7 +69977,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint64_t const &,
                VULKAN_HPP_NAMESPACE::SampleCountFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -65853,18 +70035,86 @@ namespace VULKAN_HPP_NAMESPACE
                        maxTimelineSemaphoreValueDifference,
                        framebufferIntegerColorSampleCounts );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkan12Properties const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) &&
+             ( driverName == rhs.driverName ) && ( driverInfo == rhs.driverInfo ) &&
+             ( conformanceVersion == rhs.conformanceVersion ) &&
+             ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) &&
+             ( roundingModeIndependence == rhs.roundingModeIndependence ) &&
+             ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) &&
+             ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) &&
+             ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) &&
+             ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) &&
+             ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) &&
+             ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) &&
+             ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) &&
+             ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) &&
+             ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) &&
+             ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) &&
+             ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) &&
+             ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) &&
+             ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) &&
+             ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) &&
+             ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ) &&
+             ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) &&
+             ( shaderUniformBufferArrayNonUniformIndexingNative ==
+               rhs.shaderUniformBufferArrayNonUniformIndexingNative ) &&
+             ( shaderSampledImageArrayNonUniformIndexingNative ==
+               rhs.shaderSampledImageArrayNonUniformIndexingNative ) &&
+             ( shaderStorageBufferArrayNonUniformIndexingNative ==
+               rhs.shaderStorageBufferArrayNonUniformIndexingNative ) &&
+             ( shaderStorageImageArrayNonUniformIndexingNative ==
+               rhs.shaderStorageImageArrayNonUniformIndexingNative ) &&
+             ( shaderInputAttachmentArrayNonUniformIndexingNative ==
+               rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) &&
+             ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) &&
+             ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) &&
+             ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) &&
+             ( maxPerStageDescriptorUpdateAfterBindUniformBuffers ==
+               rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) &&
+             ( maxPerStageDescriptorUpdateAfterBindStorageBuffers ==
+               rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) &&
+             ( maxPerStageDescriptorUpdateAfterBindSampledImages ==
+               rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) &&
+             ( maxPerStageDescriptorUpdateAfterBindStorageImages ==
+               rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) &&
+             ( maxPerStageDescriptorUpdateAfterBindInputAttachments ==
+               rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) &&
+             ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) &&
+             ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) &&
+             ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) &&
+             ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ==
+               rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) &&
+             ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) &&
+             ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ==
+               rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) &&
+             ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) &&
+             ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) &&
+             ( maxDescriptorSetUpdateAfterBindInputAttachments ==
+               rhs.maxDescriptorSetUpdateAfterBindInputAttachments ) &&
+             ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) &&
+             ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) &&
+             ( independentResolveNone == rhs.independentResolveNone ) &&
+             ( independentResolve == rhs.independentResolve ) &&
+             ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) &&
+             ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ) &&
+             ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ) &&
+             ( framebufferIntegerColorSampleCounts == rhs.framebufferIntegerColorSampleCounts );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -66017,32 +70267,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, vulkanMemoryModel, vulkanMemoryModelDeviceScope, vulkanMemoryModelAvailabilityVisibilityChains );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const & ) const = default;
 #else
     bool operator==( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) &&
+             ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) &&
+             ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -66161,16 +70419,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -66180,18 +70439,27 @@ namespace VULKAN_HPP_NAMESPACE
                        workgroupMemoryExplicitLayout8BitAccess,
                        workgroupMemoryExplicitLayout16BitAccess );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( workgroupMemoryExplicitLayout == rhs.workgroupMemoryExplicitLayout ) &&
+             ( workgroupMemoryExplicitLayoutScalarBlockLayout == rhs.workgroupMemoryExplicitLayoutScalarBlockLayout ) &&
+             ( workgroupMemoryExplicitLayout8BitAccess == rhs.workgroupMemoryExplicitLayout8BitAccess ) &&
+             ( workgroupMemoryExplicitLayout16BitAccess == rhs.workgroupMemoryExplicitLayout16BitAccess );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -66280,27 +70548,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, ycbcr2plane444Formats );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcr2plane444Formats == rhs.ycbcr2plane444Formats );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -66383,27 +70657,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, ycbcrImageArrays );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & ) const = default;
 #else
     bool operator==( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrImageArrays == rhs.ycbcrImageArrays );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -66490,27 +70770,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shaderZeroInitializeWorkgroupMemory );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & ) const = default;
 #else
     bool operator==( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory );
+#  endif
     }
 
     bool operator!=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -66623,31 +70910,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCacheCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags const &,
                size_t const &,
                const void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, initialDataSize, pInitialData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCacheCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData );
+#  endif
     }
 
     bool operator!=( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -66752,31 +71046,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCacheHeaderVersionOne *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &,
                VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, VK_UUID_SIZE> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( headerSize, headerVersion, vendorID, deviceID, pipelineCacheUUID );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCacheHeaderVersionOne const & ) const = default;
 #else
     bool operator==( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) &&
+             ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) &&
+             ( pipelineCacheUUID == rhs.pipelineCacheUUID );
+#  endif
     }
 
     bool operator!=( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -66876,31 +71178,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineColorBlendAdvancedStateCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::BlendOverlapEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcPremultiplied, dstPremultiplied, blendOverlap );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcPremultiplied == rhs.srcPremultiplied ) &&
+             ( dstPremultiplied == rhs.dstPremultiplied ) && ( blendOverlap == rhs.blendOverlap );
+#  endif
     }
 
     bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -67010,30 +71319,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineColorWriteCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Bool32 * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, attachmentCount, pColorWriteEnables );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineColorWriteCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) &&
+             ( pColorWriteEnables == rhs.pColorWriteEnables );
+#  endif
     }
 
     bool operator!=( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -67115,29 +71431,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCompilerControlFlagsAMD const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, compilerControlFlags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCompilerControlCreateInfoAMD const & ) const = default;
 #else
     bool operator==( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compilerControlFlags == rhs.compilerControlFlags );
+#  endif
     }
 
     bool operator!=( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -67282,9 +71604,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCoverageModulationStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateFlagsNV const &,
@@ -67292,7 +71615,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                const float * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -67303,18 +71626,27 @@ namespace VULKAN_HPP_NAMESPACE
                        coverageModulationTableCount,
                        pCoverageModulationTable );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( coverageModulationMode == rhs.coverageModulationMode ) &&
+             ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) &&
+             ( coverageModulationTableCount == rhs.coverageModulationTableCount ) &&
+             ( pCoverageModulationTable == rhs.pCoverageModulationTable );
+#  endif
     }
 
     bool operator!=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -67414,30 +71746,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCoverageReductionStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateFlagsNV const &,
                VULKAN_HPP_NAMESPACE::CoverageReductionModeNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, coverageReductionMode );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( coverageReductionMode == rhs.coverageReductionMode );
+#  endif
     }
 
     bool operator!=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -67542,31 +71881,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCoverageToColorStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateFlagsNV const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, coverageToColorEnable, coverageToColorLocation );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( coverageToColorEnable == rhs.coverageToColorEnable ) &&
+             ( coverageToColorLocation == rhs.coverageToColorLocation );
+#  endif
     }
 
     bool operator!=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -67631,27 +71978,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCreationFeedbackEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT const &, uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( flags, duration );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCreationFeedbackEXT const & ) const = default;
 #else
     bool operator==( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( flags == rhs.flags ) && ( duration == rhs.duration );
+#  endif
     }
 
     bool operator!=( PipelineCreationFeedbackEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -67766,32 +72119,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackEXT * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, pPipelineCreationFeedback, pipelineStageCreationFeedbackCount, pPipelineStageCreationFeedbacks );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineCreationFeedbackCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) &&
+             ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) &&
+             ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks );
+#  endif
     }
 
     bool operator!=( PipelineCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -67928,32 +72290,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineDiscardRectangleStateCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateFlagsEXT const &,
                VULKAN_HPP_NAMESPACE::DiscardRectangleModeEXT const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Rect2D * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, discardRectangleMode, discardRectangleCount, pDiscardRectangles );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( discardRectangleMode == rhs.discardRectangleMode ) &&
+             ( discardRectangleCount == rhs.discardRectangleCount ) && ( pDiscardRectangles == rhs.pDiscardRectangles );
+#  endif
     }
 
     bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -68044,30 +72414,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineExecutableInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Pipeline const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pipeline, executableIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineExecutableInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ) &&
+             ( executableIndex == rhs.executableIndex );
+#  endif
     }
 
     bool operator!=( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -68157,9 +72534,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
@@ -68167,23 +72545,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                size_t const &,
                void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, name, description, isText, dataSize, pData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineExecutableInternalRepresentationKHR const & ) const = default;
 #else
     bool operator==( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( name == rhs.name ) &&
+             ( description == rhs.description ) && ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) &&
+             ( pData == rhs.pData );
+#  endif
     }
 
     bool operator!=( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -68258,32 +72643,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineExecutablePropertiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stages, name, description, subgroupSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineExecutablePropertiesKHR const & ) const = default;
 #else
     bool operator==( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( name == rhs.name ) &&
+             ( description == rhs.description ) && ( subgroupSize == rhs.subgroupSize );
+#  endif
     }
 
     bool operator!=( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -68422,20 +72814,22 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineExecutableStatisticKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<char, VK_MAX_DESCRIPTION_SIZE> const &,
                VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR const &,
                VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, name, description, format, value );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePipelineExecutableStatisticKHR;
@@ -68543,31 +72937,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineFragmentShadingRateEnumStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::FragmentShadingRateTypeNV const &,
                VULKAN_HPP_NAMESPACE::FragmentShadingRateNV const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR, 2> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shadingRateType, shadingRate, combinerOps );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineFragmentShadingRateEnumStateCreateInfoNV const & ) const = default;
 #else
-    bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
+    bool     operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateType == rhs.shadingRateType ) &&
+             ( shadingRate == rhs.shadingRate ) && ( combinerOps == rhs.combinerOps );
+#  endif
     }
 
     bool operator!=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -68667,30 +73068,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineFragmentShadingRateStateCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::FragmentShadingRateCombinerOpKHR, 2> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fragmentSize, combinerOps );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineFragmentShadingRateStateCreateInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentSize == rhs.fragmentSize ) &&
+             ( combinerOps == rhs.combinerOps );
+#  endif
     }
 
     bool operator!=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -68768,28 +73176,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::
       tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Pipeline const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pipeline );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline );
+#  endif
     }
 
     bool operator!=( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -68870,27 +73284,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPushConstantRange *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ShaderStageFlags const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( stageFlags, offset, size );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PushConstantRange const & ) const = default;
 #else
     bool operator==( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && ( size == rhs.size );
+#  endif
     }
 
     bool operator!=( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -69031,9 +73451,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineLayoutCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags const &,
@@ -69041,23 +73462,31 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::PushConstantRange * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, setLayoutCount, pSetLayouts, pushConstantRangeCount, pPushConstantRanges );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineLayoutCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( setLayoutCount == rhs.setLayoutCount ) && ( pSetLayouts == rhs.pSetLayouts ) &&
+             ( pushConstantRangeCount == rhs.pushConstantRangeCount ) &&
+             ( pPushConstantRanges == rhs.pPushConstantRanges );
+#  endif
     }
 
     bool operator!=( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -69164,30 +73593,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineLibraryCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Pipeline * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, libraryCount, pLibraries );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineLibraryCreateInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( libraryCount == rhs.libraryCount ) &&
+             ( pLibraries == rhs.pLibraries );
+#  endif
     }
 
     bool operator!=( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -69292,31 +73728,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationConservativeStateCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateFlagsEXT const &,
                VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT const &,
                float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, conservativeRasterizationMode, extraPrimitiveOverestimationSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) &&
+             ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize );
+#  endif
     }
 
     bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -69413,30 +73857,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationDepthClipStateCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateFlagsEXT const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, depthClipEnable );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( depthClipEnable == rhs.depthClipEnable );
+#  endif
     }
 
     bool operator!=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -69550,32 +74001,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                uint16_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, lineRasterizationMode, stippledLineEnable, lineStippleFactor, lineStipplePattern );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationLineStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( lineRasterizationMode == rhs.lineRasterizationMode ) &&
+             ( stippledLineEnable == rhs.stippledLineEnable ) && ( lineStippleFactor == rhs.lineStippleFactor ) &&
+             ( lineStipplePattern == rhs.lineStipplePattern );
+#  endif
     }
 
     bool operator!=( PipelineRasterizationLineStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -69666,29 +74126,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, provokingVertexMode );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexMode == rhs.provokingVertexMode );
+#  endif
     }
 
     bool operator!=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -69776,29 +74242,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationStateRasterizationOrderAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::RasterizationOrderAMD const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, rasterizationOrder );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const & ) const = default;
 #else
     bool operator==( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrder == rhs.rasterizationOrder );
+#  endif
     }
 
     bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -69893,30 +74365,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRasterizationStateStreamCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateFlagsEXT const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, rasterizationStream );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( rasterizationStream == rhs.rasterizationStream );
+#  endif
     }
 
     bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -70058,9 +74537,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRenderingCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -70068,7 +74548,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::Format * const &,
                VULKAN_HPP_NAMESPACE::Format const &,
                VULKAN_HPP_NAMESPACE::Format const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -70079,18 +74559,27 @@ namespace VULKAN_HPP_NAMESPACE
                        depthAttachmentFormat,
                        stencilAttachmentFormat );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRenderingCreateInfoKHR const & ) const = default;
 #else
     bool operator==( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) &&
+             ( colorAttachmentCount == rhs.colorAttachmentCount ) &&
+             ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) &&
+             ( depthAttachmentFormat == rhs.depthAttachmentFormat ) &&
+             ( stencilAttachmentFormat == rhs.stencilAttachmentFormat );
+#  endif
     }
 
     bool operator!=( PipelineRenderingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -70179,27 +74668,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, representativeFragmentTestEnable );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable );
+#  endif
     }
 
     bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -70293,30 +74789,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineSampleLocationsStateCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, sampleLocationsEnable, sampleLocationsInfo );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( sampleLocationsEnable == rhs.sampleLocationsEnable ) &&
+             ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+#  endif
     }
 
     bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -70387,27 +74891,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, requiredSubgroupSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( requiredSubgroupSize == rhs.requiredSubgroupSize );
+#  endif
     }
 
     bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -70492,29 +75002,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineTessellationDomainOriginStateCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::TessellationDomainOrigin const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, domainOrigin );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const & ) const = default;
 #else
     bool operator==( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( domainOrigin == rhs.domainOrigin );
+#  endif
     }
 
     bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -70597,27 +75113,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVertexInputBindingDivisorDescriptionEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( binding, divisor );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputBindingDivisorDescriptionEXT const & ) const = default;
 #else
     bool operator==( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( binding == rhs.binding ) && ( divisor == rhs.divisor );
+#  endif
     }
 
     bool operator!=( VertexInputBindingDivisorDescriptionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -70727,30 +75249,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineVertexInputDivisorStateCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, vertexBindingDivisorCount, pVertexBindingDivisors );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineVertexInputDivisorStateCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) &&
+             ( pVertexBindingDivisors == rhs.pVertexBindingDivisors );
+#  endif
     }
 
     bool operator!=( PipelineVertexInputDivisorStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -70878,31 +75408,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::CoarseSampleOrderTypeNV const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, sampleOrderType, customSampleOrderCount, pCustomSampleOrders );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleOrderType == rhs.sampleOrderType ) &&
+             ( customSampleOrderCount == rhs.customSampleOrderCount ) &&
+             ( pCustomSampleOrders == rhs.pCustomSampleOrders );
+#  endif
     }
 
     bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -70989,27 +75527,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, negativeOneToOne );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportDepthClipControlCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( negativeOneToOne == rhs.negativeOneToOne );
+#  endif
     }
 
     bool operator!=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -71123,30 +75667,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportExclusiveScissorStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Rect2D * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, exclusiveScissorCount, pExclusiveScissors );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( exclusiveScissorCount == rhs.exclusiveScissorCount ) && ( pExclusiveScissors == rhs.pExclusiveScissors );
+#  endif
     }
 
     bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -71245,27 +75796,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShadingRatePaletteNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, const VULKAN_HPP_NAMESPACE::ShadingRatePaletteEntryNV * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( shadingRatePaletteEntryCount, pShadingRatePaletteEntries );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShadingRatePaletteNV const & ) const = default;
 #else
     bool operator==( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount ) &&
+             ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries );
+#  endif
     }
 
     bool operator!=( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -71381,31 +75939,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportShadingRateImageStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, shadingRateImageEnable, viewportCount, pShadingRatePalettes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( shadingRateImageEnable == rhs.shadingRateImageEnable ) && ( viewportCount == rhs.viewportCount ) &&
+             ( pShadingRatePalettes == rhs.pShadingRatePalettes );
+#  endif
     }
 
     bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -71507,30 +76073,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkViewportSwizzleNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &,
                VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &,
                VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &,
                VULKAN_HPP_NAMESPACE::ViewportCoordinateSwizzleNV const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( x, y, z, w );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ViewportSwizzleNV const & ) const = default;
 #else
     bool operator==( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ) && ( w == rhs.w );
+#  endif
     }
 
     bool operator!=( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -71647,31 +76219,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportSwizzleStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateFlagsNV const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ViewportSwizzleNV * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, viewportCount, pViewportSwizzles );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( viewportCount == rhs.viewportCount ) && ( pViewportSwizzles == rhs.pViewportSwizzles );
+#  endif
     }
 
     bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -71747,27 +76326,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkViewportWScalingNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<float const &, float const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( xcoeff, ycoeff );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ViewportWScalingNV const & ) const = default;
 #else
     bool operator==( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( xcoeff == rhs.xcoeff ) && ( ycoeff == rhs.ycoeff );
+#  endif
     }
 
     bool operator!=( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -71882,31 +76467,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPipelineViewportWScalingStateCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ViewportWScalingNV * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, viewportWScalingEnable, viewportCount, pViewportWScalings );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const & ) const = default;
 #else
     bool operator==( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( viewportWScalingEnable == rhs.viewportWScalingEnable ) && ( viewportCount == rhs.viewportCount ) &&
+             ( pViewportWScalings == rhs.pViewportWScalings );
+#  endif
     }
 
     bool operator!=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -71985,27 +76578,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentFrameTokenGGP *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, GgpFrameToken const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, frameToken );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentFrameTokenGGP const & ) const = default;
 #  else
     bool operator==( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ) == 0 );
+#    endif
     }
 
     bool operator!=( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -72103,30 +76703,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentIdKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const uint64_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, swapchainCount, pPresentIds );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentIdKHR const & ) const = default;
 #else
     bool operator==( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
+             ( pPresentIds == rhs.pPresentIds );
+#  endif
     }
 
     bool operator!=( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -72323,9 +76930,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -72334,24 +76942,32 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::SwapchainKHR * const &,
                const uint32_t * const &,
                VULKAN_HPP_NAMESPACE::Result * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, waitSemaphoreCount, pWaitSemaphores, swapchainCount, pSwapchains, pImageIndices, pResults );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentInfoKHR const & ) const = default;
 #else
     bool operator==( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
+             ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( swapchainCount == rhs.swapchainCount ) &&
+             ( pSwapchains == rhs.pSwapchains ) && ( pImageIndices == rhs.pImageIndices ) &&
+             ( pResults == rhs.pResults );
+#  endif
     }
 
     bool operator!=( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -72442,27 +77058,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRectLayerKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Offset2D const &, VULKAN_HPP_NAMESPACE::Extent2D const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( offset, extent, layer );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RectLayerKHR const & ) const = default;
 #else
     bool operator==( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( layer == rhs.layer );
+#  endif
     }
 
     bool operator!=( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -72548,27 +77170,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentRegionKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, const VULKAN_HPP_NAMESPACE::RectLayerKHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( rectangleCount, pRectangles );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentRegionKHR const & ) const = default;
 #else
     bool operator==( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( rectangleCount == rhs.rectangleCount ) && ( pRectangles == rhs.pRectangles );
+#  endif
     }
 
     bool operator!=( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -72662,30 +77290,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentRegionsKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::PresentRegionKHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, swapchainCount, pRegions );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentRegionsKHR const & ) const = default;
 #else
     bool operator==( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
+             ( pRegions == rhs.pRegions );
+#  endif
     }
 
     bool operator!=( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -72759,27 +77394,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentTimeGOOGLE *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( presentID, desiredPresentTime );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentTimeGOOGLE const & ) const = default;
 #else
     bool operator==( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime );
+#  endif
     }
 
     bool operator!=( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -72873,30 +77514,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPresentTimesInfoGOOGLE *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, swapchainCount, pTimes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PresentTimesInfoGOOGLE const & ) const = default;
 #else
     bool operator==( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) &&
+             ( pTimes == rhs.pTimes );
+#  endif
     }
 
     bool operator!=( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -72973,29 +77621,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkPrivateDataSlotCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagsEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( PrivateDataSlotCreateInfoEXT const & ) const = default;
 #else
     bool operator==( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( PrivateDataSlotCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -73071,27 +77725,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkProtectedSubmitInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, protectedSubmit );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ProtectedSubmitInfo const & ) const = default;
 #else
     bool operator==( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedSubmit == rhs.protectedSubmit );
+#  endif
     }
 
     bool operator!=( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -73192,32 +77852,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueryPoolCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::QueryPoolCreateFlags const &,
                VULKAN_HPP_NAMESPACE::QueryType const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::QueryPipelineStatisticFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, queryType, queryCount, pipelineStatistics );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueryPoolCreateInfo const & ) const = default;
 #else
     bool operator==( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( queryType == rhs.queryType ) && ( queryCount == rhs.queryCount ) &&
+             ( pipelineStatistics == rhs.pipelineStatistics );
+#  endif
     }
 
     bool operator!=( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -73335,31 +78003,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueryPoolPerformanceCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, queueFamilyIndex, counterIndexCount, pCounterIndices );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueryPoolPerformanceCreateInfoKHR const & ) const = default;
 #else
     bool operator==( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
+             ( counterIndexCount == rhs.counterIndexCount ) && ( pCounterIndices == rhs.pCounterIndices );
+#  endif
     }
 
     bool operator!=( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -73446,29 +78121,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueryPoolPerformanceQueryCreateInfoINTEL *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::QueryPoolSamplingModeINTEL const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, performanceCountersSampling );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const & ) const = default;
 #else
     bool operator==( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( performanceCountersSampling == rhs.performanceCountersSampling );
+#  endif
     }
 
     bool operator!=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -73537,29 +78219,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueueFamilyCheckpointProperties2NV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, checkpointExecutionStageMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyCheckpointProperties2NV const & ) const = default;
 #else
     bool operator==( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
+#  endif
     }
 
     bool operator!=( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -73624,29 +78313,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueueFamilyCheckpointPropertiesNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, checkpointExecutionStageMask );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyCheckpointPropertiesNV const & ) const = default;
 #else
     bool operator==( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask );
+#  endif
     }
 
     bool operator!=( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -73754,31 +78450,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT,
                                                     VK_MAX_GLOBAL_PRIORITY_SIZE_EXT> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, priorityCount, priorities );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyGlobalPriorityPropertiesEXT const & ) const = default;
 #else
     bool operator==( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) &&
+             ( priorities == rhs.priorities );
+#  endif
     }
 
     bool operator!=( QueueFamilyGlobalPriorityPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -73846,30 +78549,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueueFamilyProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::QueueFlags const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::Extent3D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( queueFlags, queueCount, timestampValidBits, minImageTransferGranularity );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyProperties const & ) const = default;
 #else
     bool operator==( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( queueFlags == rhs.queueFlags ) && ( queueCount == rhs.queueCount ) &&
+             ( timestampValidBits == rhs.timestampValidBits ) &&
+             ( minImageTransferGranularity == rhs.minImageTransferGranularity );
+#  endif
     }
 
     bool operator!=( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -73924,29 +78635,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueueFamilyProperties2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::QueueFamilyProperties const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, queueFamilyProperties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyProperties2 const & ) const = default;
 #else
     bool operator==( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyProperties == rhs.queueFamilyProperties );
+#  endif
     }
 
     bool operator!=( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -74030,27 +78747,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkQueueFamilyQueryResultStatusProperties2KHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, supported );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( QueueFamilyQueryResultStatusProperties2KHR const & ) const = default;
 #  else
     bool operator==( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported );
+#    endif
     }
 
     bool operator!=( QueueFamilyQueryResultStatusProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -74179,9 +78902,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR const &,
@@ -74190,7 +78914,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                const void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -74202,18 +78926,26 @@ namespace VULKAN_HPP_NAMESPACE
                        intersectionShader,
                        pShaderGroupCaptureReplayHandle );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingShaderGroupCreateInfoKHR const & ) const = default;
 #else
     bool operator==( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) &&
+             ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) &&
+             ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ) &&
+             ( pShaderGroupCaptureReplayHandle == rhs.pShaderGroupCaptureReplayHandle );
+#  endif
     }
 
     bool operator!=( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -74312,27 +79044,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingPipelineInterfaceCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxPipelineRayPayloadSize, maxPipelineRayHitAttributeSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const & ) const = default;
 #else
     bool operator==( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( maxPipelineRayPayloadSize == rhs.maxPipelineRayPayloadSize ) &&
+             ( maxPipelineRayHitAttributeSize == rhs.maxPipelineRayHitAttributeSize );
+#  endif
     }
 
     bool operator!=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -74561,9 +79301,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingPipelineCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
@@ -74578,7 +79319,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::PipelineLayout const &,
                VULKAN_HPP_NAMESPACE::Pipeline const &,
                int32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -74596,18 +79337,28 @@ namespace VULKAN_HPP_NAMESPACE
                        basePipelineHandle,
                        basePipelineIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingPipelineCreateInfoKHR const & ) const = default;
 #else
     bool operator==( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && ( groupCount == rhs.groupCount ) &&
+             ( pGroups == rhs.pGroups ) && ( maxPipelineRayRecursionDepth == rhs.maxPipelineRayRecursionDepth ) &&
+             ( pLibraryInfo == rhs.pLibraryInfo ) && ( pLibraryInterface == rhs.pLibraryInterface ) &&
+             ( pDynamicState == rhs.pDynamicState ) && ( layout == rhs.layout ) &&
+             ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex );
+#  endif
     }
 
     bool operator!=( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -74735,9 +79486,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingShaderGroupCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::RayTracingShaderGroupTypeKHR const &,
@@ -74745,23 +79497,30 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingShaderGroupCreateInfoNV const & ) const = default;
 #else
     bool operator==( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) &&
+             ( generalShader == rhs.generalShader ) && ( closestHitShader == rhs.closestHitShader ) &&
+             ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader );
+#  endif
     }
 
     bool operator!=( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -74960,9 +79719,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRayTracingPipelineCreateInfoNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::PipelineCreateFlags const &,
@@ -74974,7 +79734,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::PipelineLayout const &,
                VULKAN_HPP_NAMESPACE::Pipeline const &,
                int32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -74989,18 +79749,26 @@ namespace VULKAN_HPP_NAMESPACE
                        basePipelineHandle,
                        basePipelineIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RayTracingPipelineCreateInfoNV const & ) const = default;
 #else
     bool operator==( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && ( groupCount == rhs.groupCount ) &&
+             ( pGroups == rhs.pGroups ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) && ( layout == rhs.layout ) &&
+             ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex );
+#  endif
     }
 
     bool operator!=( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -75067,27 +79835,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRefreshCycleDurationGOOGLE *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( refreshDuration );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RefreshCycleDurationGOOGLE const & ) const = default;
 #else
     bool operator==( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( refreshDuration == rhs.refreshDuration );
+#  endif
     }
 
     bool operator!=( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -75184,30 +79958,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassAttachmentBeginInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ImageView * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, attachmentCount, pAttachments );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassAttachmentBeginInfo const & ) const = default;
 #else
     bool operator==( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) &&
+             ( pAttachments == rhs.pAttachments );
+#  endif
     }
 
     bool operator!=( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -75346,9 +80127,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassBeginInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::RenderPass const &,
@@ -75356,23 +80138,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Rect2D const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ClearValue * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, renderPass, framebuffer, renderArea, clearValueCount, pClearValues );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassBeginInfo const & ) const = default;
 #else
     bool operator==( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) &&
+             ( framebuffer == rhs.framebuffer ) && ( renderArea == rhs.renderArea ) &&
+             ( clearValueCount == rhs.clearValueCount ) && ( pClearValues == rhs.pClearValues );
+#  endif
     }
 
     bool operator!=( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -75602,9 +80391,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDescription *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags const &,
                VULKAN_HPP_NAMESPACE::PipelineBindPoint const &,
                uint32_t const &,
@@ -75615,7 +80405,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::AttachmentReference * const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( flags,
@@ -75629,18 +80419,29 @@ namespace VULKAN_HPP_NAMESPACE
                        preserveAttachmentCount,
                        pPreserveAttachments );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDescription const & ) const = default;
 #else
     bool operator==( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) &&
+             ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) &&
+             ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) &&
+             ( pResolveAttachments == rhs.pResolveAttachments ) &&
+             ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) &&
+             ( preserveAttachmentCount == rhs.preserveAttachmentCount ) &&
+             ( pPreserveAttachments == rhs.pPreserveAttachments );
+#  endif
     }
 
     bool operator!=( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -75759,9 +80560,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDependency *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlags const &,
@@ -75769,24 +80571,32 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::AccessFlags const &,
                VULKAN_HPP_NAMESPACE::AccessFlags const &,
                VULKAN_HPP_NAMESPACE::DependencyFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDependency const & ) const = default;
 #else
     bool operator==( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) &&
+             ( srcStageMask == rhs.srcStageMask ) && ( dstStageMask == rhs.dstStageMask ) &&
+             ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) &&
+             ( dependencyFlags == rhs.dependencyFlags );
+#  endif
     }
 
     bool operator!=( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -75962,9 +80772,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::RenderPassCreateFlags const &,
@@ -75974,24 +80785,32 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::SubpassDescription * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SubpassDependency * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, flags, attachmentCount, pAttachments, subpassCount, pSubpasses, dependencyCount, pDependencies );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassCreateInfo const & ) const = default;
 #else
     bool operator==( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) &&
+             ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) &&
+             ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies );
+#  endif
     }
 
     bool operator!=( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -76242,9 +81061,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDescription2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SubpassDescriptionFlags const &,
@@ -76258,7 +81078,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -76275,18 +81095,30 @@ namespace VULKAN_HPP_NAMESPACE
                        preserveAttachmentCount,
                        pPreserveAttachments );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDescription2 const & ) const = default;
 #else
     bool operator==( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( viewMask == rhs.viewMask ) &&
+             ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) &&
+             ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) &&
+             ( pResolveAttachments == rhs.pResolveAttachments ) &&
+             ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) &&
+             ( preserveAttachmentCount == rhs.preserveAttachmentCount ) &&
+             ( pPreserveAttachments == rhs.pPreserveAttachments );
+#  endif
     }
 
     bool operator!=( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -76431,9 +81263,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDependency2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -76444,7 +81277,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::AccessFlags const &,
                VULKAN_HPP_NAMESPACE::DependencyFlags const &,
                int32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -76458,18 +81291,27 @@ namespace VULKAN_HPP_NAMESPACE
                        dependencyFlags,
                        viewOffset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDependency2 const & ) const = default;
 #else
     bool operator==( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubpass == rhs.srcSubpass ) &&
+             ( dstSubpass == rhs.dstSubpass ) && ( srcStageMask == rhs.srcStageMask ) &&
+             ( dstStageMask == rhs.dstStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) &&
+             ( dstAccessMask == rhs.dstAccessMask ) && ( dependencyFlags == rhs.dependencyFlags ) &&
+             ( viewOffset == rhs.viewOffset );
+#  endif
     }
 
     bool operator!=( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -76685,9 +81527,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassCreateInfo2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::RenderPassCreateFlags const &,
@@ -76699,7 +81542,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::SubpassDependency2 * const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -76714,18 +81557,28 @@ namespace VULKAN_HPP_NAMESPACE
                        correlatedViewMaskCount,
                        pCorrelatedViewMasks );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassCreateInfo2 const & ) const = default;
 #else
     bool operator==( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) &&
+             ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) &&
+             ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ) &&
+             ( correlatedViewMaskCount == rhs.correlatedViewMaskCount ) &&
+             ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks );
+#  endif
     }
 
     bool operator!=( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -76816,29 +81669,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassFragmentDensityMapCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::AttachmentReference const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fragmentDensityMapAttachment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const & ) const = default;
 #else
     bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment );
+#  endif
     }
 
     bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -76952,30 +81812,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassInputAttachmentAspectCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, aspectReferenceCount, pAspectReferences );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const & ) const = default;
 #else
     bool operator==( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aspectReferenceCount == rhs.aspectReferenceCount ) &&
+             ( pAspectReferences == rhs.pAspectReferences );
+#  endif
     }
 
     bool operator!=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -77145,9 +82012,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassMultiviewCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -77156,7 +82024,7 @@ namespace VULKAN_HPP_NAMESPACE
                const int32_t * const &,
                uint32_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -77168,18 +82036,26 @@ namespace VULKAN_HPP_NAMESPACE
                        correlationMaskCount,
                        pCorrelationMasks );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassMultiviewCreateInfo const & ) const = default;
 #else
     bool operator==( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassCount == rhs.subpassCount ) &&
+             ( pViewMasks == rhs.pViewMasks ) && ( dependencyCount == rhs.dependencyCount ) &&
+             ( pViewOffsets == rhs.pViewOffsets ) && ( correlationMaskCount == rhs.correlationMaskCount ) &&
+             ( pCorrelationMasks == rhs.pCorrelationMasks );
+#  endif
     }
 
     bool operator!=( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -77262,27 +82138,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassSampleLocationsEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( subpassIndex, sampleLocationsInfo );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassSampleLocationsEXT const & ) const = default;
 #else
     bool operator==( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( subpassIndex == rhs.subpassIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo );
+#  endif
     }
 
     bool operator!=( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -77419,16 +82301,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassSampleLocationsBeginInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -77438,18 +82321,27 @@ namespace VULKAN_HPP_NAMESPACE
                        postSubpassSampleLocationsCount,
                        pPostSubpassSampleLocations );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const & ) const = default;
 #else
     bool operator==( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) &&
+             ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) &&
+             ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) &&
+             ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations );
+#  endif
     }
 
     bool operator!=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -77531,29 +82423,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderPassTransformBeginInfoQCOM *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, transform );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderPassTransformBeginInfoQCOM const & ) const = default;
 #else
     bool operator==( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform );
+#  endif
     }
 
     bool operator!=( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -77695,9 +82593,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderingAttachmentInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageView const &,
@@ -77708,7 +82607,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::AttachmentLoadOp const &,
                VULKAN_HPP_NAMESPACE::AttachmentStoreOp const &,
                VULKAN_HPP_NAMESPACE::ClearValue const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -77722,6 +82621,7 @@ namespace VULKAN_HPP_NAMESPACE
                        storeOp,
                        clearValue );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType       sType              = StructureType::eRenderingAttachmentInfoKHR;
@@ -77819,30 +82719,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderingFragmentDensityMapAttachmentInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageView const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, imageView, imageLayout );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderingFragmentDensityMapAttachmentInfoEXT const & ) const = default;
 #else
     bool operator==( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) &&
+             ( imageLayout == rhs.imageLayout );
+#  endif
     }
 
     bool operator!=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -77946,31 +82853,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ImageView const &,
                VULKAN_HPP_NAMESPACE::ImageLayout const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, imageView, imageLayout, shadingRateAttachmentTexelSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderingFragmentShadingRateAttachmentInfoKHR const & ) const = default;
 #else
     bool operator==( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) &&
+             ( imageLayout == rhs.imageLayout ) &&
+             ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize );
+#  endif
     }
 
     bool operator!=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -78143,9 +83058,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkRenderingInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::RenderingFlagsKHR const &,
@@ -78156,7 +83072,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR * const &,
                const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR * const &,
                const VULKAN_HPP_NAMESPACE::RenderingAttachmentInfoKHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -78170,18 +83086,26 @@ namespace VULKAN_HPP_NAMESPACE
                        pDepthAttachment,
                        pStencilAttachment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( RenderingInfoKHR const & ) const = default;
 #else
     bool operator==( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( renderArea == rhs.renderArea ) && ( layerCount == rhs.layerCount ) && ( viewMask == rhs.viewMask ) &&
+             ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) &&
+             ( pDepthAttachment == rhs.pDepthAttachment ) && ( pStencilAttachment == rhs.pStencilAttachment );
+#  endif
     }
 
     bool operator!=( RenderingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -78334,9 +83258,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkResolveImageInfo2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Image const &,
@@ -78345,23 +83270,31 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ImageLayout const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ImageResolve2KHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ResolveImageInfo2KHR const & ) const = default;
 #else
     bool operator==( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) &&
+             ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) &&
+             ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) &&
+             ( pRegions == rhs.pRegions );
+#  endif
     }
 
     bool operator!=( ResolveImageInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -78457,30 +83390,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerBorderColorComponentMappingCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ComponentMapping const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, components, srgb );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerBorderColorComponentMappingCreateInfoEXT const & ) const = default;
 #else
     bool operator==( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( components == rhs.components ) &&
+             ( srgb == rhs.srgb );
+#  endif
     }
 
     bool operator!=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -78690,9 +83630,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SamplerCreateFlags const &,
@@ -78711,7 +83652,7 @@ namespace VULKAN_HPP_NAMESPACE
                float const &,
                VULKAN_HPP_NAMESPACE::BorderColor const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -78733,18 +83674,30 @@ namespace VULKAN_HPP_NAMESPACE
                        borderColor,
                        unnormalizedCoordinates );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerCreateInfo const & ) const = default;
 #else
     bool operator==( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( magFilter == rhs.magFilter ) && ( minFilter == rhs.minFilter ) && ( mipmapMode == rhs.mipmapMode ) &&
+             ( addressModeU == rhs.addressModeU ) && ( addressModeV == rhs.addressModeV ) &&
+             ( addressModeW == rhs.addressModeW ) && ( mipLodBias == rhs.mipLodBias ) &&
+             ( anisotropyEnable == rhs.anisotropyEnable ) && ( maxAnisotropy == rhs.maxAnisotropy ) &&
+             ( compareEnable == rhs.compareEnable ) && ( compareOp == rhs.compareOp ) && ( minLod == rhs.minLod ) &&
+             ( maxLod == rhs.maxLod ) && ( borderColor == rhs.borderColor ) &&
+             ( unnormalizedCoordinates == rhs.unnormalizedCoordinates );
+#  endif
     }
 
     bool operator!=( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -78848,18 +83801,20 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerCustomBorderColorCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ClearColorValue const &,
                VULKAN_HPP_NAMESPACE::Format const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, customBorderColor, format );
     }
+#endif
 
   public:
     VULKAN_HPP_NAMESPACE::StructureType   sType             = StructureType::eSamplerCustomBorderColorCreateInfoEXT;
@@ -78938,29 +83893,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerReductionModeCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SamplerReductionMode const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, reductionMode );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerReductionModeCreateInfo const & ) const = default;
 #else
     bool operator==( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reductionMode == rhs.reductionMode );
+#  endif
     }
 
     bool operator!=( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -79105,9 +84066,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerYcbcrConversionCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Format const &,
@@ -79118,7 +84080,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::ChromaLocation const &,
                VULKAN_HPP_NAMESPACE::Filter const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -79132,18 +84094,26 @@ namespace VULKAN_HPP_NAMESPACE
                        chromaFilter,
                        forceExplicitReconstruction );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerYcbcrConversionCreateInfo const & ) const = default;
 #else
     bool operator==( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) &&
+             ( ycbcrModel == rhs.ycbcrModel ) && ( ycbcrRange == rhs.ycbcrRange ) && ( components == rhs.components ) &&
+             ( xChromaOffset == rhs.xChromaOffset ) && ( yChromaOffset == rhs.yChromaOffset ) &&
+             ( chromaFilter == rhs.chromaFilter ) && ( forceExplicitReconstruction == rhs.forceExplicitReconstruction );
+#  endif
     }
 
     bool operator!=( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -79220,27 +84190,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerYcbcrConversionImageFormatProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, combinedImageSamplerDescriptorCount );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerYcbcrConversionImageFormatProperties const & ) const = default;
 #else
     bool operator==( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount );
+#  endif
     }
 
     bool operator!=( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -79320,29 +84297,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSamplerYcbcrConversionInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, conversion );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SamplerYcbcrConversionInfo const & ) const = default;
 #else
     bool operator==( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conversion == rhs.conversion );
+#  endif
     }
 
     bool operator!=( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -79438,31 +84421,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkScreenSurfaceCreateInfoQNX *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateFlagsQNX const &,
                struct _screen_context * const &,
                struct _screen_window * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, context, window );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ScreenSurfaceCreateInfoQNX const & ) const = default;
 #  else
     bool operator==( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) &&
+             ( window == rhs.window );
+#    endif
     }
 
     bool operator!=( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -79541,29 +84531,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SemaphoreCreateFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreCreateInfo const & ) const = default;
 #else
     bool operator==( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -79648,30 +84644,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreGetFdInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Semaphore const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, semaphore, handleType );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreGetFdInfoKHR const & ) const = default;
 #else
     bool operator==( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
+             ( handleType == rhs.handleType );
+#  endif
     }
 
     bool operator!=( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -79761,30 +84764,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreGetWin32HandleInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Semaphore const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, semaphore, handleType );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreGetWin32HandleInfoKHR const & ) const = default;
 #  else
     bool operator==( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
+             ( handleType == rhs.handleType );
+#    endif
     }
 
     bool operator!=( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -79879,30 +84889,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreGetZirconHandleInfoFUCHSIA *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Semaphore const &,
                VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, semaphore, handleType );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreGetZirconHandleInfoFUCHSIA const & ) const = default;
 #  else
     bool operator==( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
+             ( handleType == rhs.handleType );
+#    endif
     }
 
     bool operator!=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -79989,30 +85006,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreSignalInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Semaphore const &,
                uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, semaphore, value );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreSignalInfo const & ) const = default;
 #else
     bool operator==( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
+             ( value == rhs.value );
+#  endif
     }
 
     bool operator!=( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -80113,32 +85137,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreSubmitInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Semaphore const &,
                uint64_t const &,
                VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, semaphore, value, stageMask, deviceIndex );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreSubmitInfoKHR const & ) const = default;
 #else
     bool operator==( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) &&
+             ( value == rhs.value ) && ( stageMask == rhs.stageMask ) && ( deviceIndex == rhs.deviceIndex );
+#  endif
     }
 
     bool operator!=( SemaphoreSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -80225,30 +85256,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreTypeCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SemaphoreType const &,
                uint64_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, semaphoreType, initialValue );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreTypeCreateInfo const & ) const = default;
 #else
     bool operator==( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphoreType == rhs.semaphoreType ) &&
+             ( initialValue == rhs.initialValue );
+#  endif
     }
 
     bool operator!=( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -80393,32 +85431,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSemaphoreWaitInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SemaphoreWaitFlags const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Semaphore * const &,
                const uint64_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, semaphoreCount, pSemaphores, pValues );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SemaphoreWaitInfo const & ) const = default;
 #else
     bool operator==( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( semaphoreCount == rhs.semaphoreCount ) && ( pSemaphores == rhs.pSemaphores ) &&
+             ( pValues == rhs.pValues );
+#  endif
     }
 
     bool operator!=( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -80486,27 +85532,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSetStateFlagsIndirectCommandNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( data );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SetStateFlagsIndirectCommandNV const & ) const = default;
 #else
     bool operator==( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( data == rhs.data );
+#  endif
     }
 
     bool operator!=( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -80607,31 +85659,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShaderModuleCreateInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ShaderModuleCreateFlags const &,
                size_t const &,
                const uint32_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, codeSize, pCode );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShaderModuleCreateInfo const & ) const = default;
 #else
     bool operator==( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode );
+#  endif
     }
 
     bool operator!=( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -80716,29 +85775,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShaderModuleValidationCacheCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ValidationCacheEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, validationCache );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( validationCache == rhs.validationCache );
+#  endif
     }
 
     bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -80805,28 +85870,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShaderResourceUsageAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &, size_t const &, size_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         numUsedVgprs, numUsedSgprs, ldsSizePerLocalWorkGroup, ldsUsageSizeInBytes, scratchMemUsageInBytes );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShaderResourceUsageAMD const & ) const = default;
 #else
     bool operator==( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( numUsedVgprs == rhs.numUsedVgprs ) && ( numUsedSgprs == rhs.numUsedSgprs ) &&
+             ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) &&
+             ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) &&
+             ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes );
+#  endif
     }
 
     bool operator!=( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -80893,9 +85967,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkShaderStatisticsInfoAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ShaderStageFlags const &,
                VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const &,
                uint32_t const &,
@@ -80903,7 +85978,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, 3> const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( shaderStageMask,
@@ -80914,18 +85989,26 @@ namespace VULKAN_HPP_NAMESPACE
                        numAvailableSgprs,
                        computeWorkGroupSize );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ShaderStatisticsInfoAMD const & ) const = default;
 #else
     bool operator==( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( shaderStageMask == rhs.shaderStageMask ) && ( resourceUsage == rhs.resourceUsage ) &&
+             ( numPhysicalVgprs == rhs.numPhysicalVgprs ) && ( numPhysicalSgprs == rhs.numPhysicalSgprs ) &&
+             ( numAvailableVgprs == rhs.numAvailableVgprs ) && ( numAvailableSgprs == rhs.numAvailableSgprs ) &&
+             ( computeWorkGroupSize == rhs.computeWorkGroupSize );
+#  endif
     }
 
     bool operator!=( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -80988,28 +86071,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSharedPresentSurfaceCapabilitiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::
       tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, sharedPresentSupportedUsageFlags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags );
+#  endif
     }
 
     bool operator!=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -81073,29 +86163,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageFormatProperties *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::ImageAspectFlags const &,
                VULKAN_HPP_NAMESPACE::Extent3D const &,
                VULKAN_HPP_NAMESPACE::SparseImageFormatFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( aspectMask, imageGranularity, flags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageFormatProperties const & ) const = default;
 #else
     bool operator==( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( aspectMask == rhs.aspectMask ) && ( imageGranularity == rhs.imageGranularity ) && ( flags == rhs.flags );
+#  endif
     }
 
     bool operator!=( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -81152,29 +86248,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageFormatProperties2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, properties );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageFormatProperties2 const & ) const = default;
 #else
     bool operator==( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties );
+#  endif
     }
 
     bool operator!=( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -81244,32 +86346,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageMemoryRequirements *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         formatProperties, imageMipTailFirstLod, imageMipTailSize, imageMipTailOffset, imageMipTailStride );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageMemoryRequirements const & ) const = default;
 #else
     bool operator==( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( formatProperties == rhs.formatProperties ) && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) &&
+             ( imageMipTailSize == rhs.imageMipTailSize ) && ( imageMipTailOffset == rhs.imageMipTailOffset ) &&
+             ( imageMipTailStride == rhs.imageMipTailStride );
+#  endif
     }
 
     bool operator!=( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -81329,29 +86439,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSparseImageMemoryRequirements2 *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryRequirements );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SparseImageMemoryRequirements2 const & ) const = default;
 #else
     bool operator==( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements );
+#  endif
     }
 
     bool operator!=( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -81443,30 +86559,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkStreamDescriptorSurfaceCreateInfoGGP *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateFlagsGGP const &,
                GgpStreamDescriptor const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, streamDescriptor );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( StreamDescriptorSurfaceCreateInfoGGP const & ) const = default;
 #  else
     bool operator==( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ) == 0 );
+#    endif
     }
 
     bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -81556,29 +86679,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkStridedDeviceAddressRegionKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::DeviceAddress const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( deviceAddress, stride, size );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( StridedDeviceAddressRegionKHR const & ) const = default;
 #else
     bool operator==( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( deviceAddress == rhs.deviceAddress ) && ( stride == rhs.stride ) && ( size == rhs.size );
+#  endif
     }
 
     bool operator!=( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -81773,9 +86902,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubmitInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -81785,7 +86915,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::CommandBuffer * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Semaphore * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -81798,18 +86928,26 @@ namespace VULKAN_HPP_NAMESPACE
                        signalSemaphoreCount,
                        pSignalSemaphores );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubmitInfo const & ) const = default;
 #else
     bool operator==( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) &&
+             ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) &&
+             ( commandBufferCount == rhs.commandBufferCount ) && ( pCommandBuffers == rhs.pCommandBuffers ) &&
+             ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && ( pSignalSemaphores == rhs.pSignalSemaphores );
+#  endif
     }
 
     bool operator!=( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -81995,9 +87133,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubmitInfo2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SubmitFlagsKHR const &,
@@ -82007,7 +87146,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfoKHR * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfoKHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -82020,18 +87159,29 @@ namespace VULKAN_HPP_NAMESPACE
                        signalSemaphoreInfoCount,
                        pSignalSemaphoreInfos );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubmitInfo2KHR const & ) const = default;
 #else
     bool operator==( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( waitSemaphoreInfoCount == rhs.waitSemaphoreInfoCount ) &&
+             ( pWaitSemaphoreInfos == rhs.pWaitSemaphoreInfos ) &&
+             ( commandBufferInfoCount == rhs.commandBufferInfoCount ) &&
+             ( pCommandBufferInfos == rhs.pCommandBufferInfos ) &&
+             ( signalSemaphoreInfoCount == rhs.signalSemaphoreInfoCount ) &&
+             ( pSignalSemaphoreInfos == rhs.pSignalSemaphoreInfos );
+#  endif
     }
 
     bool operator!=( SubmitInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -82112,29 +87262,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassBeginInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SubpassContents const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, contents );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassBeginInfo const & ) const = default;
 #else
     bool operator==( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( contents == rhs.contents );
+#  endif
     }
 
     bool operator!=( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -82233,31 +87389,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassDescriptionDepthStencilResolve *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ResolveModeFlagBits const &,
                VULKAN_HPP_NAMESPACE::ResolveModeFlagBits const &,
                const VULKAN_HPP_NAMESPACE::AttachmentReference2 * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, depthResolveMode, stencilResolveMode, pDepthStencilResolveAttachment );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassDescriptionDepthStencilResolve const & ) const = default;
 #else
     bool operator==( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthResolveMode == rhs.depthResolveMode ) &&
+             ( stencilResolveMode == rhs.stencilResolveMode ) &&
+             ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment );
+#  endif
     }
 
     bool operator!=( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -82327,27 +87491,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassEndInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassEndInfo const & ) const = default;
 #else
     bool operator==( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext );
+#  endif
     }
 
     bool operator!=( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -82458,30 +87628,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::Offset2D * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassFragmentDensityMapOffsetEndInfoQCOM const & ) const = default;
 #else
     bool operator==( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fragmentDensityOffsetCount == rhs.fragmentDensityOffsetCount ) &&
+             ( pFragmentDensityOffsets == rhs.pFragmentDensityOffsets );
+#  endif
     }
 
     bool operator!=( SubpassFragmentDensityMapOffsetEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -82551,30 +87729,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSubpassShadingPipelineCreateInfoHUAWEI *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::RenderPass const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, renderPass, subpass );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SubpassShadingPipelineCreateInfoHUAWEI const & ) const = default;
 #else
     bool operator==( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) &&
+             ( subpass == rhs.subpass );
+#  endif
     }
 
     bool operator!=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -82659,9 +87844,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceCapabilities2EXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
@@ -82675,7 +87861,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::ImageUsageFlags const &,
                VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -82692,18 +87878,30 @@ namespace VULKAN_HPP_NAMESPACE
                        supportedUsageFlags,
                        supportedSurfaceCounters );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceCapabilities2EXT const & ) const = default;
 #else
     bool operator==( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImageCount == rhs.minImageCount ) &&
+             ( maxImageCount == rhs.maxImageCount ) && ( currentExtent == rhs.currentExtent ) &&
+             ( minImageExtent == rhs.minImageExtent ) && ( maxImageExtent == rhs.maxImageExtent ) &&
+             ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && ( supportedTransforms == rhs.supportedTransforms ) &&
+             ( currentTransform == rhs.currentTransform ) &&
+             ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) &&
+             ( supportedUsageFlags == rhs.supportedUsageFlags ) &&
+             ( supportedSurfaceCounters == rhs.supportedSurfaceCounters );
+#  endif
     }
 
     bool operator!=( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -82791,9 +87989,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceCapabilitiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
@@ -82804,7 +88003,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::SurfaceTransformFlagBitsKHR const &,
                VULKAN_HPP_NAMESPACE::CompositeAlphaFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::ImageUsageFlags const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( minImageCount,
@@ -82818,18 +88017,28 @@ namespace VULKAN_HPP_NAMESPACE
                        supportedCompositeAlpha,
                        supportedUsageFlags );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) &&
+             ( currentExtent == rhs.currentExtent ) && ( minImageExtent == rhs.minImageExtent ) &&
+             ( maxImageExtent == rhs.maxImageExtent ) && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) &&
+             ( supportedTransforms == rhs.supportedTransforms ) && ( currentTransform == rhs.currentTransform ) &&
+             ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) &&
+             ( supportedUsageFlags == rhs.supportedUsageFlags );
+#  endif
     }
 
     bool operator!=( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -82892,29 +88101,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceCapabilities2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, surfaceCapabilities );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceCapabilities2KHR const & ) const = default;
 #else
     bool operator==( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCapabilities == rhs.surfaceCapabilities );
+#  endif
     }
 
     bool operator!=( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -82997,27 +88212,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceCapabilitiesFullScreenExclusiveEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fullScreenExclusiveSupported );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const & ) const = default;
 #  else
     bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported );
+#    endif
     }
 
     bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -83081,27 +88303,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceFormatKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::Format const &, VULKAN_HPP_NAMESPACE::ColorSpaceKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( format, colorSpace );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceFormatKHR const & ) const = default;
 #else
     bool operator==( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( format == rhs.format ) && ( colorSpace == rhs.colorSpace );
+#  endif
     }
 
     bool operator!=( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -83154,28 +88382,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceFormat2KHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::
       tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, surfaceFormat );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceFormat2KHR const & ) const = default;
 #else
     bool operator==( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceFormat == rhs.surfaceFormat );
+#  endif
     }
 
     bool operator!=( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -83255,29 +88489,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceFullScreenExclusiveInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::FullScreenExclusiveEXT const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, fullScreenExclusive );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const & ) const = default;
 #  else
     bool operator==( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusive == rhs.fullScreenExclusive );
+#    endif
     }
 
     bool operator!=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -83361,27 +88601,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceFullScreenExclusiveWin32InfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, HMONITOR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, hmonitor );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const & ) const = default;
 #  else
     bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hmonitor == rhs.hmonitor );
+#    endif
     }
 
     bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -83462,27 +88708,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSurfaceProtectedCapabilitiesKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, supportsProtected );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SurfaceProtectedCapabilitiesKHR const & ) const = default;
 #else
     bool operator==( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsProtected == rhs.supportsProtected );
+#  endif
     }
 
     bool operator!=( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -83561,29 +88813,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSwapchainCounterCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SurfaceCounterFlagsEXT const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, surfaceCounters );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SwapchainCounterCreateInfoEXT const & ) const = default;
 #else
     bool operator==( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCounters == rhs.surfaceCounters );
+#  endif
     }
 
     bool operator!=( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -83844,9 +89102,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSwapchainCreateInfoKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::SwapchainCreateFlagsKHR const &,
@@ -83865,7 +89124,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::PresentModeKHR const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::SwapchainKHR const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -83887,18 +89146,30 @@ namespace VULKAN_HPP_NAMESPACE
                        clipped,
                        oldSwapchain );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SwapchainCreateInfoKHR const & ) const = default;
 #else
     bool operator==( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( surface == rhs.surface ) &&
+             ( minImageCount == rhs.minImageCount ) && ( imageFormat == rhs.imageFormat ) &&
+             ( imageColorSpace == rhs.imageColorSpace ) && ( imageExtent == rhs.imageExtent ) &&
+             ( imageArrayLayers == rhs.imageArrayLayers ) && ( imageUsage == rhs.imageUsage ) &&
+             ( imageSharingMode == rhs.imageSharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) &&
+             ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( preTransform == rhs.preTransform ) &&
+             ( compositeAlpha == rhs.compositeAlpha ) && ( presentMode == rhs.presentMode ) &&
+             ( clipped == rhs.clipped ) && ( oldSwapchain == rhs.oldSwapchain );
+#  endif
     }
 
     bool operator!=( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -83995,27 +89266,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkSwapchainDisplayNativeHdrCreateInfoAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, localDimmingEnable );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const & ) const = default;
 #else
     bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingEnable == rhs.localDimmingEnable );
+#  endif
     }
 
     bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -84082,27 +89359,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkTextureLODGatherFormatPropertiesAMD *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Bool32 const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, supportsTextureGatherLODBiasAMD );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( TextureLODGatherFormatPropertiesAMD const & ) const = default;
 #else
     bool operator==( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD );
+#  endif
     }
 
     bool operator!=( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -84238,16 +89522,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkTimelineSemaphoreSubmitInfo *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const uint64_t * const &,
                uint32_t const &,
                const uint64_t * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -84257,18 +89542,27 @@ namespace VULKAN_HPP_NAMESPACE
                        signalSemaphoreValueCount,
                        pSignalSemaphoreValues );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( TimelineSemaphoreSubmitInfo const & ) const = default;
 #else
     bool operator==( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount ) &&
+             ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) &&
+             ( signalSemaphoreValueCount == rhs.signalSemaphoreValueCount ) &&
+             ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues );
+#  endif
     }
 
     bool operator!=( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -84359,27 +89653,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkTraceRaysIndirectCommandKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( width, height, depth );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( TraceRaysIndirectCommandKHR const & ) const = default;
 #else
     bool operator==( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth );
+#  endif
     }
 
     bool operator!=( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -84487,31 +89787,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkValidationCacheCreateInfoEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ValidationCacheCreateFlagsEXT const &,
                size_t const &,
                const void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, initialDataSize, pInitialData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ValidationCacheCreateInfoEXT const & ) const = default;
 #else
     bool operator==( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( initialDataSize == rhs.initialDataSize ) && ( pInitialData == rhs.pInitialData );
+#  endif
     }
 
     bool operator!=( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -84652,16 +89959,17 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkValidationFeaturesEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ValidationFeatureEnableEXT * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ValidationFeatureDisableEXT * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -84671,18 +89979,27 @@ namespace VULKAN_HPP_NAMESPACE
                        disabledValidationFeatureCount,
                        pDisabledValidationFeatures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ValidationFeaturesEXT const & ) const = default;
 #else
     bool operator==( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) &&
+             ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures ) &&
+             ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount ) &&
+             ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures );
+#  endif
     }
 
     bool operator!=( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -84789,30 +90106,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkValidationFlagsEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::ValidationCheckEXT * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, disabledValidationCheckCount, pDisabledValidationChecks );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ValidationFlagsEXT const & ) const = default;
 #else
     bool operator==( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) &&
+             ( pDisabledValidationChecks == rhs.pDisabledValidationChecks );
+#  endif
     }
 
     bool operator!=( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -84916,32 +90241,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVertexInputAttributeDescription2EXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::Format const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, location, binding, format, offset );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputAttributeDescription2EXT const & ) const = default;
 #else
     bool operator==( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( location == rhs.location ) &&
+             ( binding == rhs.binding ) && ( format == rhs.format ) && ( offset == rhs.offset );
+#  endif
     }
 
     bool operator!=( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -85048,32 +90380,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVertexInputBindingDescription2EXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::VertexInputRate const &,
                uint32_t const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, binding, stride, inputRate, divisor );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VertexInputBindingDescription2EXT const & ) const = default;
 #else
     bool operator==( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binding == rhs.binding ) &&
+             ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ) && ( divisor == rhs.divisor );
+#  endif
     }
 
     bool operator!=( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -85161,30 +90500,36 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkViSurfaceCreateInfoNN *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::ViSurfaceCreateFlagsNN const &,
                void * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, window );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( ViSurfaceCreateInfoNN const & ) const = default;
 #  else
     bool operator==( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window );
+#    endif
     }
 
     bool operator!=( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -85288,32 +90633,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoPictureResourceKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Offset2D const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ImageView const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, codedOffset, codedExtent, baseArrayLayer, imageViewBinding );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoPictureResourceKHR const & ) const = default;
 #  else
     bool operator==( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( codedOffset == rhs.codedOffset ) &&
+             ( codedExtent == rhs.codedExtent ) && ( baseArrayLayer == rhs.baseArrayLayer ) &&
+             ( imageViewBinding == rhs.imageViewBinding );
+#    endif
     }
 
     bool operator!=( VideoPictureResourceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -85402,30 +90755,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoReferenceSlotKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                int8_t const &,
                const VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, slotIndex, pPictureResource );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoReferenceSlotKHR const & ) const = default;
 #  else
     bool operator==( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) &&
+             ( pPictureResource == rhs.pPictureResource );
+#    endif
     }
 
     bool operator!=( VideoReferenceSlotKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -85576,9 +90936,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoBeginCodingInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoBeginCodingFlagsKHR const &,
@@ -85587,7 +90948,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -85599,18 +90960,26 @@ namespace VULKAN_HPP_NAMESPACE
                        referenceSlotCount,
                        pReferenceSlots );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoBeginCodingInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( codecQualityPreset == rhs.codecQualityPreset ) && ( videoSession == rhs.videoSession ) &&
+             ( videoSessionParameters == rhs.videoSessionParameters ) &&
+             ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots );
+#    endif
     }
 
     bool operator!=( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -85718,32 +91087,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoBindMemoryKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::DeviceMemory const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &,
                VULKAN_HPP_NAMESPACE::DeviceSize const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoBindMemoryKHR const & ) const = default;
 #  else
     bool operator==( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) &&
+             ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && ( memorySize == rhs.memorySize );
+#    endif
     }
 
     bool operator!=( VideoBindMemoryKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -85821,9 +91197,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoCapabilitiesKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR const &,
@@ -85834,7 +91211,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Extent2D const &,
                uint32_t const &,
                uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -85848,18 +91225,29 @@ namespace VULKAN_HPP_NAMESPACE
                        maxReferencePicturesSlotsCount,
                        maxReferencePicturesActiveCount );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoCapabilitiesKHR const & ) const = default;
 #  else
     bool operator==( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilityFlags == rhs.capabilityFlags ) &&
+             ( minBitstreamBufferOffsetAlignment == rhs.minBitstreamBufferOffsetAlignment ) &&
+             ( minBitstreamBufferSizeAlignment == rhs.minBitstreamBufferSizeAlignment ) &&
+             ( videoPictureExtentGranularity == rhs.videoPictureExtentGranularity ) && ( minExtent == rhs.minExtent ) &&
+             ( maxExtent == rhs.maxExtent ) &&
+             ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) &&
+             ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount );
+#    endif
     }
 
     bool operator!=( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -85944,29 +91332,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoCodingControlInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoCodingControlFlagsKHR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoCodingControlInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+#    endif
     }
 
     bool operator!=( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -86035,31 +91429,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::Offset2D const &,
                VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxLevel, fieldOffsetGranularity, stdExtensionVersion );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264CapabilitiesEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) &&
+             ( fieldOffsetGranularity == rhs.fieldOffsetGranularity ) &&
+             ( stdExtensionVersion == rhs.stdExtensionVersion );
+#    endif
     }
 
     bool operator!=( VideoDecodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -86142,29 +91544,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const StdVideoDecodeH264ReferenceInfo * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pStdReferenceInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264DpbSlotInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
+#    endif
     }
 
     bool operator!=( VideoDecodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -86242,27 +91650,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH264MvcEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, const StdVideoDecodeH264Mvc * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pStdMvc );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264MvcEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdMvc == rhs.pStdMvc );
+#    endif
     }
 
     bool operator!=( VideoDecodeH264MvcEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -86377,31 +91791,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH264PictureInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const StdVideoDecodeH264PictureInfo * const &,
                uint32_t const &,
                const uint32_t * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264PictureInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) &&
+             ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets );
+#    endif
     }
 
     bool operator!=( VideoDecodeH264PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -86492,30 +91913,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH264ProfileEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                StdVideoH264ProfileIdc const &,
                VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stdProfileIdc, pictureLayout );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264ProfileEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) &&
+             ( pictureLayout == rhs.pictureLayout );
+#    endif
     }
 
     bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -86607,30 +92036,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoDecodeH264CreateFlagsEXT const &,
                const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pStdExtensionVersion );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264SessionCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+#    endif
     }
 
     bool operator!=( VideoDecodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -86777,32 +92213,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const StdVideoH264SequenceParameterSet * const &,
                uint32_t const &,
                const StdVideoH264PictureParameterSet * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264SessionParametersAddInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) &&
+             ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+#    endif
     }
 
     bool operator!=( VideoDecodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -86911,31 +92354,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH264SessionParametersCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) &&
+             ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+#    endif
     }
 
     bool operator!=( VideoDecodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -87005,30 +92455,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxLevel, stdExtensionVersion );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265CapabilitiesEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxLevel == rhs.maxLevel ) &&
+             ( stdExtensionVersion == rhs.stdExtensionVersion );
+#    endif
     }
 
     bool operator!=( VideoDecodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -87110,29 +92567,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const StdVideoDecodeH265ReferenceInfo * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pStdReferenceInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265DpbSlotInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo );
+#    endif
     }
 
     bool operator!=( VideoDecodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -87249,31 +92712,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH265PictureInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                StdVideoDecodeH265PictureInfo * const &,
                uint32_t const &,
                const uint32_t * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, pStdPictureInfo, slicesCount, pSlicesDataOffsets );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265PictureInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) &&
+             ( slicesCount == rhs.slicesCount ) && ( pSlicesDataOffsets == rhs.pSlicesDataOffsets );
+#    endif
     }
 
     bool operator!=( VideoDecodeH265PictureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -87354,27 +92824,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH265ProfileEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH265ProfileIdc const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stdProfileIdc );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265ProfileEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
+#    endif
     }
 
     bool operator!=( VideoDecodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -87465,30 +92942,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoDecodeH265CreateFlagsEXT const &,
                const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pStdExtensionVersion );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265SessionCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+#    endif
     }
 
     bool operator!=( VideoDecodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -87635,32 +93119,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const StdVideoH265SequenceParameterSet * const &,
                uint32_t const &,
                const StdVideoH265PictureParameterSet * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265SessionParametersAddInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) &&
+             ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+#    endif
     }
 
     bool operator!=( VideoDecodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -87769,31 +93260,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeH265SessionParametersCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) &&
+             ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+#    endif
     }
 
     bool operator!=( VideoDecodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -87992,9 +93490,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoDecodeInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoDecodeFlagsKHR const &,
@@ -88007,7 +93506,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -88023,18 +93522,28 @@ namespace VULKAN_HPP_NAMESPACE
                        referenceSlotCount,
                        pReferenceSlots );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoDecodeInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( codedOffset == rhs.codedOffset ) && ( codedExtent == rhs.codedExtent ) &&
+             ( srcBuffer == rhs.srcBuffer ) && ( srcBufferOffset == rhs.srcBufferOffset ) &&
+             ( srcBufferRange == rhs.srcBufferRange ) && ( dstPictureResource == rhs.dstPictureResource ) &&
+             ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) &&
+             ( pReferenceSlots == rhs.pReferenceSlots );
+#    endif
     }
 
     bool operator!=( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -88212,9 +93721,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT const &,
@@ -88228,7 +93738,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint8_t const &,
                uint8_t const &,
                VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -88245,18 +93755,29 @@ namespace VULKAN_HPP_NAMESPACE
                        qualityLevelCount,
                        stdExtensionVersion );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264CapabilitiesEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) &&
+             ( minPictureSizeInMbs == rhs.minPictureSizeInMbs ) && ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) &&
+             ( inputImageDataAlignment == rhs.inputImageDataAlignment ) &&
+             ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) &&
+             ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) &&
+             ( qualityLevelCount == rhs.qualityLevelCount ) && ( stdExtensionVersion == rhs.stdExtensionVersion );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -88355,30 +93876,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                int8_t const &,
                const StdVideoEncodeH264PictureInfo * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, slotIndex, pStdPictureInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264DpbSlotInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) &&
+             ( pStdPictureInfo == rhs.pStdPictureInfo );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -88512,32 +94040,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint8_t const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                const uint8_t * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, spsId, emitSpsEnable, ppsIdEntryCount, ppsIdEntries );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264EmitPictureParametersEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsId == rhs.spsId ) &&
+             ( emitSpsEnable == rhs.emitSpsEnable ) && ( ppsIdEntryCount == rhs.ppsIdEntryCount ) &&
+             ( ppsIdEntries == rhs.ppsIdEntries );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -88626,27 +94162,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264FrameSizeEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( frameISize, framePSize, frameBSize );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264FrameSizeEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -88803,9 +94345,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264NaluSliceEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const StdVideoEncodeH264SliceHeader * const &,
@@ -88814,7 +94357,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &,
                uint8_t const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -88826,18 +94369,27 @@ namespace VULKAN_HPP_NAMESPACE
                        refFinalList1EntryCount,
                        pRefFinalList1Entries );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264NaluSliceEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd ) &&
+             ( mbCount == rhs.mbCount ) && ( refFinalList0EntryCount == rhs.refFinalList0EntryCount ) &&
+             ( pRefFinalList0Entries == rhs.pRefFinalList0Entries ) &&
+             ( refFinalList1EntryCount == rhs.refFinalList1EntryCount ) &&
+             ( pRefFinalList1Entries == rhs.pRefFinalList1Entries );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -88921,27 +94473,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264ProfileEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH264ProfileIdc const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stdProfileIdc );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264ProfileEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -89023,27 +94582,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264QpEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<int32_t const &, int32_t const &, int32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( qpI, qpP, qpB );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264QpEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -89153,9 +94718,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -89163,24 +94729,31 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlStructureFlagBitsEXT const &,
                uint8_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, temporalLayerCount );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264RateControlInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) &&
+             ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) &&
+             ( rateControlStructure == rhs.rateControlStructure ) && ( temporalLayerCount == rhs.temporalLayerCount );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -89341,9 +94914,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint8_t const &,
@@ -89355,7 +94929,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -89370,18 +94944,27 @@ namespace VULKAN_HPP_NAMESPACE
                        useMaxFrameSize,
                        maxFrameSize );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264RateControlLayerInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalLayerId == rhs.temporalLayerId ) &&
+             ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) &&
+             ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
+             ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) &&
+             ( maxFrameSize == rhs.maxFrameSize );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -89491,31 +95074,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH264CreateFlagsEXT const &,
                VULKAN_HPP_NAMESPACE::Extent2D const &,
                const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, maxPictureSizeInMbs, pStdExtensionVersion );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264SessionCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( maxPictureSizeInMbs == rhs.maxPictureSizeInMbs ) && ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -89663,32 +95253,39 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const StdVideoH264SequenceParameterSet * const &,
                uint32_t const &,
                const StdVideoH264PictureParameterSet * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264SessionParametersAddInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spsStdCount == rhs.spsStdCount ) &&
+             ( pSpsStd == rhs.pSpsStd ) && ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -89797,31 +95394,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264SessionParametersCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSpsStdCount == rhs.maxSpsStdCount ) &&
+             ( maxPpsStdCount == rhs.maxPpsStdCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -90011,9 +95615,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint8_t const &,
@@ -90023,7 +95628,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT * const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -90036,18 +95641,29 @@ namespace VULKAN_HPP_NAMESPACE
                        pNaluSliceEntries,
                        pCurrentPictureInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH264VclFrameInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( refDefaultFinalList0EntryCount == rhs.refDefaultFinalList0EntryCount ) &&
+             ( pRefDefaultFinalList0Entries == rhs.pRefDefaultFinalList0Entries ) &&
+             ( refDefaultFinalList1EntryCount == rhs.refDefaultFinalList1EntryCount ) &&
+             ( pRefDefaultFinalList1Entries == rhs.pRefDefaultFinalList1Entries ) &&
+             ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) &&
+             ( pCurrentPictureInfo == rhs.pCurrentPictureInfo );
+#    endif
     }
 
     bool operator!=( VideoEncodeH264VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -90224,9 +95840,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsEXT const &,
@@ -90240,7 +95857,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint8_t const &,
                uint8_t const &,
                VULKAN_HPP_NAMESPACE::ExtensionProperties const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -90257,18 +95874,29 @@ namespace VULKAN_HPP_NAMESPACE
                        qualityLevelCount,
                        stdExtensionVersion );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265CapabilitiesEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( inputModeFlags == rhs.inputModeFlags ) && ( outputModeFlags == rhs.outputModeFlags ) &&
+             ( ctbSizes == rhs.ctbSizes ) && ( inputImageDataAlignment == rhs.inputImageDataAlignment ) &&
+             ( maxNumL0ReferenceForP == rhs.maxNumL0ReferenceForP ) &&
+             ( maxNumL0ReferenceForB == rhs.maxNumL0ReferenceForB ) && ( maxNumL1Reference == rhs.maxNumL1Reference ) &&
+             ( maxNumSubLayers == rhs.maxNumSubLayers ) && ( qualityLevelCount == rhs.qualityLevelCount ) &&
+             ( stdExtensionVersion == rhs.stdExtensionVersion );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265CapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -90366,30 +95994,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                int8_t const &,
                const StdVideoEncodeH265ReferenceInfo * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, slotIndex, pStdReferenceInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265DpbSlotInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) &&
+             ( pStdReferenceInfo == rhs.pStdReferenceInfo );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265DpbSlotInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -90544,9 +96179,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint8_t const &,
@@ -90555,23 +96191,30 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                uint32_t const &,
                const uint8_t * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, vpsId, spsId, emitVpsEnable, emitSpsEnable, ppsIdEntryCount, ppsIdEntries );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265EmitPictureParametersEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsId == rhs.vpsId ) && ( spsId == rhs.spsId ) &&
+             ( emitVpsEnable == rhs.emitVpsEnable ) && ( emitSpsEnable == rhs.emitSpsEnable ) &&
+             ( ppsIdEntryCount == rhs.ppsIdEntryCount ) && ( ppsIdEntries == rhs.ppsIdEntries );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265EmitPictureParametersEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -90662,27 +96305,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265FrameSizeEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<uint32_t const &, uint32_t const &, uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( frameISize, framePSize, frameBSize );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265FrameSizeEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265FrameSizeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -90830,9 +96479,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265ReferenceListsEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint8_t const &,
@@ -90840,7 +96490,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint8_t const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT * const &,
                const StdVideoEncodeH265ReferenceModifications * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -90851,18 +96501,28 @@ namespace VULKAN_HPP_NAMESPACE
                        pReferenceList1Entries,
                        pReferenceModifications );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265ReferenceListsEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( referenceList0EntryCount == rhs.referenceList0EntryCount ) &&
+             ( pReferenceList0Entries == rhs.pReferenceList0Entries ) &&
+             ( referenceList1EntryCount == rhs.referenceList1EntryCount ) &&
+             ( pReferenceList1Entries == rhs.pReferenceList1Entries ) &&
+             ( pReferenceModifications == rhs.pReferenceModifications );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265ReferenceListsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -90963,31 +96623,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265NaluSliceEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * const &,
                const StdVideoEncodeH265SliceHeader * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, ctbCount, pReferenceFinalLists, pSliceHeaderStd );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265NaluSliceEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ctbCount == rhs.ctbCount ) &&
+             ( pReferenceFinalLists == rhs.pReferenceFinalLists ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -91068,27 +96735,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265ProfileEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, StdVideoH265ProfileIdc const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, stdProfileIdc );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265ProfileEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -91170,27 +96844,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265QpEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<int32_t const &, int32_t const &, int32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( qpI, qpP, qpB );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265QpEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265QpEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -91300,9 +96980,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -91310,24 +96991,31 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlStructureFlagBitsEXT const &,
                uint8_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, gopFrameCount, idrPeriod, consecutiveBFrameCount, rateControlStructure, subLayerCount );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265RateControlInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( gopFrameCount == rhs.gopFrameCount ) &&
+             ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) &&
+             ( rateControlStructure == rhs.rateControlStructure ) && ( subLayerCount == rhs.subLayerCount );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265RateControlInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -91488,9 +97176,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint8_t const &,
@@ -91502,7 +97191,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &,
                VULKAN_HPP_NAMESPACE::Bool32 const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -91517,18 +97206,27 @@ namespace VULKAN_HPP_NAMESPACE
                        useMaxFrameSize,
                        maxFrameSize );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265RateControlLayerInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( temporalId == rhs.temporalId ) &&
+             ( useInitialRcQp == rhs.useInitialRcQp ) && ( initialRcQp == rhs.initialRcQp ) &&
+             ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) &&
+             ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) &&
+             ( maxFrameSize == rhs.maxFrameSize );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265RateControlLayerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -91629,30 +97327,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeH265CreateFlagsEXT const &,
                const VULKAN_HPP_NAMESPACE::ExtensionProperties * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, pStdExtensionVersion );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265SessionCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( pStdExtensionVersion == rhs.pStdExtensionVersion );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265SessionCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -91831,9 +97536,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -91842,23 +97548,30 @@ namespace VULKAN_HPP_NAMESPACE
                const StdVideoH265SequenceParameterSet * const &,
                uint32_t const &,
                const StdVideoH265PictureParameterSet * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, vpsStdCount, pVpsStd, spsStdCount, pSpsStd, ppsStdCount, pPpsStd );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265SessionParametersAddInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vpsStdCount == rhs.vpsStdCount ) &&
+             ( pVpsStd == rhs.pVpsStd ) && ( spsStdCount == rhs.spsStdCount ) && ( pSpsStd == rhs.pSpsStd ) &&
+             ( ppsStdCount == rhs.ppsStdCount ) && ( pPpsStd == rhs.pPpsStd );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265SessionParametersAddInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -91978,32 +97691,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                uint32_t const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, maxVpsStdCount, maxSpsStdCount, maxPpsStdCount, pParametersAddInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265SessionParametersCreateInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVpsStdCount == rhs.maxVpsStdCount ) &&
+             ( maxSpsStdCount == rhs.maxSpsStdCount ) && ( maxPpsStdCount == rhs.maxPpsStdCount ) &&
+             ( pParametersAddInfo == rhs.pParametersAddInfo );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265SessionParametersCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -92139,33 +97860,41 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT * const &,
                const StdVideoEncodeH265PictureInfo * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie(
         sType, pNext, pReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pCurrentPictureInfo );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeH265VclFrameInfoEXT const & ) const = default;
 #  else
     bool operator==( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pReferenceFinalLists == rhs.pReferenceFinalLists ) &&
+             ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) &&
+             ( pCurrentPictureInfo == rhs.pCurrentPictureInfo );
+#    endif
     }
 
     bool operator!=( VideoEncodeH265VclFrameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -92374,9 +98103,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeFlagsKHR const &,
@@ -92390,7 +98120,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR * const &,
                uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -92407,18 +98137,30 @@ namespace VULKAN_HPP_NAMESPACE
                        pReferenceSlots,
                        precedingExternallyEncodedBytes );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( qualityLevel == rhs.qualityLevel ) && ( codedExtent == rhs.codedExtent ) &&
+             ( dstBitstreamBuffer == rhs.dstBitstreamBuffer ) &&
+             ( dstBitstreamBufferOffset == rhs.dstBitstreamBufferOffset ) &&
+             ( dstBitstreamBufferMaxRange == rhs.dstBitstreamBufferMaxRange ) &&
+             ( srcPictureResource == rhs.srcPictureResource ) && ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) &&
+             ( referenceSlotCount == rhs.referenceSlotCount ) && ( pReferenceSlots == rhs.pReferenceSlots ) &&
+             ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes );
+#    endif
     }
 
     bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -92554,9 +98296,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -92565,7 +98308,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                uint32_t const &,
                uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -92577,18 +98320,27 @@ namespace VULKAN_HPP_NAMESPACE
                        virtualBufferSizeInMs,
                        initialVirtualBufferSizeInMs );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) &&
+             ( maxBitrate == rhs.maxBitrate ) && ( frameRateNumerator == rhs.frameRateNumerator ) &&
+             ( frameRateDenominator == rhs.frameRateDenominator ) &&
+             ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) &&
+             ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs );
+#    endif
     }
 
     bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -92725,32 +98477,40 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEncodeRateControlInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeRateControlFlagsKHR const &,
                VULKAN_HPP_NAMESPACE::VideoEncodeRateControlModeFlagBitsKHR const &,
                uint8_t const &,
                const VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayerConfigs );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( rateControlMode == rhs.rateControlMode ) && ( layerCount == rhs.layerCount ) &&
+             ( pLayerConfigs == rhs.pLayerConfigs );
+#    endif
     }
 
     bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -92833,29 +98593,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoEndCodingInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoEndCodingFlagsKHR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoEndCodingInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags );
+#    endif
     }
 
     bool operator!=( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -92917,27 +98683,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoFormatPropertiesKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, void * const &, VULKAN_HPP_NAMESPACE::Format const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, format );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoFormatPropertiesKHR const & ) const = default;
 #  else
     bool operator==( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format );
+#    endif
     }
 
     bool operator!=( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -93025,30 +98797,37 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoGetMemoryPropertiesKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                VULKAN_HPP_NAMESPACE::MemoryRequirements2 * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, memoryBindIndex, pMemoryRequirements );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoGetMemoryPropertiesKHR const & ) const = default;
 #  else
     bool operator==( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) &&
+             ( pMemoryRequirements == rhs.pMemoryRequirements );
+#    endif
     }
 
     bool operator!=( VideoGetMemoryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -93130,29 +98909,35 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoQueueFamilyProperties2KHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                void * const &,
                VULKAN_HPP_NAMESPACE::VideoCodecOperationFlagsKHR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, videoCodecOperations );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoQueueFamilyProperties2KHR const & ) const = default;
 #  else
     bool operator==( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperations == rhs.videoCodecOperations );
+#    endif
     }
 
     bool operator!=( VideoQueueFamilyProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -93295,9 +99080,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoSessionCreateInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -93308,7 +99094,7 @@ namespace VULKAN_HPP_NAMESPACE
                VULKAN_HPP_NAMESPACE::Format const &,
                uint32_t const &,
                uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -93322,18 +99108,28 @@ namespace VULKAN_HPP_NAMESPACE
                        maxReferencePicturesSlotsCount,
                        maxReferencePicturesActiveCount );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoSessionCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) &&
+             ( flags == rhs.flags ) && ( pVideoProfile == rhs.pVideoProfile ) &&
+             ( pictureFormat == rhs.pictureFormat ) && ( maxCodedExtent == rhs.maxCodedExtent ) &&
+             ( referencePicturesFormat == rhs.referencePicturesFormat ) &&
+             ( maxReferencePicturesSlotsCount == rhs.maxReferencePicturesSlotsCount ) &&
+             ( maxReferencePicturesActiveCount == rhs.maxReferencePicturesActiveCount );
+#    endif
     }
 
     bool operator!=( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -93431,30 +99227,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoSessionParametersCreateInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const &,
                VULKAN_HPP_NAMESPACE::VideoSessionKHR const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, videoSessionParametersTemplate, videoSession );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoSessionParametersCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( videoSessionParametersTemplate == rhs.videoSessionParametersTemplate ) &&
+             ( videoSession == rhs.videoSession );
+#    endif
     }
 
     bool operator!=( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -93537,27 +99341,33 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkVideoSessionParametersUpdateInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, updateSequenceCount );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( VideoSessionParametersUpdateInfoKHR const & ) const = default;
 #  else
     bool operator==( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( updateSequenceCount == rhs.updateSequenceCount );
+#    endif
     }
 
     bool operator!=( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -93652,31 +99462,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWaylandSurfaceCreateInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateFlagsKHR const &,
                struct wl_display * const &,
                struct wl_surface * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, display, surface );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WaylandSurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( display == rhs.display ) &&
+             ( surface == rhs.surface );
+#    endif
     }
 
     bool operator!=( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -93921,9 +99738,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -93933,7 +99751,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
                const uint64_t * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -93946,18 +99764,26 @@ namespace VULKAN_HPP_NAMESPACE
                        pReleaseSyncs,
                        pReleaseKeys );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const & ) const = default;
 #  else
     bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) &&
+             ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) &&
+             ( pAcquireTimeouts == rhs.pAcquireTimeouts ) && ( releaseCount == rhs.releaseCount ) &&
+             ( pReleaseSyncs == rhs.pReleaseSyncs ) && ( pReleaseKeys == rhs.pReleaseKeys );
+#    endif
     }
 
     bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -94207,9 +100033,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWin32KeyedMutexAcquireReleaseInfoNV *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
@@ -94219,7 +100046,7 @@ namespace VULKAN_HPP_NAMESPACE
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::DeviceMemory * const &,
                const uint64_t * const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -94232,18 +100059,27 @@ namespace VULKAN_HPP_NAMESPACE
                        pReleaseSyncs,
                        pReleaseKeys );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const & ) const = default;
 #  else
     bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) &&
+             ( pAcquireSyncs == rhs.pAcquireSyncs ) && ( pAcquireKeys == rhs.pAcquireKeys ) &&
+             ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) &&
+             ( releaseCount == rhs.releaseCount ) && ( pReleaseSyncs == rhs.pReleaseSyncs ) &&
+             ( pReleaseKeys == rhs.pReleaseKeys );
+#    endif
     }
 
     bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -94344,31 +100180,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWin32SurfaceCreateInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::Win32SurfaceCreateFlagsKHR const &,
                HINSTANCE const &,
                HWND const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, hinstance, hwnd );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( Win32SurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( hinstance == rhs.hinstance ) && ( hwnd == rhs.hwnd );
+#    endif
     }
 
     bool operator!=( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -94575,9 +100418,10 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWriteDescriptorSet *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::DescriptorSet const &,
@@ -94588,7 +100432,7 @@ namespace VULKAN_HPP_NAMESPACE
                const VULKAN_HPP_NAMESPACE::DescriptorImageInfo * const &,
                const VULKAN_HPP_NAMESPACE::DescriptorBufferInfo * const &,
                const VULKAN_HPP_NAMESPACE::BufferView * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType,
@@ -94602,18 +100446,27 @@ namespace VULKAN_HPP_NAMESPACE
                        pBufferInfo,
                        pTexelBufferView );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WriteDescriptorSet const & ) const = default;
 #else
     bool operator==( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dstSet == rhs.dstSet ) &&
+             ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) &&
+             ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) &&
+             ( pImageInfo == rhs.pImageInfo ) && ( pBufferInfo == rhs.pBufferInfo ) &&
+             ( pTexelBufferView == rhs.pTexelBufferView );
+#  endif
     }
 
     bool operator!=( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -94731,30 +100584,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureKHR *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::AccelerationStructureKHR * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const & ) const = default;
 #else
     bool operator==( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( accelerationStructureCount == rhs.accelerationStructureCount ) &&
+             ( pAccelerationStructures == rhs.pAccelerationStructures );
+#  endif
     }
 
     bool operator!=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -94869,30 +100730,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWriteDescriptorSetAccelerationStructureNV *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                uint32_t const &,
                const VULKAN_HPP_NAMESPACE::AccelerationStructureNV * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WriteDescriptorSetAccelerationStructureNV const & ) const = default;
 #else
     bool operator==( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
+             ( accelerationStructureCount == rhs.accelerationStructureCount ) &&
+             ( pAccelerationStructures == rhs.pAccelerationStructures );
+#  endif
     }
 
     bool operator!=( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -95003,28 +100872,34 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT *>( this );
     }
 
-#if 14 <= VULKAN_HPP_CPP_VERSION
+#if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#  if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#else
+#  else
     std::
       tuple<VULKAN_HPP_NAMESPACE::StructureType const &, const void * const &, uint32_t const &, const void * const &>
-#endif
+#  endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, dataSize, pData );
     }
+#endif
 
 #if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( WriteDescriptorSetInlineUniformBlockEXT const & ) const = default;
 #else
     bool operator==( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#  else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData );
+#  endif
     }
 
     bool operator!=( WriteDescriptorSetInlineUniformBlockEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #endif
 
@@ -95120,31 +100995,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkXcbSurfaceCreateInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::XcbSurfaceCreateFlagsKHR const &,
                xcb_connection_t * const &,
                xcb_window_t const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, connection, window );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( XcbSurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) &&
+             ( connection == rhs.connection ) && ( memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ) == 0 );
+#    endif
     }
 
     bool operator!=( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif
 
@@ -95239,31 +101121,38 @@ namespace VULKAN_HPP_NAMESPACE
       return *reinterpret_cast<VkXlibSurfaceCreateInfoKHR *>( this );
     }
 
-#  if 14 <= VULKAN_HPP_CPP_VERSION
+#  if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
+#    if 14 <= VULKAN_HPP_CPP_VERSION
     auto
-#  else
+#    else
     std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
                const void * const &,
                VULKAN_HPP_NAMESPACE::XlibSurfaceCreateFlagsKHR const &,
                Display * const &,
                Window const &>
-#  endif
+#    endif
       reflect() const VULKAN_HPP_NOEXCEPT
     {
       return std::tie( sType, pNext, flags, dpy, window );
     }
+#  endif
 
 #  if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
     auto operator<=>( XlibSurfaceCreateInfoKHR const & ) const = default;
 #  else
     bool operator==( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
+#    if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
       return this->reflect() == rhs.reflect();
+#    else
+      return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dpy == rhs.dpy ) &&
+             ( memcmp( &window, &rhs.window, sizeof( Window ) ) == 0 );
+#    endif
     }
 
     bool operator!=( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT
     {
-      return this->reflect() != rhs.reflect();
+      return !operator==( rhs );
     }
 #  endif