vulkan-api-0.1.0.0: src-gen/Graphics/Vulkan/Types/Bitmasks.hs

{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE Strict                     #-}
module Graphics.Vulkan.Types.Bitmasks
       (VkAndroidSurfaceCreateFlagsKHR(..), VkBufferViewCreateFlags(..),
        VkCommandPoolTrimFlagsKHR(..), VkDescriptorPoolResetFlags(..),
        VkDescriptorUpdateTemplateCreateFlagsKHR(..),
        VkDeviceCreateFlags(..), VkDeviceQueueCreateFlags(..),
        VkDisplayModeCreateFlagsKHR(..),
        VkDisplaySurfaceCreateFlagsKHR(..), VkEventCreateFlags(..),
        VkFramebufferCreateFlags(..), VkIOSSurfaceCreateFlagsMVK(..),
        VkImageViewCreateFlags(..), VkInstanceCreateFlags(..),
        VkMacOSSurfaceCreateFlagsMVK(..), VkMemoryMapFlags(..),
        VkMirSurfaceCreateFlagsKHR(..), VkPipelineCacheCreateFlags(..),
        VkPipelineColorBlendStateCreateFlags(..),
        VkPipelineCoverageModulationStateCreateFlagsNV(..),
        VkPipelineCoverageToColorStateCreateFlagsNV(..),
        VkPipelineDepthStencilStateCreateFlags(..),
        VkPipelineDiscardRectangleStateCreateFlagsEXT(..),
        VkPipelineDynamicStateCreateFlags(..),
        VkPipelineInputAssemblyStateCreateFlags(..),
        VkPipelineLayoutCreateFlags(..),
        VkPipelineMultisampleStateCreateFlags(..),
        VkPipelineRasterizationConservativeStateCreateFlagsEXT(..),
        VkPipelineRasterizationStateCreateFlags(..),
        VkPipelineShaderStageCreateFlags(..),
        VkPipelineTessellationStateCreateFlags(..),
        VkPipelineVertexInputStateCreateFlags(..),
        VkPipelineViewportStateCreateFlags(..),
        VkPipelineViewportSwizzleStateCreateFlagsNV(..),
        VkQueryPoolCreateFlags(..), VkRenderPassCreateFlags(..),
        VkSamplerCreateFlags(..), VkSemaphoreCreateFlags(..),
        VkShaderModuleCreateFlags(..), VkValidationCacheCreateFlagsEXT(..),
        VkViSurfaceCreateFlagsNN(..), VkWaylandSurfaceCreateFlagsKHR(..),
        VkWin32SurfaceCreateFlagsKHR(..), VkXcbSurfaceCreateFlagsKHR(..),
        VkXlibSurfaceCreateFlagsKHR(..))
       where
import           Data.Bits                       (Bits, FiniteBits)
import           Data.Coerce                     (coerce)
import           Data.Data                       (Data)
import           Foreign.Storable                (Storable)
import           GHC.Generics                    (Generic)
import           Graphics.Vulkan.Types.BaseTypes (VkFlags)

newtype VkAndroidSurfaceCreateFlagsKHR = VkAndroidSurfaceCreateFlagsKHR VkFlags
                                           deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                     FiniteBits, Storable, Real, Data, Generic)

instance Show VkAndroidSurfaceCreateFlagsKHR where
        {-# INLINE show #-}
        show (VkAndroidSurfaceCreateFlagsKHR x) = show x

instance Read VkAndroidSurfaceCreateFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkBufferViewCreateFlags = VkBufferViewCreateFlags VkFlags
                                    deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                              FiniteBits, Storable, Real, Data, Generic)

instance Show VkBufferViewCreateFlags where
        {-# INLINE show #-}
        show (VkBufferViewCreateFlags x) = show x

instance Read VkBufferViewCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkCommandPoolTrimFlagsKHR = VkCommandPoolTrimFlagsKHR VkFlags
                                      deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                FiniteBits, Storable, Real, Data, Generic)

instance Show VkCommandPoolTrimFlagsKHR where
        {-# INLINE show #-}
        show (VkCommandPoolTrimFlagsKHR x) = show x

instance Read VkCommandPoolTrimFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkDescriptorPoolResetFlags = VkDescriptorPoolResetFlags VkFlags
                                       deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                 FiniteBits, Storable, Real, Data, Generic)

instance Show VkDescriptorPoolResetFlags where
        {-# INLINE show #-}
        show (VkDescriptorPoolResetFlags x) = show x

instance Read VkDescriptorPoolResetFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkDescriptorUpdateTemplateCreateFlagsKHR = VkDescriptorUpdateTemplateCreateFlagsKHR VkFlags
                                                     deriving (Eq, Ord, Num, Bounded, Enum,
                                                               Integral, Bits, FiniteBits, Storable,
                                                               Real, Data, Generic)

instance Show VkDescriptorUpdateTemplateCreateFlagsKHR where
        {-# INLINE show #-}
        show (VkDescriptorUpdateTemplateCreateFlagsKHR x) = show x

instance Read VkDescriptorUpdateTemplateCreateFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkDeviceCreateFlags = VkDeviceCreateFlags VkFlags
                                deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits,
                                          Storable, Real, Data, Generic)

instance Show VkDeviceCreateFlags where
        {-# INLINE show #-}
        show (VkDeviceCreateFlags x) = show x

instance Read VkDeviceCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkDeviceQueueCreateFlags = VkDeviceQueueCreateFlags VkFlags
                                     deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                               FiniteBits, Storable, Real, Data, Generic)

instance Show VkDeviceQueueCreateFlags where
        {-# INLINE show #-}
        show (VkDeviceQueueCreateFlags x) = show x

instance Read VkDeviceQueueCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkDisplayModeCreateFlagsKHR = VkDisplayModeCreateFlagsKHR VkFlags
                                        deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                  FiniteBits, Storable, Real, Data, Generic)

instance Show VkDisplayModeCreateFlagsKHR where
        {-# INLINE show #-}
        show (VkDisplayModeCreateFlagsKHR x) = show x

instance Read VkDisplayModeCreateFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkDisplaySurfaceCreateFlagsKHR = VkDisplaySurfaceCreateFlagsKHR VkFlags
                                           deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                     FiniteBits, Storable, Real, Data, Generic)

instance Show VkDisplaySurfaceCreateFlagsKHR where
        {-# INLINE show #-}
        show (VkDisplaySurfaceCreateFlagsKHR x) = show x

instance Read VkDisplaySurfaceCreateFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkEventCreateFlags = VkEventCreateFlags VkFlags
                               deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits,
                                         Storable, Real, Data, Generic)

instance Show VkEventCreateFlags where
        {-# INLINE show #-}
        show (VkEventCreateFlags x) = show x

instance Read VkEventCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkFramebufferCreateFlags = VkFramebufferCreateFlags VkFlags
                                     deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                               FiniteBits, Storable, Real, Data, Generic)

instance Show VkFramebufferCreateFlags where
        {-# INLINE show #-}
        show (VkFramebufferCreateFlags x) = show x

instance Read VkFramebufferCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkIOSSurfaceCreateFlagsMVK = VkIOSSurfaceCreateFlagsMVK VkFlags
                                       deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                 FiniteBits, Storable, Real, Data, Generic)

instance Show VkIOSSurfaceCreateFlagsMVK where
        {-# INLINE show #-}
        show (VkIOSSurfaceCreateFlagsMVK x) = show x

instance Read VkIOSSurfaceCreateFlagsMVK where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkImageViewCreateFlags = VkImageViewCreateFlags VkFlags
                                   deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                             FiniteBits, Storable, Real, Data, Generic)

instance Show VkImageViewCreateFlags where
        {-# INLINE show #-}
        show (VkImageViewCreateFlags x) = show x

instance Read VkImageViewCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkInstanceCreateFlags = VkInstanceCreateFlags VkFlags
                                  deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits,
                                            Storable, Real, Data, Generic)

instance Show VkInstanceCreateFlags where
        {-# INLINE show #-}
        show (VkInstanceCreateFlags x) = show x

instance Read VkInstanceCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkMacOSSurfaceCreateFlagsMVK = VkMacOSSurfaceCreateFlagsMVK VkFlags
                                         deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                   FiniteBits, Storable, Real, Data, Generic)

instance Show VkMacOSSurfaceCreateFlagsMVK where
        {-# INLINE show #-}
        show (VkMacOSSurfaceCreateFlagsMVK x) = show x

instance Read VkMacOSSurfaceCreateFlagsMVK where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkMemoryMapFlags = VkMemoryMapFlags VkFlags
                             deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits,
                                       Storable, Real, Data, Generic)

instance Show VkMemoryMapFlags where
        {-# INLINE show #-}
        show (VkMemoryMapFlags x) = show x

instance Read VkMemoryMapFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkMirSurfaceCreateFlagsKHR = VkMirSurfaceCreateFlagsKHR VkFlags
                                       deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                 FiniteBits, Storable, Real, Data, Generic)

instance Show VkMirSurfaceCreateFlagsKHR where
        {-# INLINE show #-}
        show (VkMirSurfaceCreateFlagsKHR x) = show x

instance Read VkMirSurfaceCreateFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineCacheCreateFlags = VkPipelineCacheCreateFlags VkFlags
                                       deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                 FiniteBits, Storable, Real, Data, Generic)

instance Show VkPipelineCacheCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineCacheCreateFlags x) = show x

instance Read VkPipelineCacheCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineColorBlendStateCreateFlags = VkPipelineColorBlendStateCreateFlags VkFlags
                                                 deriving (Eq, Ord, Num, Bounded, Enum, Integral,
                                                           Bits, FiniteBits, Storable, Real, Data,
                                                           Generic)

instance Show VkPipelineColorBlendStateCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineColorBlendStateCreateFlags x) = show x

instance Read VkPipelineColorBlendStateCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineCoverageModulationStateCreateFlagsNV = VkPipelineCoverageModulationStateCreateFlagsNV VkFlags
                                                           deriving (Eq, Ord, Num, Bounded, Enum,
                                                                     Integral, Bits, FiniteBits,
                                                                     Storable, Real, Data, Generic)

instance Show VkPipelineCoverageModulationStateCreateFlagsNV where
        {-# INLINE show #-}
        show (VkPipelineCoverageModulationStateCreateFlagsNV x) = show x

instance Read VkPipelineCoverageModulationStateCreateFlagsNV where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineCoverageToColorStateCreateFlagsNV = VkPipelineCoverageToColorStateCreateFlagsNV VkFlags
                                                        deriving (Eq, Ord, Num, Bounded, Enum,
                                                                  Integral, Bits, FiniteBits,
                                                                  Storable, Real, Data, Generic)

instance Show VkPipelineCoverageToColorStateCreateFlagsNV where
        {-# INLINE show #-}
        show (VkPipelineCoverageToColorStateCreateFlagsNV x) = show x

instance Read VkPipelineCoverageToColorStateCreateFlagsNV where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineDepthStencilStateCreateFlags = VkPipelineDepthStencilStateCreateFlags VkFlags
                                                   deriving (Eq, Ord, Num, Bounded, Enum, Integral,
                                                             Bits, FiniteBits, Storable, Real, Data,
                                                             Generic)

instance Show VkPipelineDepthStencilStateCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineDepthStencilStateCreateFlags x) = show x

instance Read VkPipelineDepthStencilStateCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineDiscardRectangleStateCreateFlagsEXT = VkPipelineDiscardRectangleStateCreateFlagsEXT VkFlags
                                                          deriving (Eq, Ord, Num, Bounded, Enum,
                                                                    Integral, Bits, FiniteBits,
                                                                    Storable, Real, Data, Generic)

instance Show VkPipelineDiscardRectangleStateCreateFlagsEXT where
        {-# INLINE show #-}
        show (VkPipelineDiscardRectangleStateCreateFlagsEXT x) = show x

instance Read VkPipelineDiscardRectangleStateCreateFlagsEXT where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineDynamicStateCreateFlags = VkPipelineDynamicStateCreateFlags VkFlags
                                              deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                        FiniteBits, Storable, Real, Data, Generic)

instance Show VkPipelineDynamicStateCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineDynamicStateCreateFlags x) = show x

instance Read VkPipelineDynamicStateCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineInputAssemblyStateCreateFlags = VkPipelineInputAssemblyStateCreateFlags VkFlags
                                                    deriving (Eq, Ord, Num, Bounded, Enum, Integral,
                                                              Bits, FiniteBits, Storable, Real,
                                                              Data, Generic)

instance Show VkPipelineInputAssemblyStateCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineInputAssemblyStateCreateFlags x) = show x

instance Read VkPipelineInputAssemblyStateCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineLayoutCreateFlags = VkPipelineLayoutCreateFlags VkFlags
                                        deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                  FiniteBits, Storable, Real, Data, Generic)

instance Show VkPipelineLayoutCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineLayoutCreateFlags x) = show x

instance Read VkPipelineLayoutCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineMultisampleStateCreateFlags = VkPipelineMultisampleStateCreateFlags VkFlags
                                                  deriving (Eq, Ord, Num, Bounded, Enum, Integral,
                                                            Bits, FiniteBits, Storable, Real, Data,
                                                            Generic)

instance Show VkPipelineMultisampleStateCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineMultisampleStateCreateFlags x) = show x

instance Read VkPipelineMultisampleStateCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineRasterizationConservativeStateCreateFlagsEXT = VkPipelineRasterizationConservativeStateCreateFlagsEXT VkFlags
                                                                   deriving (Eq, Ord, Num, Bounded,
                                                                             Enum, Integral, Bits,
                                                                             FiniteBits, Storable,
                                                                             Real, Data, Generic)

instance Show
           VkPipelineRasterizationConservativeStateCreateFlagsEXT
         where
        {-# INLINE show #-}
        show (VkPipelineRasterizationConservativeStateCreateFlagsEXT x)
          = show x

instance Read
           VkPipelineRasterizationConservativeStateCreateFlagsEXT
         where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineRasterizationStateCreateFlags = VkPipelineRasterizationStateCreateFlags VkFlags
                                                    deriving (Eq, Ord, Num, Bounded, Enum, Integral,
                                                              Bits, FiniteBits, Storable, Real,
                                                              Data, Generic)

instance Show VkPipelineRasterizationStateCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineRasterizationStateCreateFlags x) = show x

instance Read VkPipelineRasterizationStateCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineShaderStageCreateFlags = VkPipelineShaderStageCreateFlags VkFlags
                                             deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                       FiniteBits, Storable, Real, Data, Generic)

instance Show VkPipelineShaderStageCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineShaderStageCreateFlags x) = show x

instance Read VkPipelineShaderStageCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineTessellationStateCreateFlags = VkPipelineTessellationStateCreateFlags VkFlags
                                                   deriving (Eq, Ord, Num, Bounded, Enum, Integral,
                                                             Bits, FiniteBits, Storable, Real, Data,
                                                             Generic)

instance Show VkPipelineTessellationStateCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineTessellationStateCreateFlags x) = show x

instance Read VkPipelineTessellationStateCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineVertexInputStateCreateFlags = VkPipelineVertexInputStateCreateFlags VkFlags
                                                  deriving (Eq, Ord, Num, Bounded, Enum, Integral,
                                                            Bits, FiniteBits, Storable, Real, Data,
                                                            Generic)

instance Show VkPipelineVertexInputStateCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineVertexInputStateCreateFlags x) = show x

instance Read VkPipelineVertexInputStateCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineViewportStateCreateFlags = VkPipelineViewportStateCreateFlags VkFlags
                                               deriving (Eq, Ord, Num, Bounded, Enum, Integral,
                                                         Bits, FiniteBits, Storable, Real, Data,
                                                         Generic)

instance Show VkPipelineViewportStateCreateFlags where
        {-# INLINE show #-}
        show (VkPipelineViewportStateCreateFlags x) = show x

instance Read VkPipelineViewportStateCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkPipelineViewportSwizzleStateCreateFlagsNV = VkPipelineViewportSwizzleStateCreateFlagsNV VkFlags
                                                        deriving (Eq, Ord, Num, Bounded, Enum,
                                                                  Integral, Bits, FiniteBits,
                                                                  Storable, Real, Data, Generic)

instance Show VkPipelineViewportSwizzleStateCreateFlagsNV where
        {-# INLINE show #-}
        show (VkPipelineViewportSwizzleStateCreateFlagsNV x) = show x

instance Read VkPipelineViewportSwizzleStateCreateFlagsNV where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkQueryPoolCreateFlags = VkQueryPoolCreateFlags VkFlags
                                   deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                             FiniteBits, Storable, Real, Data, Generic)

instance Show VkQueryPoolCreateFlags where
        {-# INLINE show #-}
        show (VkQueryPoolCreateFlags x) = show x

instance Read VkQueryPoolCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkRenderPassCreateFlags = VkRenderPassCreateFlags VkFlags
                                    deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                              FiniteBits, Storable, Real, Data, Generic)

instance Show VkRenderPassCreateFlags where
        {-# INLINE show #-}
        show (VkRenderPassCreateFlags x) = show x

instance Read VkRenderPassCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkSamplerCreateFlags = VkSamplerCreateFlags VkFlags
                                 deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits, FiniteBits,
                                           Storable, Real, Data, Generic)

instance Show VkSamplerCreateFlags where
        {-# INLINE show #-}
        show (VkSamplerCreateFlags x) = show x

instance Read VkSamplerCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkSemaphoreCreateFlags = VkSemaphoreCreateFlags VkFlags
                                   deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                             FiniteBits, Storable, Real, Data, Generic)

instance Show VkSemaphoreCreateFlags where
        {-# INLINE show #-}
        show (VkSemaphoreCreateFlags x) = show x

instance Read VkSemaphoreCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkShaderModuleCreateFlags = VkShaderModuleCreateFlags VkFlags
                                      deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                FiniteBits, Storable, Real, Data, Generic)

instance Show VkShaderModuleCreateFlags where
        {-# INLINE show #-}
        show (VkShaderModuleCreateFlags x) = show x

instance Read VkShaderModuleCreateFlags where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkValidationCacheCreateFlagsEXT = VkValidationCacheCreateFlagsEXT VkFlags
                                            deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                      FiniteBits, Storable, Real, Data, Generic)

instance Show VkValidationCacheCreateFlagsEXT where
        {-# INLINE show #-}
        show (VkValidationCacheCreateFlagsEXT x) = show x

instance Read VkValidationCacheCreateFlagsEXT where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkViSurfaceCreateFlagsNN = VkViSurfaceCreateFlagsNN VkFlags
                                     deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                               FiniteBits, Storable, Real, Data, Generic)

instance Show VkViSurfaceCreateFlagsNN where
        {-# INLINE show #-}
        show (VkViSurfaceCreateFlagsNN x) = show x

instance Read VkViSurfaceCreateFlagsNN where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkWaylandSurfaceCreateFlagsKHR = VkWaylandSurfaceCreateFlagsKHR VkFlags
                                           deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                     FiniteBits, Storable, Real, Data, Generic)

instance Show VkWaylandSurfaceCreateFlagsKHR where
        {-# INLINE show #-}
        show (VkWaylandSurfaceCreateFlagsKHR x) = show x

instance Read VkWaylandSurfaceCreateFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkWin32SurfaceCreateFlagsKHR = VkWin32SurfaceCreateFlagsKHR VkFlags
                                         deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                   FiniteBits, Storable, Real, Data, Generic)

instance Show VkWin32SurfaceCreateFlagsKHR where
        {-# INLINE show #-}
        show (VkWin32SurfaceCreateFlagsKHR x) = show x

instance Read VkWin32SurfaceCreateFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkXcbSurfaceCreateFlagsKHR = VkXcbSurfaceCreateFlagsKHR VkFlags
                                       deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                 FiniteBits, Storable, Real, Data, Generic)

instance Show VkXcbSurfaceCreateFlagsKHR where
        {-# INLINE show #-}
        show (VkXcbSurfaceCreateFlagsKHR x) = show x

instance Read VkXcbSurfaceCreateFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)

newtype VkXlibSurfaceCreateFlagsKHR = VkXlibSurfaceCreateFlagsKHR VkFlags
                                        deriving (Eq, Ord, Num, Bounded, Enum, Integral, Bits,
                                                  FiniteBits, Storable, Real, Data, Generic)

instance Show VkXlibSurfaceCreateFlagsKHR where
        {-# INLINE show #-}
        show (VkXlibSurfaceCreateFlagsKHR x) = show x

instance Read VkXlibSurfaceCreateFlagsKHR where
        {-# INLINE readsPrec #-}
        readsPrec = coerce (readsPrec :: Int -> ReadS VkFlags)